Artificial intelligence is often presented as though humanity suddenly invented an entirely new form of technology. ChatGPT, image generators, autonomous systems, and modern neural networks certainly feel revolutionary. But underneath them are mathematical ideas that are decades—and in some cases more than two centuries—old.

One of the most important ancestors of modern AI is something considerably less glamorous: curve fitting.

It Starts Around 1800

Mathematicians were dealing with a problem that remains central to machine learning today: given imperfect observations, how do you construct a mathematical model that best represents them?

The method of least squares emerged around the beginning of the 19th century. Adrien-Marie Legendre published the method in 1805, while Carl Friedrich Gauss later described having used it years earlier.

Imagine plotting measurements as dots on a graph. They don't form a perfect line, so mathematics finds the line that minimizes the errors between the observations and the prediction.

That is remarkably close to what we now call training a model.

You have:

Inputs → Model → Prediction → Error → Adjustment

Modern AI performs this process on an enormously larger scale, but the basic concept should look familiar.

Then Came Regression

During the 1880s, Francis Galton studied relationships between characteristics of parents and their children and developed the concept that became known as regression.

Karl Pearson and others subsequently expanded the mathematics of correlation and regression.

A simple linear regression model might look like:

y = w₁x₁ + w₂x₂ + w₃x₃ + b

The x values are inputs.

The w values determine how important those inputs are.

The b value adjusts the result.

The model changes these values until its predictions fit the observations reasonably well.

Now compare that with one of the fundamental building blocks of artificial intelligence.

Enter the Artificial Neuron

In 1943, Warren McCulloch and Walter Pitts published a mathematical model inspired by biological neurons.

A modern simplified artificial neuron begins with something very familiar:

z = w₁x₁ + w₂x₂ + w₃x₃ + b

Look familiar?

It should.

The neuron takes inputs, multiplies them by weights, adds them together, adds a bias, and then typically passes the result through an activation function.

Output = activation(weighted inputs + bias)

The activation function is extremely important because it introduces nonlinearity. Without nonlinear operations, stacking many layers would still collapse mathematically into something equivalent to a single linear transformation.

But the underlying weighted calculation isn't some mysterious new mathematical invention.

Its ancestry reaches directly back into statistics and applied mathematics.

From One Neuron to Millions or Billions

Frank Rosenblatt's perceptron, developed in the late 1950s, demonstrated that an artificial neuron could adjust its weights based on examples.

That is where something recognizable as machine learning begins to emerge clearly.

Instead of a programmer explicitly writing:

If X happens, return Y.

the programmer provides examples and a mathematical process adjusts the weights.

Connect many artificial neurons together and you get a neural network.

Arrange them in layers and you get a multilayer neural network.

Add many layers and you eventually get what became known as deep learning.

The scale changes enormously.

The fundamental idea changes considerably less.

The Computer Keeps Guessing—and Correcting Itself

This is one of the simplest ways to demystify machine learning.

A model makes a prediction.

The prediction is compared with the expected answer.

The difference is measured using a loss function.

The system calculates how its parameters contributed to that error.

The parameters are adjusted slightly.

Then it tries again.

And again.

And again.

Millions, billions, or vastly more mathematical operations later, the model becomes increasingly good at producing outputs consistent with patterns found in its training data.

The mathematics is sophisticated, but the basic feedback loop isn't difficult to understand:

Predict → Measure Error → Adjust → Repeat

So What Actually Changed?

If these ideas are so old, why didn't we have ChatGPT in 1985?

Because modern AI isn't revolutionary merely because someone discovered a new equation.

Several technologies matured simultaneously.

Computers became dramatically faster. GPUs made enormous amounts of parallel mathematics practical. Digital storage became inexpensive. The internet produced gigantic datasets. Researchers developed better architectures and training methods. Distributed computing allowed thousands of processors to participate in training a single model.

Perhaps most importantly, researchers discovered ways to make very large neural networks actually work.

Scale changed what was possible.

A neural network containing a handful of neurons is an interesting mathematical demonstration.

A network containing billions of adjustable parameters, trained on enormous amounts of information using massive computing infrastructure, can exhibit capabilities that the pioneers of artificial intelligence could scarcely test experimentally.

