A modern computer looks like an engineering object.

A phone looks like electronics.

An AI model looks like software.

A GPS system looks like satellites and radio.

But underneath those layers sits another infrastructure we rarely see: centuries of mathematical ideas.

A recent Go2Tutors article collects 18 mathematicians and scientists whose ideas eventually influenced modern technology. The list is a useful excuse to examine the story more carefully.

Because saying “Newton invented calculus, therefore we have rockets” or “Gauss created modern cryptography” works as an introduction, but it flattens the history too much.

The real story is more interesting.

Modern technology looks like a stack:

mathematical ideas
        ↓
models and abstractions
        ↓
methods of calculation
        ↓
algorithms
        ↓
computer architectures
        ↓
languages and compilers
        ↓
modern systems
        ↓
AI, navigation, graphics, science

No single person built the whole stack.

Each generation inherited abstractions from the ones before it.

1. Al-Khwarizmi: the idea of procedure existed before software

Muhammad ibn Musa al-Khwarizmi lived in the ninth century.

His Latinized name eventually gave us the word algorithm. The term algebra derives from the title of one of his treatises.

That matters because an algorithm is not a computer.

It is something more fundamental:

a defined sequence of operations that transforms an input into an output.

That pattern appears in every program:

input
  ↓
rules
  ↓
defined steps
  ↓
output

Computing industrialized the idea. It did not invent the idea from nothing.

2. Pythagoras: geometry as infrastructure

The theorem associated with Pythagoras predates computers by many centuries.

Yet relationships between coordinates, distance, and Euclidean geometry appear everywhere:

  • 2D and 3D graphics;
  • computer vision;
  • game physics;
  • robotics;
  • navigation;
  • distance calculations.

A common simplification is worth correcting: GPS does not simply “run on the Pythagorean theorem.”

Satellite positioning uses timing measurements, geometry involving multiple satellites, coordinate systems, and relativistic corrections.

But the deeper idea remains the same: positions and spatial relationships can be represented mathematically.

3. Descartes: turning space into numbers

René Descartes made a decisive connection between algebra and geometry.

A position could be represented as coordinates:

(x, y)

and in three dimensions:

(x, y, z)

This feels trivial because we learn it in school.

It is an extraordinarily powerful abstraction.

In computer graphics, a scene becomes points, vectors, matrices, and transformations.

In robotics, the position of a mechanical arm can be expressed in coordinate frames.

In digital maps, location becomes numeric representation.

Descartes helped establish a language that lets us compute over space.

4. Newton: describing change

Isaac Newton and Gottfried Wilhelm Leibniz independently developed calculus in the seventeenth century.

Calculus lets us reason about quantities that change continuously:

position
   ↓ derivative
velocity
   ↓ derivative
acceleration

and in the opposite direction:

acceleration
   ↓ integration
velocity
   ↓ integration
position

Engineering, fluid dynamics, simulation, control, and modern physics all depend on this way of thinking.

There is also a connection to machine learning.

Training neural networks relies heavily on gradient-based optimization. That does not mean Newton invented backpropagation, but derivatives and rates of change are part of the mathematical infrastructure that makes modern optimization possible.

5. Euler: from bridges to networks

In 1736 Leonhard Euler analyzed the Seven Bridges of Königsberg problem.

Instead of focusing on physical distances, he reduced the problem to connections.

That helped open the path to what we now call graph theory.

A graph might look like this:

A ─── B
│   ╱ │
│ ╱   │
C ─── D

The abstraction is remarkably general.

It can represent:

  • routers and network links;
  • users and social relationships;
  • cities and roads;
  • software dependencies;
  • web pages and hyperlinks;
  • tasks and dependencies inside an agent workflow.

Modern route-finding in a network has an intellectual ancestor in that old bridge puzzle.

MacTutor describes Euler’s Königsberg work as one of the beginnings of graph theory and topology.

6. Pascal: mechanical calculation and probability

Blaise Pascal built a mechanical calculator to help with administrative arithmetic.

That places him in the long history of attempts to externalize mental operations into machines.

But his technological legacy also runs through probability.

Modern systems constantly make decisions under uncertainty:

