Build Identity Matrix

easyFREENotationLinear AlgebraCV: Introduction to Computer Vision

Implement a function to generate an $n \times n$ identity matrix, a fundamental concept in linear algebra. The identity matrix is crucial in various mathematical operations, including matrix multiplication and transformation.

The identity matrix $I$ is defined such that when it multiplies another matrix $A$ , the result is the original matrix $A$ . This property makes the identity matrix the multiplicative identity for matrices. The elements of the identity matrix can be defined using the Kronecker delta $\delta_{ij}$ , where $\delta_{ij} = 1$ if $i = j$ and $\delta_{ij} = 0$ otherwise.

Return the matrix as a list of $n$ rows, each a list of $n$ integers (1 on the main diagonal, 0 everywhere else):

I_{ij} = \delta_{ij}

This technique is widely used in computer vision for image and signal processing.

Example

Input

identity_matrix(3)

Output

[[1,0,0],[0,1,0],[0,0,1]]

Reasoning

The input $n = 3$ is the side length, so the result is a square grid with 3 rows and 3 columns: 9 entries in total, each indexed by a row $i$ and a column $j$ from 0 to 2.
Each entry follows the Kronecker delta: $I_{ij} = \delta_{ij}$ . Only the pairs where row and column match, $(0,0)$ , $(1,1)$ and $(2,2)$ , get a 1. The other 6 pairs, such as $(0,1)$ or $(2,0)$ , get a 0.
Reading row by row gives [1, 0, 0], then [0, 1, 0], then [0, 0, 1]: the 1 moves one column to the right on each new row, tracing the main diagonal.
Check the defining property on a row vector: $[4, 7, 2]$ times this matrix gives $4 \cdot 1 + 7 \cdot 0 + 2 \cdot 0 = 4$ in the first slot, and likewise $7$ and $2$ , so the vector comes back unchanged.
Notice the entries are the integers 1 and 0, not decimals, and that $n = 1$ collapses to the single entry [[1]].

Constraints

n is a positive integer, 1 ≤ n ≤ 100

More from CV: Introduction to Computer Vision

Sparse Matrix Operations for Imagesmedium Multi-Scale Feature Pyramidhard Implement Prewitt Edge Detectorhard Connected Components Labelinghard K-Means Color Quantizationmedium

Concept primer

The key idea is that an identity matrix is a square matrix whose entries are 1 on the main diagonal and 0 elsewhere, and the Kronecker delta $\delta_{ij}$ is exactly the function that captures this pattern. So $I_{ij} =$ \delta $_{ij}$ is just a compact way of saying “put 1 when row index equals column index, otherwise 0.”

1. Background Knowledge

An identity matrix $I_n$ of size $n \times n$ is defined by

(I_n)_{ij} = \begin{cases} 1 & \text{if } i = j\\ 0 & \text{if } i \neq j \end{cases}

This matrix is the multiplicative identity for matrix multiplication: for any compatible matrix $A$ , $AI_n = I_nA = A.$

The Kronecker delta $\delta_{ij}$ is a function of two indices:

\delta_{ij} = \begin{cases} 1 & \text{if } i = j\\ 0 & \text{if } i \neq j \end{cases}

Comparing this with the definition above, you can see that the identity matrix entries can be written compactly as $I_{ij} = \delta_{ij}.$

In many linear algebra and computer vision texts, writing things in index notation (using subscripts and $\delta_{ij}$ ) makes formulas for transformations and tensors shorter and easier to manipulate. This exercise is mainly about making the connection between this notation and the concrete matrix you build in code.

2. Algorithm / General Approach

To build an $n \times n$ identity matrix using the Kronecker delta idea:

Create an $n \times n$ matrix (e.g., list of lists, 2D array) initialized with zeros.
For each pair of indices $(i, j)$ :
Set the element to 1 if $i$ and $j$ are equal (because $\delta_{ij} = 1$ ), otherwise keep it 0.
Conceptually, you are implementing the rule: matrix[i][j] = 1 if i == j else 0.

The “Kronecker delta” is just the mathematical notation for this conditional.

3. Step-by-Step Strategy

Read input size

Obtain the integer $n$ (size of the matrix).

Initialize data structure

Create an empty 2D structure to hold $n$ rows, each with $n$ columns.
Often, you start with all zeros.

Loop over indices

Use a loop for row index $i$ from $0$ to $n-1$ .
Inside it, use another loop for column index $j$ from $0$ to $n-1$ .

Apply the Kronecker delta rule

If $i == j$ , set the element to 1 (this corresponds to $\delta_{ij}=1$ ).
Else, set (or leave) the element as 0 (this corresponds to $\delta_{ij}=0$ ).

Return or print the matrix

Output the full $n \times n$ matrix in the format your platform expects.

Example sketch in Python-like pseudocode:

def identity_matrix(n):
 I = [[0 for j in range(n)] for i in range(n)]
 for i in range(n):
 for j in range(n):
 if i == j: # this is δ_ij
 I[i][j] = 1
 return I

4. Common Pitfalls

Indexing off-by-one:
Mathematically, indices often start at 1; in code, they usually start at 0.
Ensure you loop correctly from 0 to n-1.
Rectangular instead of square:
An identity matrix must be $n \times n$ , not $n \times m$ with $m \neq n$ .
Incorrect initialization:
Forgetting to initialize with zeros, or accidentally reusing the same row list for all rows (in some languages) can cause unexpected behavior.
Misinterpreting $\delta_{ij}$ :
Remember it is not a product. It is a function that evaluates to either 0 or 1 depending on whether $i = j$ .

5. Time & Space Complexity

Time complexity:
You visit each element of an $n \times n$ matrix once and do constant work per element.
$T(n) = O(n^2).$
Space complexity:
You store $n^2$ elements in the matrix.
$S(n) = O(n^2).$

solution.py

Python 3.13

Test results