Large Language Models Continue the Same Story

Large language models add extraordinary complexity, particularly through the Transformer architecture introduced in 2017.

Transformers use mechanisms such as attention to determine relationships among pieces of information. Language is broken into tokens, represented numerically, transformed through many layers, and ultimately used to calculate probabilities for what should come next.

Yet underneath all of this complexity remain familiar ingredients:

Numbers.

Weights.

Biases.

Matrix multiplication.

Functions.

Predictions.

Errors.

Parameter adjustments.

The machine hasn't escaped mathematics. It has become extraordinarily good at applying it.

Visualization to us Mere Mortals

The familiar X-versus-Y graph is mostly a visualization convenience. Regression and neural networks are not inherently limited to two dimensions.

For example, simple linear regression might be:

That's easy to draw: one input $x_1$, one output $y$, giving you a line on a 2-D graph.

Add another input:

Now you have $x_1$, $x_2$, and $y$. Instead of fitting a line, you're fitting a plane in 3-D space.

Add another:

Now you need four dimensions to geometrically represent the relationship. We can't conveniently draw that, but mathematically there's nothing unusual about it. With 100 inputs:

you're effectively fitting something in a 101-dimensional space. In linear regression, that fitted object is called a hyperplane.

Neural networks take this much further

An artificial neuron already does essentially this:

So a neuron might receive 10, 1,000, or 10,000 input dimensions. There's no mathematical requirement that we be able to visualize those dimensions.

Then the neuron applies a nonlinear activation:

And a neural network has many such neurons operating simultaneously.

Suppose a layer has 1,000 inputs and 500 neurons. Rather than thinking about individual equations, we usually represent the entire operation with matrices:

Here, $\mathbf{x}$ can be a point in 1,000-dimensional space, and the layer transforms it into a point in 500-dimensional space.

Then the next layer might do:

1,000 dimensions → 500 → 200 → 800 → 50 → output

So neural networks aren't merely fitting curves in higher dimensions. They repeatedly transform one high-dimensional representation into another.

And "dimension" has a very concrete meaning

Imagine predicting house prices.

With one feature:

X₁ = square footage

you can draw it:

square footage → price

Add:

X₂ = number of bedrooms

Now you've got a 3-D visualization:

square footage × bedrooms → price

Then add:

X₃ = age
X₄ = lot size
X₅ = distance from downtown
X₆ = school rating
X₇ = interest rate

Now you're operating in a space humans can't visualize, but the mathematics works just fine.

That's one reason linear algebra and matrices are so fundamental to AI. They let computers manipulate spaces containing hundreds, thousands, or even millions of dimensions without needing to "visualize" them.

And there's an especially interesting connection to your earlier question:

1800s curve fitting: find a line/curve that minimizes error.

Regression: find a relationship among potentially many variables that minimizes error.

Neural network: repeatedly transform potentially enormous multidimensional spaces while adjusting weights to minimize error.

So the conceptual lineage you were getting at in the article is quite legitimate.

One small correction: the number of dimensions isn't literally unlimited. It's mathematically arbitrary, but in an actual computer it's constrained by memory, computation, available data, numerical precision, and model architecture. Conceptually, though, there is no 2-D or 3-D ceiling.

AI Is New—and It Isn't

Calling modern artificial intelligence "nothing new" goes too far. Transformers, modern training techniques, specialized hardware, enormous datasets, and today's scale represent genuine technological advances.

But portraying AI as something that suddenly appeared in the 2020s is equally misleading.

There is a remarkable historical path:

Least squares (~1800)
↓
Regression (~1880s)
↓
Mathematical neuron (1943)
↓
Perceptron (1950s)
↓
Multilayer neural networks
↓
Backpropagation and modern neural-network training
↓
Deep learning
↓
Transformers (2017)
↓
Modern generative AI

Seen this way, artificial intelligence becomes considerably less mysterious.

Today's systems are spectacularly larger, faster, more complicated, and more capable than their ancestors. But many of their fundamental ideas did not suddenly appear with ChatGPT.

We have spent more than two centuries developing increasingly powerful ways for mathematics to find patterns in data.

Modern AI may be the most impressive result yet.