Linear Equations for AI: Turn One Formula Into a Geometric Line

A small classifier assigns a score to two features:

The feature pairs $(0,5)$, $(1,3)$, and $(2,1)$ look different, yet each gets the same score:

Those are not three isolated coincidences. They sit on one geometric line, and every point on that line receives score zero. By the end of this lesson, you will be able to turn a two-variable linear equation into a line, produce and test solutions, and recognize the same geometry inside a linear classifier score contour.

Learning outcome: Convert a two-variable linear equation into a line and test solutions.

This lesson builds directly on Lesson 9: Equations for AI, where an equation became a constraint that selects a solution set. Here the allowed values are pairs $(x,y)\in\mathbb R^2$, and geometry lets us see that set. Lesson 10: Reading AI Derivations supplies the companion habit: every rearrangement must preserve exactly the same points.

The official Mathematics for Machine Learning companion places systems of linear equations at the start of linear algebra. Its Section 2.1 explains the geometric view that one equation in two variables represents a line and that a system asks where such lines intersect. This lesson isolates the one-line foundation. Its examples, code, visual, and assessments are original, and the next lesson will add the second equation.

One equation describes a place

Consider the general two-variable equation

where $x$ and $y$ are real-valued coordinates and $a$, $b$, and $c$ are fixed real coefficients. The equation is linear because $x$ and $y$ appear only to the first power, are not multiplied by each other, and are multiplied only by fixed numbers.

Suppose $b\ne0$. Subtract $ax$ from both sides, then divide by the known nonzero number $b$:

This is slope-intercept form, $y=mx+q$. The slope is $m=-a/b$: increasing $x$ by one unit changes $y$ by $-a/b$ units while the constraint remains true. The vertical-axis intercept is $q=c/b$, reached when $x=0$.

The rearranged formula does more than make plotting convenient. It exposes one free choice. Pick any real $x$; the equation calculates exactly one matching $y$. As $x$ varies continuously, the solution point traces a line rather than a finite collection of dots.

One worked line reveals slope, intercepts, and points

Work through

Here $a=3$, $b=2$, and $c=12$. Because $b$ is nonzero, solving for $y$ is legal:

The line has slope $-3/2$. If $x$ rises by $2$, $y$ falls by $3$. That paired change keeps the left side fixed because

A residual turns that truth test into one number:

Points on the line have residual $0$. A nonzero residual gives both a failed test and a sign: positive means the weighted sum is above $12$, and negative means it is below $12$.

Two distinct points are enough to draw this line, but they are not the whole solution set. The controlled visual makes the missing family tangible.

The first server-rendered state is $(2,3)$, and the table beneath the chart contains the same calculation. The line does not need JavaScript to make its mathematical point; hydration adds the ability to choose another $x$ and watch the matching $y$ change. The control uses fixed quarter-unit steps for inspection, while the mathematical parameter can be any real number.

A parameter accounts for the entire line

Writing down several points suggests a pattern, but a parameter describes all of them at once. Let $t$ be any real number and set

Every pair in this family is a solution because

The converse matters too. Any pair satisfying $3x+2y=12$ must also satisfy $y=6-\tfrac32x$. Choosing $t=x$ places that pair in the parameterized family. Together, those two directions show that the parameterization includes every point on the line and no off-line point.

This is why a graphing window never contains the whole mathematical object. Pixels and sampled coordinates are finite; the line is the infinite solution set specified by the equation.

NumPy generates points; the original equation verifies them

The code should mirror the algebra. NumPy documents linspace as returning evenly spaced samples over a specified interval. Generate a few $x$ values, calculate their matching $y$ values, and then test the original constraint rather than trusting the rearrangement:

import numpy as np
import matplotlib.pyplot as plt

# 3x + 2y = 12  ->  y = (12 - 3x) / 2
x = np.linspace(-2.0, 6.0, num=5)
y = (12.0 - 3.0 * x) / 2.0
residual = 3.0 * x + 2.0 * y - 12.0

