Updated 1 November 2026 · A beginner’s guide. No equations or coding required.
How can you recognise a familiar song after hearing only a few notes? You use a small clue to recall something bigger.
Physicist John Hopfield explored a related idea with a network of simple connected units: could it recover a stored pattern even when part of the information was wrong or missing?
His work helped lay foundations for artificial intelligence and earned him a share of the 2024 Nobel Prize in Physics, alongside Geoffrey Hinton. Here is the idea in everyday language.
Why did Hopfield win?
Hopfield developed a network that could store patterns and recover them from imperfect clues. Hinton developed methods that helped networks learn patterns in data. Their work connected ideas from physics with machine learning, the process of teaching computers through examples. See the official Nobel Prize announcement.
The prize recognised important building blocks of AI. It did not mean that either researcher invented all of AI or created ChatGPT.
What is a Hopfield network?
Imagine a group of connected switches. Each can be ON or OFF, and its connections influence whether other switches turn on or off.
These simplified units are called artificial neurons. They borrow an idea from the brain, but they are much simpler than real brain cells.
A stored pattern is spread across the connections. When the network receives an incomplete or damaged version, the units influence one another until the activity settles. Under suitable conditions, the result is the stored pattern.
One small example: repairing a pattern
Picture four lights. The pattern we want to remember is: ON, ON, OFF, OFF.
| Stage | Four lights, left to right |
|---|---|
| Stored pattern | ON · ON · OFF · OFF |
| Damaged input | ON · OFF · OFF · OFF |
| Successful recall | ON · ON · OFF · OFF |
With suitable connections, the other lights can encourage the second light to return to ON. The network uses relationships stored in its connections to repair the pattern.
This is called associative memory: remembering from a clue. Recognising a blurred face is an everyday analogy, not a claim that the network works exactly like a human brain.
Why was this a physics prize?
Physics studies how many interacting parts produce behaviour together. In a magnet, for example, tiny magnetic components influence one another.
Hopfield used related mathematics to describe his network. Think of a ball rolling into a valley: it moves towards a resting place. In the network, a stable pattern plays the role of that resting place.
The “valley” is a teaching analogy. The network does not contain a ball. Its behaviour can be described using a mathematical quantity called energy.
What did Geoffrey Hinton contribute?
Hinton, working with collaborators, developed a network called the Boltzmann machine. It used ideas from statistical physics to learn relationships in examples.
A useful distinction: Hopfield’s work showed how a network could recall patterns; Hinton’s work helped advance how networks could learn them. Their contributions were related, but different.
Is ChatGPT a Hopfield network?
No. ChatGPT is not simply a larger version of Hopfield’s original network. Modern language models use different architectures and many later advances. Hopfield’s contribution matters because it showed a powerful principle: useful memory can emerge from many simple connected units.
For an introduction to today’s assistants, read what ChatGPT is and how it works.
Can the network get things wrong?
Yes. Memories can interfere, a clue can be too damaged, or the network can settle on an incorrect pattern. It cannot store unlimited memories reliably.
The idea to remember: Hopfield showed how connected units could recover a whole pattern from an imperfect clue. That bridge between physics and computation helped shape the foundations of AI.
My perspective: the connection that makes the idea click
The surprising connection here is that physics can help explain how a computer remembers. Instead of looking at each switch separately, we look at how the connections make the whole group behave.
The four-light example is the clearest starting point: one light is wrong, yet the relationships between the lights can restore the pattern. The ball-in-a-valley analogy then helps explain why the changes eventually stop. Neither picture tells the whole story, but together they make an abstract idea easier to follow.
My takeaway is to separate settling on an answer from getting the right answer. The small demonstration below makes that distinction visible.
A small experiment: can four lights recover their pattern?
For this article, a Python demonstration was executed on 1 November 2026. It stored one pattern, ON, ON, OFF, OFF, and tried every possible starting arrangement of four lights: 16 in total.
The lights updated one at a time, from left to right, until nothing changed. Connections encouraged pairs to match the relationship in the stored pattern. The program did not tell a light whether it was the mistaken one.
| Lights initially wrong | Arrangements tried | Correct recoveries |
|---|---|---|
| 0 | 1 | 1 of 1 |
| 1 | 4 | 4 of 4 |
| 2 | 6 | 3 of 6 |
| 3 | 4 | 0 of 4 |
| 4 | 1 | 0 of 1 |
One successful case: ON, OFF, OFF, OFF became ON, ON, OFF, OFF. But the completely opposite pattern stayed opposite. The network settled, yet did not recover the intended memory.
What this shows: this tiny network can correct a little damage, while larger changes can send it to the wrong resting place. The three successful two-error cases depend on the stated update order; they are not a universal 50% accuracy claim.
Limitations: this is a deterministic four-unit illustration with one stored memory, not a new scientific finding or a test of human memory, image recognition or ChatGPT. Different connections, update rules and additional memories can change the outcome.
Optional: reproduce the experiment with Python
No additional packages are needed. Here ON is represented by +1 and OFF by −1, a common version of the Hopfield model. Connections are symmetric, self-connections are zero, and a zero signal leaves a light unchanged. Output columns are wrong lights, arrangements tried and correct recoveries.
from itertools import product
memory = (1, 1, -1, -1) # +1 = ON; -1 = OFF
weights = [[memory[i] * memory[j] if i != j else 0
for j in range(4)] for i in range(4)]
def recall(start):
state = list(start)
for _ in range(20):
previous = state.copy()
for i in range(4): # update left to right, one at a time
signal = sum(weights[i][j] * state[j] for j in range(4))
if signal: # leave state unchanged on a tie
state[i] = 1 if signal > 0 else -1
if state == previous:
return tuple(state)
raise RuntimeError("Did not settle")
for errors in range(5):
starts = [s for s in product((1, -1), repeat=4)
if sum(a != b for a, b in zip(s, memory)) == errors]
recovered = sum(recall(s) == memory for s in starts)
print(errors, len(starts), recovered)0 1 1
1 4 4
2 6 3
3 4 0
4 1 0
