ম্যাট্রিক্স নর্ম, কন্ডিশন নাম্বার ও এরর বাউন্ড

def inf_norm(A):
    # ম্যাট্রিক্স ইনফিনিটি-নর্ম = সারিগুলোর absolute-value যোগফলের মধ্যে সর্বোচ্চটি
    return max(sum(abs(v) for v in row) for row in A)

def mat_inverse(A):
    n = len(A)
    M = [A[i][:] + [1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]

    for col in range(n):
        pivot_row = max(range(col, n), key=lambda r: abs(M[r][col]))
        if abs(M[pivot_row][col]) < 1e-15:
            raise ValueError("ম্যাট্রিক্সটি singular -- inverse নেই")
        M[col], M[pivot_row] = M[pivot_row], M[col]

        pivot_val = M[col][col]
        M[col] = [v / pivot_val for v in M[col]]

        for r in range(n):
            if r != col:
                factor = M[r][col]
                M[r] = [M[r][k] - factor * M[col][k] for k in range(2 * n)]

    return [row[n:] for row in M]

def mat_mult(X, Y):
    n, m, p = len(X), len(Y), len(Y[0])
    return [[sum(X[i][t] * Y[t][j] for t in range(m)) for j in range(p)] for i in range(n)]

def condition_number(A):
    A_inv = mat_inverse(A)
    return inf_norm(A) * inf_norm(A_inv), A_inv

print("=== ভালোভাবে-কন্ডিশনড (well-conditioned) ম্যাট্রিক্স ===")
A_good = [[4.0, 1.0], [2.0, 3.0]]
cond_good, Ainv_good = condition_number(A_good)
print("A =", A_good)
print("||A||_inf =", inf_norm(A_good))
print("A^-1 =", [[round(v, 6) for v in row] for row in Ainv_good])
print("||A^-1||_inf =", round(inf_norm(Ainv_good), 6))
print(f"কন্ডিশন নাম্বার κ(A) = {cond_good:.6f}")

print()
print("=== খারাপভাবে-কন্ডিশনড (ill-conditioned) ম্যাট্রিক্স ===")
A_bad = [[1.0, 1.0], [1.0, 1.0001]]
cond_bad, Ainv_bad = condition_number(A_bad)
print("A =", A_bad)
print("||A||_inf =", inf_norm(A_bad))
print("A^-1 =", [[round(v, 4) for v in row] for row in Ainv_bad])
print("||A^-1||_inf =", round(inf_norm(Ainv_bad), 4))
print(f"কন্ডিশন নাম্বার κ(A) = {cond_bad:.4f}")

print()
print(f"তুলনা: κ(A_good) = {cond_good:.4f}   বনাম   κ(A_bad) = {cond_bad:.2f}")
print(f"অনুপাত = {cond_bad / cond_good:.1f}x")

def solve_2x2(A, b):
    det = A[0][0]*A[1][1] - A[0][1]*A[1][0]
    x0 = (b[0]*A[1][1] - A[0][1]*b[1]) / det
    x1 = (A[0][0]*b[1] - b[0]*A[1][0]) / det
    return [x0, x1]

b1 = [2.0, 2.0]
b2 = [2.0, 2.001]   # b-তে মাত্র 0.001 পার্থক্য

print()
print("=== ছোট perturbation-এর প্রভাব (b-তে 0.001 পরিবর্তন) ===")
for name, A in [("good", A_good), ("bad", A_bad)]:
    x1 = solve_2x2(A, b1)
    x2 = solve_2x2(A, b2)
    change = max(abs(x1[i]-x2[i]) for i in range(2))
    print(f"{name}: x পরিবর্তন = {change:.6f}")

=== ভালোভাবে-কন্ডিশনড (well-conditioned) ম্যাট্রিক্স ===
A = [[4.0, 1.0], [2.0, 3.0]]
||A||_inf = 5.0
A^-1 = [[0.3, -0.1], [-0.2, 0.4]]
||A^-1||_inf = 0.6
কন্ডিশন নাম্বার κ(A) = 3.000000

=== খারাপভাবে-কন্ডিশনড (ill-conditioned) ম্যাট্রিক্স ===
A = [[1.0, 1.0], [1.0, 1.0001]]
||A||_inf = 2.0000999999999998
A^-1 = [[10001.0, -10000.0], [-10000.0, 10000.0]]
||A^-1||_inf = 20001.0
কন্ডিশন নাম্বার κ(A) = 40004.0001

তুলনা: κ(A_good) = 3.0000   বনাম   κ(A_bad) = 40004.00
অনুপাত = 13334.7x

=== ছোট perturbation-এর প্রভাব (b-তে 0.001 পরিবর্তন) ===
good: x পরিবর্তন = 0.000400
bad: x পরিবর্তন = 10.000000