Mathematics as a Process
Many mathematical tasks can be described as procedures. We begin with some information, apply a sequence of operations or decisions, and produce a result. When that procedure is stated precisely enough to be carried out repeatedly, it can be treated as an algorithm.
Algorithms are not limited to computer programming. Long division, the Euclidean algorithm, solving an equation, converting units, searching for a root, sorting values, evaluating a formula, and constructing a table can all be described algorithmically.
This section develops the habits needed to think about mathematics as a sequence of structured actions. Students learn to identify inputs and outputs, organize steps, make decisions, repeat processes, describe recursion, compare exact and approximate methods, test procedures, and communicate algorithms clearly.
Lessons
- Procedures and Algorithms — Introduces repeatable mathematical procedures and distinguishes informal methods from clearly specified algorithms.
- Problems, Inputs, Processes, and Outputs — Breaks mathematical tasks into the information supplied, the actions performed, and the results produced.
- Decision Rules and Branching — Develops procedures in which different actions are selected according to whether specified conditions are satisfied.
- Repetition and Iteration — Uses repeated steps to generate sequences, refine estimates, process collections, and carry out recurring calculations.
- Introductory Recursion — Introduces processes in which later stages are defined using earlier stages or smaller versions of the same problem.
- Tables and Pseudocode — Represents procedures through organized tables and language-like algorithm descriptions without requiring a specific programming language.
- Calculator and Spreadsheet Methods — Uses common computational tools to automate formulas, repeated calculations, tables, and numerical exploration.
- Symbolic and Numerical Computation — Distinguishes calculations performed with exact symbolic expressions from calculations performed with numerical values and approximations.
- Exact and Approximate Methods — Compares procedures that produce exact results with methods designed to approach sufficiently accurate numerical answers.
- Termination and Stopping Conditions — Examines how algorithms determine when a process is finished and why poorly designed repetition may fail to stop.
- Introductory Efficiency — Compares algorithms according to the amount of work, repetition, storage, or computation required to reach a result.
- Testing, Debugging, and Error Detection — Develops methods for identifying failures, tracing incorrect results, testing special cases, and correcting flawed procedures.
- Communicating Algorithms Clearly — Establishes conventions for writing mathematical procedures so that another person or computational system can follow them reliably.
Algorithms Begin with a Clearly Defined Problem
Before a procedure can be designed, the problem itself must be understood. What information is available? What result is required? What assumptions or restrictions apply? What type of mathematical object should the output be?
Thinking in terms of inputs, processes, and outputs encourages this separation. Inputs provide the starting information, the process transforms that information, and the output records the result.
This structure appears throughout mathematics. A function maps inputs to outputs, a formula transforms known quantities into another quantity, and an algorithm describes the sequence of steps used to carry out such a transformation.
Procedures Must Be Precise Enough to Follow
An informal instruction such as “simplify the expression” may be meaningful to an experienced mathematician, but it does not yet specify a complete algorithm. A more explicit procedure identifies which transformations may be used, in what circumstances, and how the process decides that no further action is needed.
Precision matters because an algorithm should be reproducible. Two people given the same inputs and following the same deterministic algorithm should arrive at the same result.
This does not mean every mathematical method must become rigid. Creative reasoning remains important. Algorithms are especially valuable for the portions of a problem that can be organized into dependable repeatable steps.
Decision Rules Create Branches
Not every procedure follows the same path for every input. A decision rule examines a condition and selects an appropriate action.
For example, an algorithm may behave differently depending on whether a number is positive or negative, whether a denominator is zero, whether a candidate solution passes a test, or whether an approximation has reached the desired accuracy.
These choices create branches. Conditional reasoning from mathematical logic therefore becomes part of algorithm design: if a condition is satisfied, perform one action; otherwise perform another.
Iteration Repeats a Process
Iteration applies a step or sequence of steps repeatedly. Repetition may continue a fixed number of times, once for every element of a collection, or until some mathematical condition is satisfied.
Many useful mathematical procedures are iterative. Repeated multiplication generates powers, repeated updates generate sequences, numerical methods refine approximations, and spreadsheets can apply the same formula across many rows or columns.
Iteration converts a simple local rule into a potentially large process. Learning to identify the repeated structure can make complicated calculations easier to describe and automate.
Recursion Builds from Earlier Cases
Recursion defines a process or object using earlier instances of the same process. A recursive sequence may determine each new term from preceding terms, while a recursive algorithm may solve a large problem by reducing it to smaller versions of that problem.
Recursion therefore requires two structural ingredients: a rule describing how one case depends on another and at least one base case that does not require further recursion.
Without a suitable base case or stopping condition, a recursive procedure may continue indefinitely. This makes recursion a natural place to connect mathematical definition, algorithm design, and termination.
Pseudocode Describes Algorithms Without Programming Syntax
Pseudocode provides a convenient intermediate language between ordinary explanation and executable computer code. It can describe variables, calculations, conditions, loops, and outputs without requiring the syntax of a particular programming language.
The purpose is clarity rather than formal compilation. A reader should be able to identify what the procedure does, what order the steps occur in, when decisions are made, and when repetition begins or ends.
This makes pseudocode useful even when no computer program will be written. It forces a mathematical procedure to become explicit enough to inspect, test, and communicate.
Tables Can Represent Computation
Tables are especially useful when an algorithm develops through repeated stages. One column may contain an input, another the current estimate, and another the result of applying the next update rule.
This structure allows each stage of an iterative process to be examined rather than hiding the entire calculation behind one final answer.
Tables also connect naturally to spreadsheets, where formulas can automate repeated relationships and make computational patterns visible across many examples.
Calculators and Spreadsheets Extend Manual Computation
Computational tools are valuable when they automate repetitive work while leaving the mathematical structure understandable. A calculator can evaluate complicated expressions quickly, while a spreadsheet can apply formulas across large collections of data.
Spreadsheets are particularly useful for tables, recurrence relations, financial models, numerical approximation, unit conversions, and exploring how results change when inputs are modified.
The goal is not to replace mathematical understanding with software. Students should still know what relationships are being calculated, why the formulas are appropriate, and how to recognize results that do not make sense.
Symbolic and Numerical Computation Serve Different Purposes
Symbolic computation works with mathematical expressions in exact form. Simplifying \(\frac{2}{6}\) to \(\frac{1}{3}\), factoring a polynomial, or solving an equation algebraically preserves mathematical structure.
Numerical computation replaces expressions with numerical approximations. The value \(\frac{1}{3}\) may be approximated as \(0.3333\), and an irrational root may be represented by a decimal accurate to a specified number of digits.
Neither approach is always superior. Symbolic methods preserve exact relationships, while numerical methods may be more practical for measurement, modeling, large calculations, or problems without convenient closed-form solutions.
Exact and Approximate Algorithms
An exact method produces the mathematically exact result when its assumptions are satisfied. An approximate method instead aims to produce a value sufficiently close to the desired result.
Approximation becomes necessary when exact solutions are unavailable, inefficient, or more detailed than the application requires. Numerical root finding, iterative estimation, and many scientific calculations therefore use algorithms that improve an estimate step by step.
The important question becomes not simply whether the answer is exact, but whether its uncertainty and error are understood and appropriate for the problem.
Algorithms Need Stopping Conditions
A repeated process must eventually determine whether it should continue. Some algorithms stop after a predetermined number of steps. Others stop when a target has been reached or when successive values differ by less than a specified tolerance.
A stopping condition must be designed carefully. Stopping too early may produce an inadequate answer, while a condition that can never be reached may cause the algorithm to continue indefinitely.
Termination is therefore part of correctness. A procedure that knows how to take the next step but never determines when it is finished may not constitute a useful solution method.
Efficiency Matters When Problems Grow
Two algorithms can produce the same result while requiring very different amounts of work. For small examples, that difference may be unimportant. For large problems, it can become decisive.
Efficiency may involve reducing the number of arithmetic operations, avoiding unnecessary repetition, using less storage, or choosing a representation that makes the calculation simpler.
The treatment here is introductory. The main goal is to establish the habit of asking whether a correct method is also reasonably economical and whether another procedure could accomplish the same task with less effort.
Testing Reveals Whether an Algorithm Works
A procedure should be tested on more than one convenient example. Ordinary cases, boundary values, special cases, invalid inputs, and deliberately difficult examples can expose assumptions or failures that would otherwise remain hidden.
Testing does not by itself prove that an algorithm works for every possible input, but it provides valuable evidence and can quickly reveal errors.
This connects algorithm testing to earlier mathematical reasoning. Counterexamples can refute general claims, boundary tests examine limiting cases, and verification checks whether outputs satisfy the requirements of the original problem.
Debugging Locates the Source of Failure
When an algorithm produces an incorrect result, debugging investigates where the procedure departed from the intended logic.
The error may come from incorrect input, a wrong formula, a faulty branch condition, an improperly updated variable, a missing stopping rule, rounding, or a misunderstanding of the underlying mathematics.
Tracing intermediate steps helps isolate the source. This is one reason transparent tables, pseudocode, and clearly separated stages are useful: they make the procedure inspectable rather than treating the calculation as a black box.
Algorithms Should Be Communicated Clearly
A useful algorithm should tell the reader what information is required, what steps must be performed, which choices may occur, how repetition operates, and what result should be produced.
Ambiguous instructions weaken reproducibility. Statements such as “repeat until close enough” are incomplete unless “close enough” has been defined. Likewise, a procedure should specify what happens when expected conditions fail.
Clear algorithmic communication therefore combines mathematical precision with practical readability.
Computational Thinking as a Reusable Mathematical Tool
The ideas introduced here will appear throughout Malone Math. Algebraic procedures will become algorithms, recursive rules will generate sequences, numerical methods will approximate roots, matrices will organize repeated calculations, and probability and discrete mathematics will rely on systematic counting and search procedures.
Later work in modeling and analysis will use iterative algorithms, stopping conditions, tolerance, efficiency, and verification at increasingly sophisticated levels.
The objective of this section is therefore not to teach programming as a separate subject. It is to establish computational thinking as another way of organizing mathematical reasoning: define the problem, structure the process, carry it out, test the result, and improve the method when necessary.