Matrix Operations

easyFREELinear Algebra BasicsNumPy Linear AlgebraNumPy Foundations

Problem Statement

Perform common matrix operations.

Background

NumPy linear algebra operations:

np.linalg.inv(A) - matrix inverse
np.linalg.det(A) - determinant
np.trace(A) - trace (sum of diagonal)
A.T - transpose

Your Task

Write a function matrix_ops(mat) that computes matrix properties.

Output Format

Return a dictionary with:

"transpose": Transposed matrix (list)
"trace": Sum of diagonal elements
"determinant": Determinant (rounded to 2 decimals)
"is_symmetric": True if mat == mat.T

Example

Input

[[1, 2], [3, 4]]

Output

{'transpose': [[1, 3], [2, 4]], 'trace': 5, 'determinant': -2.0, 'is_symmetric': False}

Reasoning

Input: mat is the $2 \times 2$ matrix $A = \begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}$ , so $a_{11}=1$ , $a_{12}=2$ , $a_{21}=3$ , $a_{22}=4$ .
Transpose: $A^T$ swaps rows and columns, $(A^T)_{ij} = a_{ji}$ . Row 1 of $A$ , $(1, 2)$ , becomes column 1, giving [[1, 3], [2, 4]] as a plain nested list.
Trace: the sum of the main diagonal, $\operatorname{tr}(A) = a_{11} + a_{22} = 1 + 4 = 5$ , a whole number since every entry is an integer.
Determinant: for a $2 \times 2$ matrix, $\det A = a_{11}a_{22} - a_{12}a_{21} = 1 \cdot 4 - 2 \cdot 3 = -2$ . Computed numerically it can come out as $-2.0000000000000004$ ; rounded to 2 decimal places it is the float -2.0.
Symmetry: $A$ is symmetric only if $A = A^T$ , i.e. $a_{ij} = a_{ji}$ for every pair. Here $a_{12} = 2$ but $a_{21} = 3$ , so is_symmetric is False.
Notice that the trace is unchanged by transposing (the diagonal stays put), and so is the determinant: $\det A^T = \det A$ for any square matrix.

Constraints

mat is a square matrix
Round determinant to 2 decimal places

Learn this in

Mathematical FoundationsFoundations NumPy & Data WranglingFoundations

More from NumPy Foundations

Solve Linear Systemmedium Dot Producteasy Image-like Reshapingmedium Array Stackingeasy Array Reshapingeasy

Concept primer

1. Background Knowledge

Matrix fundamentals form the basis of linear algebra, where a matrix is a rectangular array of numbers arranged in rows and columns, representing linear transformations or systems of equations. Key properties include the transpose (flipping rows and columns, denoted $A^T$ ), trace (sum of diagonal elements, $\operatorname{trace}(A) =$ \sum_i A_{ii} $), **determinant** (scalar value indicating volume scaling and invertibility for square matrices,$ \det(A) \neq 0 $for invertible matrices), and **symmetry** (a matrix is symmetric if$ A = A^T $). These operations are foundational in fields like physics, computer graphics, and machine learning.

NumPy, Python's library for numerical computing, provides efficient array operations via ndarrays, enabling vectorized computations that avoid slow Python loops. Functions like np.trace(), np.linalg.det(), and A.T leverage optimized C backends for speed, while np.linalg.inv() computes inverses (though not required here). Understanding NumPy's broadcasting and shape handling is crucial, as matrices must be square for trace/determinant.

2. Algorithm/Approach

The approach follows a direct computation pattern common in linear algebra problems:

Extract matrix properties using built-in NumPy functions.
Convert results to required formats (e.g., NumPy array to list for transpose).
Perform conditional checks (e.g., symmetry via equality comparison).
Package into a dictionary for structured output.

This is O(n) time for most operations (n = matrix dimension), emphasizing NumPy's vectorized efficiency over manual loops.

3. Step-by-Step Strategy

Validate input: Ensure mat is a square NumPy array (use mat.shape to check rows == columns).
Compute transpose: Use mat.T and convert to nested list via mat.T.tolist().
Calculate trace: Apply np.trace(mat) for diagonal sum.
Compute determinant: Use np.linalg.det(mat) and round to 2 decimals with round(value, 2).
Check symmetry: Compare np.array_equal(mat, mat.T) (accounts for floating-point precision).
Return dictionary: Populate with keys "transpose", "trace", "determinant", "is_symmetric".

Test with sample: For $\begin{bmatrix}$ 1 & 2 \ 3 & 4 \end{bmatrix} $, expect trace=5, det=-2.0, transpose=[[1,3],[2,4]], not symmetric.

4. Common Pitfalls

Non-square matrices: det() and trace() fail or give misleading results—always check mat.shape == mat.shape.
Data types: Input may be list; convert with np.array(mat) to enable NumPy ops.
Floating-point precision: Use np.allclose(mat, mat.T) instead of == for symmetry if floats present.
Output format: Transpose must be list of lists, not NumPy array—use .tolist().
Rounding: Apply round() only to determinant; trace may be integer.
Import: Forget import numpy as np → all functions fail.

5. Time & Space Complexity

Time: O(n) per operation (n = side length), dominated by det (Gaussian elimination ~O(n³) worst-case, but NumPy optimizes). Total: O(n³).
Space: O(n²) for transpose copy; dictionary holds O(1) scalars + O(n²) list. O(n²) overall.

NumPy's C backend ensures efficiency scales to large n (e.g., 1000x1000 in seconds on modern hardware).

solution.py

Python 3.13

Test results