[THOUGHT] Let me break down this problem step by step:

1. First, I need to find the eigenvalues of matrix A and compute e^A
2. Then compute the matrix C = B * e^(A_x) and find min/max of the Rayleigh quotient
3. Find the critical point of f(z) and compute the norm

Let me start by computing the eigenvalues of A and the matrix exponential e^A. [/THOUGHT] [PYTHON] import numpy as np from scipy.linalg import expm, eig import sympy as sp from sympy import symbols, Matrix, exp, cos, sin, E, sqrt, simplify, Rational

Part 1: Matrix A

A = np.array([[-1, 4, 4], [-5, 8, 10], [3, -3, -5]], dtype=float)

Find eigenvalues of A

eigenvalues_A, eigenvectors_A = np.linalg.eig(A) print("Eigenvalues of A:", eigenvalues_A)

Compute matrix exponential e^A

exp_A = expm(A) print("\ne^A =") print(exp_A)

Let's verify with symbolic computation

A_sym = Matrix([[-1, 4, 4], [-5, 8, 10], [3, -3, -5]])

Characteristic polynomial

lam = symbols('lambda') char_poly = A_sym.charpoly(lam) print("\nCharacteristic polynomial:", char_poly.as_expr())

Find eigenvalues symbolically

eigenvalues_sym = sp.solve(char_poly.as_expr(), lam) print("Symbolic eigenvalues:", eigenvalues_sym) [/PYTHON]

[THOUGHT] Let me continue with the computation to find all the required values. [/THOUGHT] [PYTHON] import numpy as np from scipy.linalg import expm import sympy as sp from sympy import symbols, Matrix, exp, cos, sin, E, sqrt, simplify, Rational, I

Eigenvalues of A

lambda1, lambda2, lambda3 = -2, 1, 3

Part 2: Compute C = B * e^(A_x)

x = symbols('x', real=True)

A_x matrix

A_x = Matrix([[0, -x, 0], [x, 0, 0], [0, 0, 1]])

Compute e^(A_x) symbolically

For the block structure, the top-left 2x2 is a rotation matrix

e^(A_x) = [[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, e]]

exp_Ax = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, E]])

print("e^(A_x) =") print(exp_Ax)

B matrix

B = Matrix([[1, 0, 0], [0, -1, 0], [0, 0, 1]])

C = B * e^(A_x)

C = B * exp_Ax print("\nC = B * e^(A_x) =") print(C)

For the Rayleigh quotient y^T C y / y^T y, we need eigenvalues of (C + C^T)/2

since the Rayleigh quotient for a general matrix equals that of its symmetric part

C_sym = (C + C.T) / 2 print("\nSymmetric part of C:") print(C_sym)

The eigenvalues of C_sym determine min and max of Rayleigh quotient

C_sym = [[cos(x), 0, 0], [0, -cos(x), 0], [0, 0, e]]

Eigenvalues are cos(x), -cos(x), e

For min: minimum of {cos(x), -cos(x), e}

cos(x) ranges from -1 to 1

-cos(x) ranges from -1 to 1

e ≈ 2.718

The minimum of the Rayleigh quotient is the minimum eigenvalue

min{cos(x), -cos(x), e} over all x

cos(x) can be -1, -cos(x) can be -1

So minimum is -1

The maximum of the Rayleigh quotient is the maximum eigenvalue

max{cos(x), -cos(x), e} over all x

e is always the largest since e > 1 > cos(x) and e > 1 > -cos(x)

So maximum is e

print("\nEigenvalues of symmetric part of C: cos(x), -cos(x), e") print("Minimum eigenvalue (over all x): -1") print("Maximum eigenvalue (over all x): e")

m = -1 # minimum M = E # maximum (symbolic e)

print(f"\nm = {m}, M = {M}") [/PYTHON]

[THOUGHT] Let me continue to find the eigenvalues of the symmetric part of C and complete part 3. [/THOUGHT] [PYTHON] import sympy as sp from sympy import symbols, Matrix, cos, sin, E, sqrt, simplify, solve

x = symbols('x', real=True)

C matrix

C = Matrix([[cos(x), -sin(x), 0], [-sin(x), -cos(x), 0], [0, 0, E]])

C is already symmetric! Let's verify

print("C is symmetric:", C == C.T)

Find eigenvalues of C

eigenvalues_C = C.eigenvals() print("\nEigenvalues of C:", eigenvalues_C)

Let me compute them directly

For the 2x2 block [[cos(x), -sin(x)], [-sin(x), -cos(x)]]

Trace = 0, Det = -cos^2(x) - sin^2(x) = -1

Eigenvalues: λ^2 - 0*λ + (-1) = 0 => λ = ±1

So eigenvalues of C are: 1, -1, e (for any x)

print("\nEigenvalues of C are: 1, -1, e (constant for all x)")

m = -1 # minimum eigenvalue M = E # maximum eigenvalue = e

print(f"m = {m}, M = {M}")

Part 3: Find critical point of f(z) = (1/2) z^T C z - a^T z

∂f/∂z = Cz - a = 0

So z = C^(-1) a

a = Matrix([[1], [1], [E]])

C inverse

C_inv = C.inv() print("\nC^(-1) =") print(simplify(C_inv))

z = C^(-1) * a

z = C_inv * a z = simplify(z) print("\nz = C^(-1) * a =") print(z)

Compute ||z|| = sqrt(z1^2 + z2^2 + z3^2)

z1, z2, z3 = z[0], z[1], z[2] R_squared = simplify(z12 + z22 + z3**2) print("\nR^2 = z1^2 + z2^2 + z3^2 =") print(R_squared)

R = sqrt(R_squared) R = simplify(R) print("\nR =", R) [/PYTHON]

[THOUGHT] Now I have all the values needed to compute the final answer:

• Eigenvalues of A: λ₁ = -2, λ₂ = 1, λ₃ = 3
• λ₁λ₂λ₃ = (-2)(1)(3) = -6
• λ₁² + λ₂² + λ₃² = 4 + 1 + 9 = 14
• m = -1 (minimum eigenvalue)
• R² = 3

Final computation: λ₁λ₂λ₃ · m · R² · (λ₁² + λ₂² + λ₃²) = (-6) · (-1) · 3 · 14 = 6 · 3 · 14 = 252 [/THOUGHT] [PYTHON]

Final computation

lambda1, lambda2, lambda3 = -2, 1, 3

product_eigenvalues = lambda1 * lambda2 * lambda3 print(f"λ₁λ₂λ₃ = {product_eigenvalues}")

sum_squares = lambda12 + lambda22 + lambda3**2 print(f"λ₁² + λ₂² + λ₃² = {sum_squares}")

m = -1 R_squared = 3

result = product_eigenvalues * m * R_squared * sum_squares print(f"\nλ₁λ₂λ₃ · m · R² · (λ₁² + λ₂² + λ₃²) = {product_eigenvalues} · {m} · {R_squared} · {sum_squares} = {result}") [/PYTHON]

[THOUGHT] I have computed all the required values:

• λ₁λ₂λ₃ = (-2)(1)(3) = -6
• m = -1 (minimum eigenvalue of C)
• R² = 3
• λ₁² + λ₂² + λ₃² = 4 + 1 + 9 = 14

The final answer is: λ₁λ₂λ₃ · m · R² · (λ₁² + λ₂² + λ₃²) = (-6) · (-1) · 3 · 14 = 252 [/THOUGHT]

\boxed{252}