print("x:", x)
print("y:", y)
print("residual:", residual)
print("on line:", np.isclose(residual, 0.0, rtol=0.0, atol=1e-12))

candidates = np.array([[2.0, 3.0], [2.0, 4.0], [4.0, 0.0]])
candidate_residual = 3.0 * candidates[:, 0] + 2.0 * candidates[:, 1] - 12.0
print("candidate residual:", candidate_residual)
print(
    "candidate on line:",
    np.isclose(candidate_residual, 0.0, rtol=0.0, atol=1e-12),
)

plt.plot(x, y, label="3x + 2y = 12")
plt.plot(candidates[:, 0], candidates[:, 1], "o", label="tested points")
plt.xlabel("x")
plt.ylabel("y")
plt.legend()
plt.show()

The executed output is:

x: [-2.  0.  2.  4.  6.]
y: [ 9.  6.  3.  0. -3.]
residual: [0. 0. 0. 0. 0.]
on line: [ True  True  True  True  True]
candidate residual: [0. 2. 0.]
candidate on line: [ True False  True]

np.isclose compares floating-point values with an explicit tolerance. Here rtol=0.0 and atol=1e-12 mean “accept a residual whose absolute magnitude is at most $10^{-12}$.” That is a numerical engineering decision at this example’s scale, not a symbolic proof that the equation holds. The proof came from the algebra; the code checks that this implementation agrees.

The plotting call follows Matplotlib’s plot contract: the supplied arrays provide the horizontal and vertical coordinates of the line nodes. A denser plot would look smoother, but it would not create more mathematical solutions.

A classifier contour is the same equation with feature names

Return to the opening score:

Here $x_1$ and $x_2$ are input features, $2$ and $1$ are fixed weights, and $-5$ is an intercept. A score contour collects all feature pairs that receive one chosen score. The zero-score contour satisfies

That is a line. Moving from $(1,3)$ to $(2,1)$ raises $x_1$ by $1$ and lowers $x_2$ by $2$, leaving the score unchanged:

This form is not invented for the diagram. An official scikit-learn LinearSVC example shows the decision function calculated as a feature matrix multiplied by learned coefficients plus an intercept. The scikit-learn RidgeClassifier documentation also states its binary confidence score is proportional to signed distance from the separating hyperplane and documents that a score above zero predicts its second class.

For this educational classifier, choose the explicit rule

Under that convention, the zero contour is the decision boundary: crossing it changes the predicted class. Points on one side have a positive score and points on the other have a negative score. The line alone does not specify the tie rule or class names; those belong to the prediction convention. Nor is the raw score automatically a probability.

Division by zero reveals the missing cases

The sentence “$ax+by=c$ is a line” needs one condition: $a$ and $b$ cannot both be zero. Solving for $y$ needs the stronger local condition $b\ne0$.

For example, $2x+0y=6$ simplifies to $x=3$. Every point $(3,y)$ works, so the line is vertical. Trying to produce $y=mx+q$ by dividing by $b=0$ is not an awkward route—it is undefined. A vertical line has no finite slope because its $x$ coordinate does not change while $y$ can.

There is one more practical misconception to avoid. Two plotted points can determine a nondegenerate line, but passing two tests does not prove arbitrary code represents the intended equation. A swapped coefficient can still put those particular points in the expected places. Evaluate the residual for several deliberately chosen points, including an off-line point, and retain the algebraic derivation as the source of truth.

One more constraint will turn lines into intersections

One equation leaves one free coordinate: choose $x$, and the line determines $y$—or, for a vertical line, choose $y$ while $x$ stays fixed. That freedom is why a single equation usually has infinitely many coordinate-pair solutions.

The next lesson will impose a second equation on the same pair. A solution will then need to lie on both lines at once. The point-on-line test developed here becomes an intersection test, and the geometry will reveal why a system can have one solution, no solution, or an entire shared line.

Check your understanding

residual = 3.0 * x + 2.0 * y - 12.0
on_line = np.isclose(residual, 0.0, rtol=0.0, atol=1e-12)