Identity and Eye Matrices

1. Background Knowledge

Identity matrices are square matrices $I_n \in \mathbb{R}^{n \times n}$ with 1s on the main diagonal and 0s elsewhere, serving as the multiplicative identity: $I_n \cdot A = A \cdot I_n = A$ for any compatible matrix $A$.

NumPy provides efficient n-dimensional array operations central to scientific Python computing. Key functions:

• np.eye(n): Returns $n \times n$ identity matrix as a float NumPy array (dtype float64 by default).
• np.identity(n): Identical to np.eye(n) for square matrices.

Trace of a matrix is the sum of its diagonal elements: $\operatorname{trace}(I_n) = n$, since only diagonal 1s contribute.

Shape is the tuple (n, n) converted to list [n, n] for the output.

Prerequisites: Basic NumPy array handling, list comprehension for nested lists, dictionary creation.

2. Algorithm Approach

Use np.eye(n) (or np.identity(n)) to generate the identity array directly—no manual construction needed, as it's $O(n^2)$ optimized in C.

1. Generate identity array.
2. Compute trace via np.trace() or np.diagonal().sum() ($O(n)$).
3. Extract shape and convert to list.
4. Convert array to nested list via array.tolist().

This leverages NumPy's vectorized operations for efficiency over pure Python loops.

3. Step-by-Step Strategy

import numpy as np

def create_identity(n):
 # Step 1: Create n x n identity matrix (float64)
 identity_array = np.eye(n)

 # Step 2: Compute trace (sum of diagonal = n)
 trace = np.trace(identity_array)

 # Step 3: Get shape as list
 shape = list(identity_array.shape)

 # Step 4: Convert to nested list (preserves float values like 1.0)
 identity_list = identity_array.tolist()

 # Step 5: Return exact dictionary format
 return {
 "identity": identity_list,
 "trace": trace,
 "shape": shape
 }

Verification:

result = create_identity(3)
print(result["identity"] == [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0], [0.0, 0.0, 1.0]]) # True
print(result["trace"] == 3.0) # True
print(result["shape"] == [3, 3]) # True

4. Common Pitfalls

• Data type mismatch: np.eye(n) returns floats (1.0, not 1); sample expects 1.0—.tolist() preserves this.
• Shape as tuple: array.shape is (n, n); must convert to [n, n] list.
• Manual loops: Avoid for loops to build matrix—use np.eye() for $O(1)$ logical time.
• Integer input: n is positive integer, but output trace/shape use float/list—no casting needed.
• Import missing: Always import numpy as np.
• Non-square: Constraints guarantee square; no need for rectangular handling.

5. Time & Space Complexity

• Time: $O(n^2)$ dominant from np.eye() allocation and .tolist() traversal. Trace is $O(n)$.
• Total: $\Theta(n^2)$, optimized via C backend (vectorized, no Python loops).
• Space: $O(n^2)$ for array storage (dense matrix).
• Auxiliary: $O(n^2)$ for list conversion; dictionary overhead $O(1)$.
• Identity matrix sparsity unused here (all zeros explicit).

This approach is optimal for constraints, scaling linearly in memory but constant-time logically via NumPy primitives.