Designing Geometric Algorithms
What an algorithm is
An algorithm is a precise recipe: a finite list of unambiguous steps that, followed exactly, solves a problem every time. This unit applies that computational idea to geometry, designing algorithms built from geometric constructions and theorems, then testing and refining them until they work in every case. The skill is not just writing steps, but judging whether those steps are correct, and improving them when they are not.
Sequences and decisions
Two kinds of instruction make up almost every algorithm. The first is a sequence: ordered steps carried out one after another, where the order genuinely matters. The second is a decision, a branch of the form if a condition holds, do one thing, otherwise do another. A geometry algorithm weaves these together, using measured or constructed facts as the conditions that steer the decisions. Describing an algorithm clearly, in numbered steps with explicit if-then choices, is the first half of the work.
Constructions as algorithms: bisecting an angle
Geometric constructions are natural algorithms, because each is a fixed sequence of compass-and-straightedge steps. To bisect an angle, you draw an arc from the vertex crossing both arms, then equal arcs from the two crossing points, then the line from the vertex through their intersection. Followed in order, these steps always halve the angle. The reason is a theorem: the construction quietly builds two triangles with three equal sides each, which are congruent, so the two halves of the angle must be equal. The algorithm and the theorem that guarantees it go hand in hand.
The perpendicular bisector
The perpendicular bisector of a segment is another construction algorithm. From each endpoint, draw arcs of the same radius, large enough to cross, then join the two intersection points. Every point on the resulting line is equidistant from the two endpoints, which is exactly what being the perpendicular bisector means. Here again a sequence of steps produces a guaranteed geometric result, and naming the theorem behind it explains why the recipe can be trusted.
Decisions that branch: classifying a triangle
Decisions in geometry often test a property and branch on the answer. Consider an algorithm that classifies a triangle from its three side lengths. A first attempt might say: if two sides are equal, report isosceles, otherwise report scalene. Testing this on a triangle with sides five, five and five exposes a flaw, because it reports isosceles when the triangle is really equilateral. The fix is to reorder the decisions: first check whether all three sides are equal and report equilateral, then check for exactly two equal sides for isosceles, and only then fall through to scalene. Re-testing confirms the refined version handles every case.
Testing and refining
This loop of testing and refining is the heart of good algorithm design. You run the algorithm on carefully chosen examples, including awkward edge cases, watch for inputs that give a wrong or missing answer, then change the steps and run the tests again. A second example is an algorithm that decides whether a triangle is right-angled. Sort the three sides so the longest is last, then test whether the sum of the squares of the two shorter sides equals the square of the longest. For sides three, four and five this holds, so the triangle is right-angled; for four, five and six it fails, so it is not. Choosing the right condition, and ordering the sides first, is what makes the decision reliable.
Evaluating a refinement
Evaluating a refinement means asking not only whether it now works, but whether it is clear, efficient and complete. A good algorithm covers every possible input, branches in a sensible order, and avoids unnecessary steps. When deciding triangle congruence, for instance, the valid tests are side-side-side, side-angle-side with the angle between the two sides, angle-side-angle, and right-angle-hypotenuse-side; testing two sides and a non-included angle is not enough to guarantee congruence, a subtlety a careful algorithm must respect. Designing, testing, refining and then judging an algorithm against these standards turns a rough set of steps into a dependable geometric procedure.