fraud?
rain?
what token comes next?
which route is lower risk?
which experiment is promising?

Probability and statistics are fundamental languages for turning uncertainty into calculation.

7. Gauss: measure, estimate, correct

Carl Friedrich Gauss made enormous contributions to number theory, astronomy, geometry, and statistical methods.

One particularly important connection to modern systems is estimation from noisy data.

Real sensors never produce perfect measurements.

A navigation system might receive:

measurement 1 → slightly high
measurement 2 → slightly low
measurement 3 → noisy

The task is to infer the most plausible underlying state.

Least-squares methods and later probabilistic techniques belong to the genealogy of methods used in science, positioning, and signal processing.

The number theory Gauss worked on also became central to areas such as modern cryptography, although today’s cryptosystems emerged much later and should not be attributed directly to him.

8. Sophie Germain: abstract mathematics enters engineering

Sophie Germain worked in number theory and elasticity.

Her research on elastic surfaces contributed to the mathematical description of how materials vibrate and deform.

That step — turning physical behavior into equations — is essential to engineering.

Before manufacturing a structure, we can model it:

material
 + geometry
 + load
 + equations
      ↓
estimated response

The same philosophy lies behind modern numerical simulation.

9. Emmy Noether: symmetry turned into physical law

Emmy Noether’s theorem establishes a deep relationship between symmetries and conservation laws.

In very simplified form:

time symmetry
      ↓
energy conservation

and other symmetries correspond to other conserved quantities.

MacTutor describes the result as a fundamental connection between symmetry and conservation principles.

This is not an everyday software tool.

It is something deeper: an example of an abstract mathematical structure revealing the architecture of physical law.

10. Cantor: sets, infinities, and foundations

Georg Cantor developed modern set theory and showed that not all infinities have the same size.

At first glance this seems far removed from engineering.

But sets became part of the formal language of mathematics, logic, and computer science.

Software uses related ideas constantly:

users ∈ set of users
permissions ⊆ set of actions
result = union / intersection / difference

Not because a database literally “runs Cantor,” but because collections, membership, and relations became part of the formal vocabulary we use to describe systems.

11. Ramanujan: when ideas find applications decades later

Srinivasa Ramanujan produced extraordinary results in series, partitions, continued fractions, and number theory.

Many mathematical ideas follow a strange cycle:

abstract discovery
        ↓
decades with no obvious application
        ↓
unexpected connection
        ↓
use in physics / algorithms / theory

Ramanujan is a reminder that the value of a mathematical idea cannot always be measured by immediate usefulness.

That lesson matters for AI research too: optimizing only for visible short-term application can prevent tomorrow’s foundational tools from being discovered.

12. Mandelbrot: computing the irregular

Benoît Mandelbrot popularized and deeply developed fractal geometry.

Fractals showed that apparently irregular shapes could be described through mathematical rules and iterative processes.

The computer became crucial because it can repeat an operation millions of times and visualize the result.

simple rule
   ↓
iteration
   ↓
iteration
   ↓
iteration
   ↓
complex structure

Fractals and related techniques have influenced procedural generation, scientific visualization, and the modeling of natural forms.

Fractal ideas have also been applied to financial irregularity and scale, though they are not a universal model of markets.

13. Ada Lovelace: from calculating numbers to manipulating symbols

Ada Lovelace studied Charles Babbage’s Analytical Engine and published notes in 1843 that included a sequence of operations for calculating Bernoulli numbers.

The Computer History Museum notes that this table is often described as the first published program, while the exact division of contributions between Babbage and Lovelace remains debated.

Lovelace’s broader observation may matter even more.

She understood that a general-purpose machine could operate not merely on “numbers” in a narrow sense, but on symbols represented by numbers.

That jump is essential.

A modern computer does not fundamentally know that something is:

image
audio
text
video
code

At machine level, all of it becomes numeric representation.

Lovelace saw that possibility long before electronic computers existed.

14. Turing: defining what computation means

In his work on computable numbers, Alan Turing described an abstract machine that follows elementary rules over symbols.

The universal Turing machine showed that one machine could carry out different procedures when supplied with the appropriate instructions.

