Verifying Algebraic Solutions by Substitution

Welcome back. In the previous lesson, you translated quantitative formulas into Python using named variables, arithmetic operators, and parentheses. You also saw that Python’s = means assignment, not a mathematical claim of equality.

Now we add an essential discipline for algebra and modelling: checking a proposed answer. Whether you solve an equation by hand, rearrange a formula, or calculate a result in code, substitution lets you test whether the candidate actually satisfies the original relationship. Plan for about 30 minutes.

---

What it means to verify a solution

Consider an equation such as

$$12q+500=3500$$

Suppose someone proposes that

$$q=250$$

To verify this proposed solution, do not repeat the process used to find $q$. Instead, substitute $250$ for every occurrence of $q$ in the original equation and see whether the left-hand side and right-hand side are equal.

$$12(250)+500=3500$$

Evaluate the left-hand side:

$$12(250)+500=3000+500=3500$$

The right-hand side is also $3500$. Therefore,

$$3500=3500$$

So $q=250$ is a verified solution.

In a market interpretation, $q$ could be the number of units sold, $12$ could be USD received per unit, and $500$ could be a fixed payment in USD. Both sides of the equation are then measured in USD, which is another quick reasonableness check.

A verification answers one precise question:

Does this candidate satisfy the original equation?

It does not explain how the candidate was found, and it does not establish that a failed candidate is “almost right.” It either satisfies the condition or it does not.

A reliable manual checking routine

For a one-variable equation, use this sequence:

1. Write down the original equation.
2. Replace every occurrence of the variable with the proposed value.
3. Use parentheses around a substituted negative number or fraction.
4. Calculate the left-hand side and right-hand side separately.
5. Compare the final values and state a conclusion.

The original equation matters. A mistake in algebraic rearrangement can sometimes be hidden if you check only a later line of your working.

---

Substitution with signs, parentheses, and order

Negative values are where careful notation matters most. Consider

$$5-2x=17$$

and the proposed solution

$$x=-6$$

Substitute $-6$ for $x$, keeping parentheses around the negative value:

$$5-2(-6)=17$$

Then calculate:

$$5+12=17$$ $$17=17$$

Therefore, $x=-6$ is correct.

Without parentheses, it is easy to lose track of the two minus signs. Treat substitution as a literal replacement: wherever you see $x$, insert $(-6)$.

Now compare that with a failed candidate for the earlier quantity equation:

$$12q+500=3500$$

Test $q=240$:

$$12(240)+500=2880+500=3380$$

But the right-hand side remains $3500$, so

$$3380\ne 3500$$

Thus, $q=240$ does not solve the equation.

When a check fails, review these possibilities before concluding that the original solution is wrong:

• You may have copied the equation incorrectly.
• You may have substituted the candidate into only part of the equation.
• A negative sign or parentheses may have been lost.
• There may be an arithmetic error.
• The proposed value may genuinely not be a solution.

The following short video reinforces the mechanics of substitution and the use of order of operations. Its examples concern evaluating expressions, which is exactly the computational core of checking an equation.

Python follows the same arithmetic priorities you use by hand. The operator-precedence reference below is useful when you need to inspect a longer expression. In particular, arithmetic is evaluated before an equality comparison, and parentheses make your intended grouping explicit.

---

Turning an algebraic check into Python

Python can perform the same verification, but it is important to distinguish two symbols:

Symbol	Meaning in Python	Example
=	Assign a value to a variable name	quantity = 250
==	Test whether two values are equal	left_side == right_side

Mathematics uses $=$ to claim equality. Python uses = to store a value. To ask whether two already-calculated values are equal, use ==.

Here is the quantity example in Python:

unit_receipt_usd = 12.0
fixed_receipt_usd = 500.0
target_receipt_usd = 3500.0

candidate_quantity = 250

left_side = unit_receipt_usd * candidate_quantity + fixed_receipt_usd
right_side = target_receipt_usd

print(left_side)
print(right_side)
print(left_side == right_side)

The output is:

3500.0
3500.0
True

The Boolean value True means that the candidate satisfies the equation. Notice the parallel with the manual work:

$$\text{left side}=12(250)+500$$ $$\text{right side}=3500$$

The code deliberately stores each side separately. This makes a failed check informative: you can see which numerical values Python compared, rather than seeing only False.

Now test the incorrect candidate:

candidate_quantity = 240

left_side = unit_receipt_usd * candidate_quantity + fixed_receipt_usd

print(left_side)
print(right_side)
print(left_side == right_side)

This produces:

3380.0
3500.0
False

Recall a key point from the previous lesson: changing candidate_quantity alone does not update left_side. You must run the line that recalculates left_side after changing the candidate.

Do not write this when you mean to check equality:

left_side = right_side

That line overwrites the old value of left_side with the value of right_side. It does not test the equation. The checking line is:

left_side == right_side

---

A brief Python reference for equality tests

The relevant parts of Real Python’s Operators and Expressions in Python clarify the distinction between assignment and comparison.

For the current type of algebra problem, integer-valued and clean decimal-valued calculations will usually compare exactly. In later data analysis, you may encounter decimal rounding effects: two values that are mathematically intended to match can differ by a tiny computer-storage error. In that case, inspecting the difference between the two sides is often more informative than relying only on ==. For now, clear intermediate variables and direct equality checks are the right foundation.

---

A compact checking template

For any equation with a proposed numerical solution, you can use this pattern.

By hand

$$\text{original equation}$$ $$\text{left side after substitution}=\text{right side after substitution}$$

Then state whether the two numerical values agree.

In Python

candidate =  # proposed value

left_side =  # original left-hand expression, using candidate
right_side = # original right-hand expression

print(left_side)
print(right_side)
print(left_side == right_side)

The aim is not merely to get True. It is to make the check auditable: another person, or your future self, should be able to see the original relation, the candidate, both evaluated sides, and the conclusion.

---

Key takeaways

To verify an algebraic solution, substitute the proposed value into the original equation and evaluate both sides.

• A candidate is a solution only if the two sides have the same value.
• Parentheses are especially important when substituting negative values.
• A failed check may reveal a copying, sign, substitution, or arithmetic error—or an incorrect candidate.
• In Python, = assigns a value, while == tests equality.
• Calculate and print left_side and right_side separately before checking them with ==.
• After changing a candidate value, recalculate any dependent expressions.

This completes the module on quantitative foundations and Python as a calculator. Next, you will begin working with functions: identifying which quantity is the input, which is the output, and how a formula describes their relationship.