Matrix Multiplication Calculator

Each row of A has k entries, and each column of B has k entries. The dot product C[i][j] = sum of k products, one for each matching position. If A has 3 columns but B has only 2 rows, there is no way to pair up the elements, the operation is simply undefined.

Geometrically: if A maps vectors from a 3D space to a 2D space, and B maps vectors from a 2D space to a 4D space, then AB makes sense, B first reduces to 2D, then A processes that 2D output. But if B outputs 3D and A expects 2D input, they are incompatible.

• ›A: m×k maps from k-dimensional to m-dimensional space
• ›B: k×n maps from n-dimensional to k-dimensional space
• ›AB: applies B first (n→k), then A (k→m) → net result is n→m, i.e., A is m×n

No, in general, AB ≠ BA. This is one of the most fundamental differences between matrix algebra and scalar arithmetic.

AB may not even be the same size as BA: if A is 2×3 and B is 3×2, then AB is 2×2 but BA is 3×3, different sizes cannot possibly be equal.

Even for square matrices of the same size where both AB and BA are defined and the same size, they are almost always different:

• ›A=[[1,2],[3,4]], B=[[5,6],[7,8]]: AB=[[19,22],[43,50]], BA=[[23,34],[31,46]]
• ›Exception: diagonal matrices always commute with each other
• ›Exception: any matrix commutes with the identity I and with scalar multiples of I
• ›Exception: A always commutes with its own powers Aⁿ

The dot product of two vectors a = [a₁, a₂, …, aₙ] and b = [b₁, b₂, …, bₙ] is: a · b = a₁b₁ + a₂b₂ + … + aₙbₙ, a single number summarising how much the vectors "align."

Matrix multiplication is simply a systematic collection of dot products: C[i][j] is the dot product of row i of A with column j of B. An m×k times k×n multiplication computes m×n dot products total.

• ›If vectors are perpendicular, their dot product is 0
• ›If parallel and same direction, dot product = product of magnitudes
• ›Dot product = |a||b|cos(θ), where θ is the angle between them

The identity matrix Iₙ is the n×n matrix with 1s on the main diagonal and 0s everywhere else. It is the matrix equivalent of the number 1, multiplying by it leaves any matrix unchanged.

• ›A × I = A for any compatible A
• ›I × A = A for any compatible A
• ›I₂ = [[1,0],[0,1]], I₃ = [[1,0,0],[0,1,0],[0,0,1]]
• ›det(I) = 1, and I⁻¹ = I

The identity matrix represents the "do nothing" transformation, no rotation, no scaling, no shearing. It is the starting point for building transformation matrices: you start with I and add rotation, scale, and translation components.

A matrix A represents a linear transformation: given any input vector x, the output is Ax. The columns of A are the images of the standard basis vectors, they tell you exactly where the transformation sends each axis direction.

• ›Rotation by θ: [[cos θ, −sin θ], [sin θ, cos θ]]
• ›Scaling by (sx, sy): [[sx, 0], [0, sy]]
• ›Reflection across x-axis: [[1, 0], [0, −1]]
• ›Shear: [[1, k], [0, 1]], slides horizontal layers

Composing two transformations (first B, then A) is equivalent to computing the matrix product AB. The order matters: AB means "apply B first, then A." In 3D graphics, a model matrix M = T × R × S means "scale first (S), then rotate (R), then translate (T)."

For standard matrix multiplication, multiplying an m×k matrix by a k×n matrix requires m×k×n scalar multiplications and m×k×(k−1) additions, approximately O(m·k·n) operations total.

• ›2×2 × 2×2: 8 multiplications, 4 additions
• ›3×3 × 3×3: 27 multiplications, 18 additions
• ›100×100 × 100×100: 1,000,000 multiplications
• ›1000×1000 × 1000×1000: 10⁹ operations (CPU-intensive)

For large matrices, algorithms like Strassen's (O(n^2.807)) and Coppersmith-Winograd reduce theoretical complexity. In practice, highly optimised BLAS libraries (LAPACK, cuBLAS) exploit CPU SIMD instructions and GPU parallelism to multiply large matrices orders of magnitude faster than naive implementations.

Aⁿ means applying the transformation represented by A exactly n times. It is computed by repeated matrix multiplication: A² = A×A, A³ = A²×A, and so on. Efficient computation uses repeated squaring, O(log n) multiplications instead of O(n).

• ›Rotation matrix Rθ to the power n → rotation by nθ
• ›Adjacency matrix A of a graph: A^n gives the number of length-n paths between each pair of nodes
• ›Markov transition matrix P^n → probability distribution after n steps
• ›Fibonacci sequence: [[1,1],[1,0]]^n gives F(n) and F(n+1) in O(log n) multiplications

Matrix diagonalisation simplifies computing Aⁿ: if A = PDP⁻¹ (where D is diagonal), then Aⁿ = PDⁿP⁻¹, and Dⁿ is trivial (just raise each diagonal entry to the nth power). This technique is used in differential equations to find closed-form solutions for systems of equations.