•A matrix with different numbers of rows and columns models a transformation between spaces of different sizes. For example, a 3-by-2 matrix takes 2D vectors from the flat plane and turns them into 3D vectors in space. The columns of the matrix tell you exactly where the basic 2D directions (i-hat and j-hat) end up in 3D. Using this rule, any 2D input can be mapped by combining those columns.
•A 3-by-2 matrix has two columns (so inputs are 2D) and three rows (so outputs are 3D). Each input vector in the plane becomes a point in 3D space after the transformation. Altogether, the entire 2D plane becomes a flat sheet (a plane) inside 3D that passes through the origin. If the two columns are not multiples of each other, this sheet is truly a 2D plane; if they are multiples, the image collapses to a line.
•To compute the output of a 3-by-2 matrix on a 2D vector, express the input as a linear combination of the standard basis and send those basis vectors to the matrix’s columns. Multiply each column by the corresponding input component and then add the results. This is called the column picture of matrix-vector multiplication. It is a fast, visual way to understand how transformations work.
•Example: With columns [1, 0, 2] and [-1, 1, 0], the 2D input (-2, 3) maps to -2*[1, 0, 2] + 3*[-1, 1, 0] = [-5, 3, -4]. This shows how each part of the input scales a column and then adds together in 3D space. The result is a single 3D point, which lies on the plane spanned by those two columns. Every other 2D input lands on the same plane.
•A 3-by-1 matrix represents a transformation from a 1D number line to a 3D line in space. There is only one column, so the input direction “1” maps to that single 3D column. Any real number t maps to t times that column vector. The whole number line becomes a straight line through the origin in 3D.
•Matrix multiplication represents doing one transformation after another. If N is 2-by-2 (2D to 2D) and M is 3-by-2 (2D to 3D), then M*N is 3-by-2 and means “first do N, then do M.” The inner dimensions (2 and 2) must match for multiplication to make sense. The outer dimensions (3 and 2) tell you the input and output sizes for the combined transformation.
Why This Lecture Matters
Understanding non-square matrices as transformations between dimensions is essential for anyone who models or analyzes real-world data and geometry. Engineers and scientists often embed 2D or 3D measurements into higher dimensions for analysis or reduce high-dimensional data to fewer dimensions for visualization. Designers of graphics, robotics, and simulations routinely map shapes from one space to another, using exactly these ideas of columns as images of basis vectors and products as composition. Even when using software, you must know which matrix shapes to multiply and what those products mean.
This knowledge solves practical problems like: how to place a 2D object into a 3D scene, how to reduce 3D sensor data to 2D screens, and how to chain multiple transformations correctly. It clarifies why some outputs are unreachable (rank limits) and guides how to detect whether your map collapses information unintentionally. By using the column picture, you can compute and reason quickly, and by understanding composition, you can build complex pipelines that work in one clean step.
Career-wise, these skills are foundational across computer graphics, data science, machine learning, robotics, physics, and engineering. They help you read and debug matrix shapes, design proper pipelines, and avoid subtle mistakes that cause wrong results or software errors. In today’s industry, where transformations of images, coordinates, and features are everywhere, mastering non-square matrices and their geometric meaning is a critical building block that supports advanced topics like projections, embeddings, and dimension reduction.
Lecture Summary
Tap terms for definitions
01Overview
This lesson teaches how rectangular (non-square) matrices act as transformations between spaces of different dimensions. Before, square matrices like 2-by-2 were used to take a 2D vector and turn it into another 2D vector. Now the focus shifts to matrices whose number of rows and columns are not the same, such as 3-by-2 or 3-by-1. These matrices describe how to carry vectors from one dimension to another, for example from the flat 2D plane into 3D space. The central idea remains the same as with square matrices: the columns show where the standard basisvectors land after the transformation.
The main objective is to build a clear, simple mental picture of what non-square matrices do. A 3-by-2 matrix has two columns and three rows. The two columns tell you that the inputs are 2D vectors (because there are two basis directions: i-hat and j-hat), and the three rows show the outputs are 3D vectors. Each column is a 3D vector showing where a 2D basis direction ends up in space. Any input vector from 2D is a combination of i-hat and j-hat, so its output in 3D is the same combination of those two columns. In other words, every 2D input is lifted into 3D by mixing these two 3D columns. The entire 2D plane is mapped into a flat 3D sheet (a plane) passing through the origin.
This also covers the 3-by-1 case, where the input is 1D (the number line) and the output is 3D. With one column, the single basis direction “1” goes to that column vector, and any real number t maps to t times that vector. The whole 1D line becomes a straight line in 3D through the origin. Understanding this simple case makes the idea of changing dimensions very concrete.
Another key goal is to make matrix multiplication feel like combining transformations. If N is 2-by-2, it moves vectors around the 2D plane. If M is 3-by-2, it lifts 2D vectors into 3D space. The product M*N is defined and results in a 3-by-2 matrix, which represents doing N first, then M. The rule for dimensions (inner sizes must match; the outer sizes give the result) exactly reflects the idea that the output of one step must fit as the input to the next.
This lesson is for beginners and anyone who wants to form a rock-solid intuition for what matrices truly do. You only need basic familiarity with vectors, the coordinate ideas of i-hat and j-hat, and what a linear combination is. No heavy algebra is required, though being comfortable with multiplying vectors by scalars and adding vectors helps. If you already know the row-by-column rule for multiplication, this lesson will complement that with an even more intuitive column-based view.
By the end, you will be able to read any rectangular matrix and immediately tell what dimensions it maps between. You will know how to compute outputs by taking linear combinations of columns with the input’s coordinates. You will also understand why the image of the transformation is always a subspace (like a line or plane) in the output space that passes through the origin. Finally, you will be ready to see how composing two transformations corresponds to multiplying their matrices and how the shapes of the matrices must align to make sense.
The lesson is structured around a series of concrete, visual ideas. It begins by reviewing how columns show where basis vectors go. It then introduces the 3-by-2 case and gives a specific numeric example of mapping a 2D vector into 3D. Next, it generalizes to the 3-by-1 case to show how a whole number line becomes a 3D line. It closes by connecting everything to matrix multiplication as composition: N acts first in 2D, then M lifts into 3D, and the product M*N summarizes the whole story as a single 3-by-2 matrix. With these pieces, you gain a complete toolkit for thinking about transformations between different dimensions.
Key Takeaways
✓Always read the matrix shape first. An m-by-n matrix maps n-dimensional inputs to m-dimensional outputs; columns count inputs, rows count outputs. This quick check saves you from illegal multiplications and wrong assumptions. Make it a habit before every calculation.
✓Use the column picture for clarity. Compute outputs as sums of input components times columns: x1*c1 + ... + xn*cn. This works for any shape and instantly shows the geometry. If you forget formulas, this idea gets you back on track.
✓Track basis vectors to understand transformations. Know where i-hat and j-hat land; those are the columns. Any other input follows by the same mix. Drawing these images makes even 3D intuition easy.
✓Expect images to be subspaces through the origin. Linear maps send 0 to 0 and keep straightness, so outputs form lines or planes (or higher-dimensional flats) that pass through the origin. If your drawing shows a shifted shape, re-check your assumptions. This rule is a strong error detector.
✓Check column independence to predict image dimension. Independent columns span a higher-dimensional image (plane over line). Dependent columns collapse the image. A quick multiple test (is c2 = k*c1?) gives the answer fast.
✓Practice both column picture and row-by-column rule. Use the column picture for geometry and quick reasoning, and the row rule for careful numeric components. They are two sides of the same coin. Knowing both makes you flexible.
✓Compose transformations by multiplying matrices in the right order. A*B means do B first, then A. Match inner dimensions to make the product valid. The result replaces two steps with one.
Glossary
Matrix
A matrix is a rectangular grid of numbers that acts like a machine turning input vectors into output vectors. Its number of rows and columns decides the input and output sizes. You can think of it as a recipe for how to mix and scale basis directions. Each column shows where a simple basis vector goes. Matrices can be square or non-square.
Vector
A vector is an ordered list of numbers that can be seen as an arrow with direction and length. In 2D it has two numbers, in 3D it has three. Vectors add by tip-to-tail and scale by stretching or shrinking. They are the basic objects we move around with matrices. Every point in a space can be described by a vector.
Dimension
Dimension tells how many independent directions a space has. 1D is a line, 2D is a plane, 3D is space. A vector in n dimensions has n numbers. The dimension also tells you how many basis vectors you need to describe any vector. More dimensions mean more ways to move.
Linear transformation
A linear transformation is a rule that preserves addition and scaling. If you add inputs, outputs add; if you scale inputs, outputs scale the same. It always sends the zero vector to zero. Matrices represent linear transformations. They keep straight lines straight and keep parallel lines parallel (within their image).
Version: 1
•Columns tell you where standard basis vectors go under a transformation. In 2D, i-hat = (1,0) and j-hat = (0,1). Under a 3-by-2 matrix, i-hat lands at the first column and j-hat at the second column, both as 3D vectors. Any 2D input is a mix of i-hat and j-hat, so its image is the same mix of the two columns.
•A non-square matrix cannot be a perfect back-and-forth between spaces of different sizes. When going from 2D to 3D, information can be preserved or stretched but you cannot define a unique reverse mapping for every possible 3D vector back to 2D. The image is a lower-dimensional sheet (plane or line) inside the larger space. This is why not every output in the bigger space comes from an input.
•A 2-by-3 matrix maps 3D vectors to 2D vectors. Here, there are three columns (so inputs are 3D) and two rows (so outputs are 2D). The three 3D basis vectors e1, e2, e3 land in 2D at the three columns. Any 3D input is a sum of those basis directions, and thus its output is the same weighted sum of the three columns in 2D.
•The shape of the output set (image) reveals the rank of the matrix. With a 3-by-2 matrix, the rank is at most 2: you get a plane or a line in 3D. If the two columns are linearly independent, you get a plane; if one is a multiple of the other, you get a line. Rank tells you how many independent directions survive the transformation.
•Visualizing transformations helps build intuition. Think of the input grid being lifted or lowered into 3D by the columns of the matrix. Lines in the input become lines in the output, and the whole grid becomes a flat sheet when going from 2D to 3D. This sheet always passes through the origin because linear transformations send 0 to 0.
•The composition rule for dimensions matches the multiplication rule for matrices. For A (m-by-n) and B (n-by-p), A times B is m-by-p and means first apply B (pD to nD), then A (nD to mD). This guarantees that the chain of transformations lines up correctly. It also explains why the “inner” sizes must be the same.
•The column interpretation gives a simple way to compute without memorizing formulas. Instead of thinking row-by-column, think: input components tell you how much of each column to take. Multiply each column by the matching input component, then add. This works for any matrix shape.
•A 3-by-1 transformation is like choosing a direction in space and sliding along it based on the input number. Positive inputs go one way, negatives go the other, and zero lands at the origin. The speed along that line matches the input’s size. This is a clean example of how 1D information becomes a 3D position.
•Every non-square matrix maps the entire input space to a subspace in the output. A subspace is a flat set through the origin, like a line or a plane. The dimension of that subspace is at most the smaller of the input size and output size. This is the geometric meaning behind rank and column span.
•Knowing where basis vectors go is enough to know the entire transformation. That is because every vector is just a combination of basis vectors. So a matrix is fully determined by its columns, which are the images of the basis vectors. This is why the columns are so important to read and understand.
•The earlier 2-by-2 case is a special instance: same-size input and output. Now, with 3-by-2 or 3-by-1, we see how linear maps connect spaces of different sizes. The same rules and intuition still apply. Only the dimension counts change, steering the shape of the image.
•When you multiply a 3-by-2 matrix M by a 2-by-2 matrix N, you get a 3-by-2 matrix that goes straight from 2D to 3D. That combined matrix’s columns are just M applied to N’s columns. This makes composition easy to visualize: watch where basis vectors travel through each stage. The final positions are exactly the columns of the product.
02Key Concepts
01
Non-square matrices as dimension-changing transformations: A matrix with m rows and n columns maps n-dimensional inputs to m-dimensional outputs. This means a 3-by-2 matrix takes 2D vectors into 3D space. The columns show where the input’s basis directions land in the output. Seeing matrices this way turns abstract numbers into a picture of motion between spaces. It’s the same core idea used for square matrices, just applied across different dimensions.
02
Columns tell where basis vectors go: In 2D, the standard basisvectors are i-hat = (1, 0) and j-hat = (0, 1). Under a 3-by-2 matrix, i-hat lands at the first column (a 3D vector), and j-hat lands at the second column (another 3D vector). Any input (x, y) is x times i-hat plus y times j-hat. So its image is x times the first column plus y times the second column. This column-lifting view makes every calculation a simple mix-and-add.
03
3-by-2 maps a plane into 3D: Because there are two independent input directions, the whole 2D plane gets sent into 3D. The set of all outputs forms a flat sheet (a plane) through the origin if the two columns are independent. If the columns are multiples, the plane collapses into a single line. Either way, the image is a flat subspace inside 3D that includes the origin.
04
Concrete numeric example (3-by-2): Suppose the columns are c1 = 102 and c2 = −110. For input v = (-2, 3), compute Mv = (-2)c1 + 3c2. That is −20−4 + −330 = −53−4. The result lies in the plane spanned by c1 and c2. This shows how inputs control how much of each column to take.
05
3-by-1 maps a line into 3D: A 3-by-1 matrix has just one column, so the input space is 1D (the number line). The single basis direction “1” maps to that column vector in 3D. Any number t maps to t times that column. So the entire input line becomes a straight line through the origin in 3D, pointing along that column.
06
2-by-3 maps 3D into a plane: A 2-by-3 matrix has three columns, so it takes 3D input. It outputs 2D vectors, so the image lies inside a 2D plane (or possibly a line or a point if columns are dependent). Each 3D basis direction e1, e2, e3 maps to the three columns in 2D. Any 3D input is a sum of those columns scaled by the input’s coordinates.
07
Matrix multiplication is composition: If N is 2-by-2 and M is 3-by-2, then M*N is defined and is 3-by-2. This means first apply N (staying in 2D), then apply M (lifting to 3D). The inner sizes (2 and 2) must match for the chain to work. The outer sizes (3 and 2) give the overall input-output sizes. This mirrors how real processes line up step by step.
08
The product’s columns track basis flow: The columns of MN are simply M applied to the columns of N. Each column of N shows where a 2D basis vector goes after the first step. Applying M to those gives the final 3D positions of those basis vectors. Arranged as columns, those final positions are exactly the columns of MN. This gives a vivid geometric meaning to multiplication.
09
Why outputs form subspaces: Linear transformations send 0 to 0 and preserve straight lines and scaling. Therefore, the set of all outputs is closed under addition and scalar multiplication and passes through the origin. This is exactly the definition of a subspace, such as a line or plane. Non-square matrices naturally produce these flat shapes in the output space.
10
Rank reflects surviving directions: Rank counts how many independent columns a matrix has, which equals the dimension of the image. For a 3-by-2 matrix, rank is at most 2, so the image is at most a plane. If columns are independent, the rank is 2 and the image is a full plane; if not, the rank is 1 and the image is a line. Rank turns geometry into a number you can compute.
11
Column picture vs. row-by-column rule: The column picture says output = sum of input components times columns. The row-by-column rule says the i-th output component is the dot product of the i-th row with the input. Both produce the same result, but the column picture is especially intuitive for visualizing transformations. It also makes dimension changes easy to grasp. Use both as tools depending on what you need.
12
Reading dimensions quickly: An m-by-n matrix maps from nD to mD. The number of columns equals input dimension; the number of rows equals output dimension. Check this first to avoid shape mistakes. This simple habit prevents many errors when composing transformations or doing calculations.
13
Lines and grids map to lines and sheets: A line in the input (like y = constant*x) maps to a line in the output subspace. The entire input grid (all of 2D) maps to a flat sheet in 3D for a 3-by-2 matrix. Shapes do not suddenly curve because linear maps preserve straightness and parallelism. This is a powerful guide for sketching results.
14
Origin stays fixed: For any linear transformation, the origin (0 vector) maps to the origin. This anchors every picture and helps you place the final image correctly. Planes and lines created by these maps always pass through the origin. Remembering this prevents drawing or imagining shifted shapes when none exist.
15
1D intuition made concrete: With a 3-by-1 matrix, there’s exactly one output direction. The input number just says how far and which way to go along that direction. Positive values move one way, negatives the other, and zero stays put. This example makes the idea of changing dimension feel simple and sturdy.
16
Composition preserves linearity: Doing one linear map after another is still linear. The combined effect is a single matrix with shape matching the start and end dimensions. This lets you replace a two-step process with one matrix multiplication. It keeps computations and reasoning clean.
17
Why not all outputs are reachable: If you map 2D to 3D with a 3-by-2 matrix, you can only land in a plane (or line), not anywhere in 3D. This means there’s no single-valued inverse from all of 3D back to 2D. The size mismatch explains why: you started with only two degrees of freedom. Understanding reachability clarifies what a transformation can and cannot do.
18
Basis-first thinking solves everything: Because any vector is a mix of basis vectors, knowing where basis vectors go tells you the whole story. This is why the columns (images of basis vectors) completely define the matrix. It also explains why matrix multiplication tracks how basis vectors move through each step. With this mindset, all calculations feel natural.
03Technical Details
Overall Architecture/Structure of Dimension-Changing Transformations
Spaces and Dimensions:
Think of Rn as an n-dimensional space of vectors with n numbers each. A matrix with m rows and n columns (written m-by-n) acts as a machine that takes an input vector of length n and produces an output vector of length m. This is why the number of columns (n) equals the input dimension, and the number of rows (m) equals the output dimension.
Columns as Images of Basis Vectors:
In n dimensions, the standard basisvectors are e1 = (1,0,0,...), e2 = (0,1,0,...), and so on. The i-th column of an m-by-n matrix is exactly where ei lands in the m-dimensional output space. Because any input vector x can be written as a combination x1e1 + x2e2 + ... + xnen, the output is x1(column 1) + x2*(column 2) + ... + xn*(column n). This is called the column picture of matrix-vector multiplication.
What Changes with Non-Square Shapes:
When n=m, the map goes between spaces of different dimensions. For example, a 3-by-2 matrix maps 2D inputs to 3D outputs. The image (the set of all outputs) cannot be more than 2-dimensional because you only had two input directions to begin with. If those two directions stay independent after mapping, you get a 2D plane in 3D; if they fold into a single direction, you get a 1D line in 3D; if they both map to 0, you get just the origin (rank 0).
Subspace Structure of Outputs:
Linear transformations preserve the origin and straightness. That means the image is closed under addition and scaling and passes through the origin, which is exactly the definition of a subspace. For a 3-by-2 matrix, the image is a plane or line through the origin within 3D. For a 3-by-1 matrix, the image is always a line through the origin in 3D.
Composition as Matrix Multiplication:
If B is n-by-p and A is m-by-n, then A*B is defined and is m-by-p. The input dimension p flows through B to become n, then through A to become m. This is why the inner dimensions must match (n with n), and the resulting matrix maps from pD to mD. Geometrically, multiplying matrices corresponds to applying one transformation after another.
Even though no programming code is used here, we can treat the computations like a careful algorithm.
Computing Mx with the Column Picture:
Inputs: an m-by-n matrix M with columns c1, c2, ..., cn; an input vector x in Rn with components (x1, x2, ..., xn).
Steps:
Multiply each column by the matching input component: x1c1, x2c2, ..., xn*cn.
Add the results: Mx = x1c1 + x2c2 + ... + xn*cn.
This gives an m-dimensional output vector.
Computing Mx with the Row-by-Column Rule:
Inputs: same as above.
Steps:
Let r1, r2, ..., rm be the rows of M.
For each i from 1 to m, compute the dot product yi = ri ⋅ x.
Assemble y = (y1, y2, ..., ym). This equals Mx.
The row-by-column rule is useful for finding individual output components, while the column picture is great for visualizing direction and dimension changes.
Example: 3-by-2 Matrix Acting on a 2D Vector:
Suppose M’s columns are c1 = 102^T and c2 = −110^T. Let x = (-2, 3). Using the column picture: Mx = (-2)c1 + 3c2 = −20−4 + −330 = −53−4. Using row-by-column would give the same result if you write out M’s rows and compute their dot products with x.
Example: 3-by-1 Matrix Acting on a Scalar:
Let M be a 3-by-1 with single column c1 = 2−11^T. For t in R (a real number), Mt = tc1 = 2t−tt^T. So 1 maps to 2−11^T, 2 maps to 4−22^T, and so on. The output is always on the line spanned by c1.
Composition via Multiplication:
Let N be 2-by-2 and M be 3-by-2. The product P = MN is 3-by-2. Its columns are Pe1 = M*(Ne1) and Pe2 = M*(Ne2). In practice, compute N’s columns first (they are Ne1 and N*e2 in 2D), then apply M to each to get two 3D columns. Stack them to form P. P takes any 2D input directly to the final 3D output.
Tools/Libraries Used
No programming libraries are needed for these ideas. The main tools are:
Standard basisvectors: to read columns as images of basis directions.
Vector arithmetic: scaling by numbers (scalars) and adding vectors.
Matrix multiplication rules: both the column picture and row-by-column rule.
Geometric visualization: imagining planes, lines, and grids moving through space.
These are the core “tools” to understand and compute with non-square matrices.
Step 2: Read the columns as images of basis vectors.
Label columns c1, c2, ..., cn.
Interpret: ei → ci, where ei is the i-th standard basisvector of Rn.
Example: For 3-by-2, i-hat → c1 (a 3D vector), j-hat → c2 (a 3D vector).
Step 3: Compute the image of a specific input.
Write the input x = (x1, x2, ..., xn).
Form the linear combination x1c1 + x2c2 + ... + xn*cn.
The result is the output vector in Rm.
Tip: Always multiply each column by the matching input component by position.
Step 4: Understand the image (the set of all outputs).
Determine whether columns are independent.
If columns are independent, the image is an n-dimensional flat subspace (like a plane if n=2) inside Rm.
If not, the image collapses to a smaller subspace (line or just the origin).
Example: 3-by-2 with independent columns gives a plane through the origin in 3D.
Step 5: Compose transformations (if needed).
Check shapes: If A is m-by-n and B is n-by-p, A*B is m-by-p.
Interpret: first apply B (pD → nD), then A (nD → mD).
Compute product columns: Each column of A*B equals A applied to the matching column of B.
Use the product to map inputs in one step instead of two.
Tips and Warnings
Tip: Always check shapes first. If inner dimensions don’t match for multiplication, the product is undefined. For example, 3-by-2 times 2-by-2 is okay; 3-by-2 times 3-by-2 is not.
Tip: Use the column picture to avoid confusion. When you get lost in numbers, return to “output = sum of input components times columns.” It works for any shape and keeps the geometry clear.
Tip: Visualize grids and basis vectors. Draw i-hat and j-hat in 2D, then imagine where they land as 3D arrows. The whole input plane becomes the flat sheet spanned by those two 3D arrows.
Warning: Don’t expect a unique inverse when dimensions change. A 3-by-2 matrix can’t map all of 3D back to 2D in a one-to-one way because the image is only a plane in 3D. Many 3D points lie off that plane and can’t be pre-images of anything.
Warning: Don’t forget the origin. Linear transformations always send 0 to 0. If your drawing shows a shifted plane not passing through the origin, that picture is not a linear map’s image.
Tip: Rank tells you the image’s dimension. Count independent columns to know if the image is a plane, a line, or just the origin. This makes it easier to predict the shape of outputs.
Tip: Practice with simple numbers. Try columns like 100^T and 010^T to build intuition. Then tilt and stretch them to see how the image plane moves or changes.
Tip: For composition, track basis vectors. Follow where e1 and e2 go after the first transformation, then where those results go under the second. The end positions become the columns of the product matrix.
Warning: Keep input-output order straight. If A is m-by-n, inputs must be length n, not m. Mixing this up is a common source of errors.
By following these steps and ideas, you can confidently read and use non-square matrices to understand how vectors move between dimensions, compute outputs efficiently, and combine transformations correctly.
04Examples
💡
3-by-2 mapping of a specific vector: Let M have columns 102 and −110, and take input x = (-2, 3). Compute Mx = -2*102 + 3*−110 = −53−4. The input from the 2D plane lands at a specific point in 3D. This demonstrates the column picture and how to combine columns using input components.
💡
Whole 2D plane maps to a 3D plane: With a 3-by-2 matrix whose columns are not multiples, every input (x, y) yields xc1 + yc2 in 3D. The set of all such sums forms a flat sheet through the origin. This image is called the plane spanned by c1 and c2. It shows that two independent input directions survive as a 2D surface in 3D.
💡
Collapsed image to a line (rank 1): If a 3-by-2 matrix has columns c1 and c2 where c2 = 2c1, then any output is xc1 + y*(2*c1) = (x + 2y)*c1. All outputs lie on the line through c1. The entire 2D input collapses to 1D in 3D. This example highlights what happens when columns are dependent.
💡
3-by-1 mapping of the number line: Let the single column be c1 = 2−11^T. Then t in R maps to t*c1 = 2t−tt^T. The number line becomes a line in 3D through the origin pointing along c1. This makes the 1D-to-3D case crystal clear.
💡
2-by-3 mapping from 3D to 2D: Suppose M is 2-by-3 with columns [1, 0]^T, [0, 1]^T, and [1, 1]^T. For input x = (a, b, c), Mx = a*[1, 0]^T + b*[0, 1]^T + c*[1, 1]^T = (a+cb+c)^T. The 3D input collapses into a 2D output based on those three 2D columns. This shows how three 3D basis directions contribute to a 2D result.
💡
Composition: 2D to 2D then to 3D: Let N be a 2-by-2 that rotates the plane, and M be a 3-by-2 that lifts 2D to 3D. First, an input vector is rotated in 2D by N. Then M takes that rotated vector and places it on a plane in 3D. The product M*N is a single 3-by-2 matrix that does both steps at once.
💡
Composition columns computed explicitly: If N’s columns are u1 and u2 in 2D, then P = MN has columns Mu1 and Mu2 in 3D. Compute u1 and u2 from N, then apply M to each: Mu1 and Mu2. Stack these as columns to form P. Now any input (x, y) maps to x(Mu1) + y(M*u2).
💡
Mapping i-hat and j-hat: For a 3-by-2 M, i-hat = (1, 0) maps to the first column, and j-hat = (0, 1) maps to the second column. Drawing these two 3D arrows shows the edges of the output plane. Any input is a stretch-and-add of these two arrows. This example cements the idea that columns are images of basis vectors.
💡
Grid mapping intuition: Imagine the 2D square grid of points (all integer pairs). Under a 3-by-2 matrix with independent columns, this grid becomes a tilted lattice lying on a plane in 3D. Lines that were parallel remain parallel on the plane. This helps you picture how the whole space moves, not just single vectors.
💡
Zero vector behavior: Take any m-by-n matrix M and input x = (0, 0, ..., 0). The output is the zero vector in Rm. This confirms that all images (lines or planes) pass through the origin. It also checks the linearity rule that 0 maps to 0.
💡
Switching to the row-by-column rule: For M = 102−110 and x = (-2, 3), compute each output component as a row dot product. Row 1 dot x = 1*(-2) + (-1)3 = -5, row 2 dot x = 0(-2) + 13 = 3, row 3 dot x = 2(-2) + 0*3 = -4. The result is (-5, 3, -4), matching the column picture. This shows both rules agree.
💡
Changing columns changes the image plane: If you replace c2 with a new vector not in the span of c1, the image plane tilts to a new orientation in 3D. Inputs still map to xc1 + yc2, but the sheet lies differently in space. This control lets you shape the output geometry. It emphasizes the power of choosing columns.
💡
Detecting independence quickly: For 3-by-2, check if c2 is a multiple of c1. If not, the columns are independent and the image is a plane. If so, it’s a line. This simple test predicts the output’s dimension.
💡
Understanding degrees of freedom: A 2D input has two degrees of freedom (x and y). After mapping with a 3-by-2 matrix, the outputs are limited to a 2D shape (a plane) in 3D. You didn’t gain new independent directions; you just placed the old ones into a bigger space. This example ties algebra to geometry.
💡
Reconstructing the product matrix: Given N (2-by-2) and M (3-by-2), compute P = MN by columns. Find Ne1 and N*e2 in 2D, then apply M to each. Place those results as columns of P. Now P sends any 2D input to the same place as doing N then M.
💡
Line direction from a 3-by-1 column: If c1 = abc^T, the output line points in the direction (a, b, c). Scaling the input scales distance along this direction. Negative inputs reverse direction. This links a single column to a whole 3D line.
💡
Image always passes through origin: For any non-square matrix, the shape you get (line, plane) goes through (0,0,0,...) because 0 maps to 0. If your mental picture has a shifted plane, it’s not the image of a linear map. This example keeps drawings honest. It’s a must-remember check.
05Conclusion
Non-square matrices provide a precise and visual way to map between spaces of different dimensions. A 3-by-2 matrix takes the two basis directions of the 2D plane and lands them as two 3D vectors, and every input is a mix of those columns. The image of the entire 2D space becomes a flat subspace in 3D, typically a plane through the origin if the columns are independent, or a line if they are not. A 3-by-1 matrix shows the simplest dimension change: the number line becomes a 3D line pointing in the direction of its single column. These patterns generalize: an m-by-n matrix maps nD inputs to mD outputs, and the columns always tell where the standard basis goes.
Matrix multiplication ties everything together as composition. If the inner dimensions match, the product is defined and represents doing one transformation after another. The columns of the product are the final positions of the basis vectors after both steps, making the geometry behind multiplication very clear. This perspective makes it easy to build complex transformations from simple ones and to read their overall effect at a glance.
To practice, take small matrices with easy numbers, compute images of sample inputs, and sketch where the outputs lie. Check whether the image is a plane, a line, or just the origin by testing column independence. Try composing a 2D-to-2D map with a 2D-to-3D map and verify the shape and orientation of the resulting image plane. These exercises strengthen the link between algebraic rules and geometric pictures.
The next natural step is to study square matrices in higher dimensions, like 3-by-3 maps of 3D space to itself, and to explore concepts like rank, null space, and inverses more deeply. But the core message remains: columns show where basis vectors go, and that single idea powers every calculation and picture. Keep checking shapes, use the column picture to compute, and remember that linear maps always send 0 to 0 and preserve straightness. With these habits, you can understand and design transformations between dimensions confidently.
✓Reconstruct product columns by following basis flow. The columns of A*B are A applied to B’s columns. Compute B’s columns, map them with A, and stack them. This method makes multiplication feel natural and visual.
✓When mapping from lower to higher dimensions, you embed a flat shape. A 3-by-2 matrix places a 2D sheet in 3D; a 3-by-1 puts a line in 3D. Don’t expect to fill all of 3D from a 2D input. This prevents over-promising what your map can do.
✓When mapping from higher to lower dimensions, you lose information. A 2-by-3 matrix flattens 3D into 2D, often merging different inputs to the same output. Plan for this loss if you want to recover inputs later. Understand that inverses may not exist.
✓Always include the origin in your mental picture. Since 0 maps to 0, your image must pass through the origin. Use this as a check when sketching planes and lines. It keeps your intuition honest.
✓Think in degrees of freedom. The input’s dimension caps how many independent directions the output can show. This explains why 2D inputs give at most planes in any output space. It also explains why composition can’t magically add independence.
✓Use simple numeric examples to build intuition. Choose easy columns and compute a few outputs by hand. Then tilt, scale, or swap columns and see how the image changes. This practice cements the concepts.
✓Avoid shape mismatches in multiplication. If inner sizes don’t match, the product is undefined. Check shapes before pressing “enter” or writing a result. This prevents common and costly mistakes.
✓For 3-by-1 matrices, remember the direction-speed idea. The single column gives direction, and the input number gives how far along it you go. Positive and negative inputs handle direction; size handles distance. This makes 1D-to-3D mapping intuitive.
✓Use rank as a diagnostic tool. Rank equals the image’s dimension and tells you whether the output is a plane, a line, or a single point. If results look collapsed, check for dependent columns. Rank explains why.
Standard basis
The standard basis is the simplest set of vectors that point along the axes. In 2D they are (1,0) and (0,1); in 3D they add (0,0,1). Any vector can be built as a combination of these. Knowing where these go under a matrix tells you the whole transformation. They are like unit steps in each direction.
i-hat, j-hat, k-hat
These are names for the standard basis vectors in 3D: i-hat = (1,0,0), j-hat = (0,1,0), k-hat = (0,0,1). In 2D, we use i-hat = (1,0) and j-hat = (0,1). They mark the basic directions along the axes. Matrices tell you where these arrows land. From that, you can find any output.
Column picture
The column picture says that multiplying a matrix by a vector equals a mix of the matrix’s columns using the vector’s components. Each input component scales a matching column, and you add them up. It’s a simple and visual method. It works for any matrix shape. It helps you see how dimensions change.
Row-by-column rule
This rule computes each output component as a dot product of a row of the matrix with the input vector. Do this for each row to build the full output. It’s the standard calculator method. It always matches the column picture results. It’s useful for detailed numeric work.