The Computer History Museum describes this abstraction as foundational to modern computability theory.

Here we reach one of computing’s central ideas:

general hardware
     +
program
     =
specific behavior

We do not need to build a new machine for every problem.

We change the program.

That conceptual separation is one of the most powerful ideas in technological history.

15. John von Neumann: instructions and data in memory

The history of stored-program architecture has multiple contributors and should not be reduced to one person.

John von Neumann was nevertheless a crucial figure in formalizing and disseminating the idea.

In 1945, his First Draft of a Report on the EDVAC described an architecture in which data and instructions could be stored electronically in memory.

The Computer History Museum documents how the IAS computer built under his supervision influenced many later machines.

The principle can be summarized as:

memory
 ├─ data
 └─ instructions

CPU
 └─ reads both

Most later general-purpose computers grew around variations of this principle.

16. Grace Hopper: letting humans program at a higher level

Early computer programming meant working extremely close to the machine.

Grace Hopper helped change that relationship.

The Computer History Museum documents that her A-0 system, completed in 1952, included features of modern compilers, and that she later played an important role in data-processing languages and COBOL.

A compiler enables something fundamental:

human idea
   ↓
high-level language
   ↓
compiler
   ↓
machine instructions

Each new layer lets us think less about electrical detail and more about the actual problem.

That same pattern continues today.

A developer can write Python without manually managing CPU registers.

Now that developer can describe intent to an AI agent that generates part of the code.

Software history can be read as a succession of layers that continuously raise the level of abstraction.

17. Katherine Johnson: mathematics that had to work in the real world

Katherine Johnson worked at NASA calculating and checking orbital trajectories.

NASA documents that she performed trajectory analysis for Alan Shepard’s flight, checked electronic-computer calculations for John Glenn’s orbital mission, and contributed to trajectory and navigation work connected to Apollo.

Here mathematics stops being merely an elegant abstraction.

A mistake could put a spacecraft in the wrong place.

Her work illustrates another essential part of engineering:

a formula becomes infrastructure only when it can be validated under real constraints.

It is also an early story of human-machine verification.

When electronic computers began to enter critical work, humans did not instantly disappear.

Important outputs were still checked.

The parallel with current AI systems is hard to miss.

18. Andrew Wiles: the value of solving problems that do not look “useful”

Andrew Wiles proved Fermat’s Last Theorem after centuries of attempts.

His proof used and strengthened deep connections between elliptic curves and modular forms.

The direct technological relevance of Fermat’s Last Theorem is far smaller than that of a compiler or a routing algorithm.

That is precisely why Wiles belongs in this story.

Mathematics does not advance only by solving problems with immediate commercial return.

It also advances by building theories.

Sometimes those theories find applications decades later.

The chain connecting everything

We can compress centuries of history into one view:

al-Khwarizmi
procedures
     ↓
Descartes / Euler / Newton
representation + networks + change
     ↓
Gauss / Pascal / Noether
estimation + probability + structure
     ↓
Lovelace / Turing
programs + computability
     ↓
von Neumann
stored program
     ↓
Hopper
languages and compilers
     ↓
Johnson
validated scientific computing
     ↓
modern software
     ↓
machine learning
     ↓
generative AI and agents

This is not a literal genealogy.

It is a genealogy of abstractions.

The lesson for the AI era

The full history leaves us with a useful conclusion.

Major technological leaps repeatedly happened because someone found a better representation.

Noether represented physical laws through symmetry.

Euler represented routes as graphs.

Descartes represented geometry through numbers.

Turing represented computation through an abstract machine.

Hopper represented machine instructions through languages closer to humans.

Modern AI models are adding another layer:

human intent
      ↓
natural language
      ↓
model / agent
      ↓
code + tools + execution
      ↓
result

That can make programming easier.

It does not remove the need to understand lower-level abstractions.

When something fails, the bug still lives in some layer:

  • logic;
  • probability;
  • geometry;
  • optimization;
  • representation;
  • algorithms;
  • architecture;
  • verification.

AI can write more code for us.

It cannot abolish the mathematics that code runs on.

Sources and further reading