Abstract
An algorithm is a finite procedure that transforms an input into an output and is guaranteed to produce a correct result when one exists. This article treats the algorithm as cognitive psychology does: not only as a construct from mathematics and computing, but as a model of mind. It traces how the information-processing revolution recast thinking as the execution of mental procedures, how the algorithm became one of Marr's three levels, and how the contrast between an exhaustive algorithm and a fallible heuristic frames the study of problem solving and decision making. It explains why cognitive architectures such as ACT-R and SOAR are algorithmic theories of cognition, and how the resource-rational programme reconciles the ideal algorithm with a mind of limited time and memory. Interactive demonstrations compare an algorithm with a heuristic and chart a search procedure's growing cost.
Keywords: algorithm, heuristic, problem solving, computational theory of mind, cognitive architecture
An algorithm is a recipe for a machine: a finite list of exact steps that, carried out faithfully, is guaranteed to solve every instance of a problem it was designed for. The idea was made mathematically precise before any computer existed, when a formal model of mechanical computation defined exactly which procedures count as effective (Turing, 1937). What makes the algorithm matter to cognitive psychology is a bolder claim: that the human mind, too, carries out procedures over mental representations, and that explaining a mental ability means specifying the procedure that produces it. On that view thinking is a kind of computation, and the algorithm is the natural unit in which a theory of thinking is written.
Key Takeaways
- An algorithm is a finite, deterministic procedure that is guaranteed to return a correct answer, in contrast to a heuristic, which trades that guarantee for speed.
- The information-processing account of mind treats thinking as the execution of mental procedures over representations, so the algorithm becomes a model of cognition, not only of machines.
- Marr placed the algorithm at the middle of three levels of analysis: what is computed and why, by which procedure, and in what physical substrate.
- Cognitive architectures such as ACT-R and SOAR are explicit algorithmic theories of how the mind represents and processes information.
- Because the mind has limited time and memory, it rarely runs the ideal algorithm; bounded and resource-rational accounts explain which procedures a finite mind should use instead.
What Algorithms Are
An algorithm is defined by a handful of properties, each of which matters for its use as a model of thought. It is finite: it halts after a bounded number of steps rather than running forever. It is definite: each step is specified exactly, with no room for interpretation. It is effective: every step is simple enough to be carried out mechanically. And it is general: a single procedure solves every instance of a problem class, not just one case. A procedure with these properties is guaranteed to deliver a correct output for any valid input — that guarantee is the algorithm's defining virtue and its characteristic cost, because buying certainty often means examining many possibilities (Turing, 1937).
The guarantee is what separates an algorithm from the other great family of problem-solving methods, the heuristic. An algorithm for finding the largest number in a list inspects every entry and so cannot be wrong; a heuristic might sample a few and stop, usually right but occasionally fooled. The distinction is central to cognitive psychology because human beings, faced with real problems under real time pressure, overwhelmingly use heuristics — yet the algorithm remains the normative standard against which those shortcuts are measured (Newell, Shaw & Simon, 1958). Much of the psychology of problem solving and of decision making is the study of when the mind approximates an algorithm and when it departs from one.
Types of Algorithms
In the Medical Subject Headings vocabulary, which indexes the research literature, Algorithms is a broad descriptor filed under two parents at once — Mathematical Concepts and Computing Methodologies — reflecting that an algorithm is both a mathematical object and an engineering artifact. Its narrower descriptors name the major families of procedure that the literature distinguishes. These categories are an indexing classification, not a psychological taxonomy: they overlap freely (a boosting method is a machine-learning algorithm; an autoencoder performs dimensionality reduction), and a single procedure is often filed under several at once. None of the families below is yet a separate article on this site, so each is given only a one-line gloss.
| Family | What it is |
|---|---|
| Artificial Intelligence | The broad enterprise of building systems that perform tasks ordinarily thought to require intelligence. |
| Autoencoder | A neural network that learns a compact code for its input by training to reconstruct that input. |
| Backtracking Algorithms | Systematic search that abandons a partial solution the instant it cannot be completed, then retreats to try another. |
| Boosting Machine Learning Algorithms | Ensemble methods that combine many weak predictors into a single strong one. |
| Cellular Automata | Grids of simple cells whose local update rules generate complex global behaviour. |
| Clustering Algorithms | Procedures that group data points by similarity without using labelled examples. |
| Compression Algorithms | Procedures that re-encode data into fewer bits, exactly or approximately. |
| Detection Algorithms | Procedures that decide whether a target signal or object is present in noisy input. |
| Dimensionality Reduction | Methods that re-express high-dimensional data in fewer variables while preserving its structure. |
| Genetic Algorithms | Optimization by simulated mutation, recombination, and selection over a population of candidate solutions. |
| Latent Class Analysis | A statistical procedure that infers unobserved subgroups from patterns in categorical data. |
| Machine Learning Algorithms | Procedures that improve their performance on a task by learning from data rather than being explicitly programmed. |
| Multiple-Instance Learning Algorithms | Learning from labelled bags of instances rather than from individually labelled instances. |
| Parallel Algorithms | Procedures designed to run as simultaneous, cooperating parts rather than one step at a time. |
| Particle Swarm Optimization | Optimization by a population of candidate solutions that move through the search space toward the best found so far. |
| Prediction Algorithms | Procedures that estimate an unknown or future value from the data available now. |
Note. The sixteen narrower descriptors of Algorithms in Medical Subject Headings (2026 release). The grouping is a bibliographic index, not a theory of mind, and the families overlap; none is yet a separate article on this site.
Algorithms and Heuristics
The founding move of cognitive psychology's information-processing era was to describe human thinking in the vocabulary of procedures. Rather than treat problem solving as an unanalysable flash of insight, researchers specified the exact operations a solver performs — representing the problem as a problem space of states, and searching that space by applying operators that move from one state to the next (Newell, Shaw & Simon, 1958). A solver who considered every path through that space would be running an algorithm, guaranteed to find a solution if one exists; but the spaces of real problems explode too fast for exhaustive search, so human solvers rely on heuristics that prune the space to a tractable few paths. The best-known of these, means-end analysis, repeatedly chooses the operator that most reduces the difference between the current state and the goal.
Why the mind favours heuristics over algorithms was given its deepest justification in the theory of bounded rationality: a real agent has limited computation, limited memory, and limited time, so the rational choice is not the optimal answer an unbounded calculator would compute but the best answer reachable within those limits (Simon, 1956). Rather than optimize, a bounded agent satisfices — accepts the first option that is good enough. The programme that followed catalogued the specific heuristics people use, showing both their efficiency and the systematic biases they produce when the shortcut misfires (Tversky & Kahneman, 1974). A later, more sympathetic account argued that such fast and frugal heuristics are not merely cheap approximations but can be more accurate than elaborate algorithms when information is scarce or the world is uncertain (Gigerenzer & Gaissmaier, 2011). The relationship between the two methods is explored further under heuristics and bounded rationality.
The demonstration below sets an exhaustive algorithm against a greedy heuristic on the same small problem, so that the trade-off between guaranteed correctness and cheap speed can be watched directly.
Guaranteed Correct vs. Fast but Fallible
Choose a subset of three items to maximise total value without exceeding a weight budget. The exhaustive algorithm checks every subset and always finds the best; the greedy heuristic grabs items in descending value-per-weight order and stops — cheap, but not always right. Slide the capacity and watch where the shortcut fails.
| Item | Value | Weight | Value / weight |
|---|---|---|---|
| A | 10 | 5 | 2.00 |
| B | 9 | 4 | 2.25 |
| C | 9 | 4 | 2.25 |
Exhaustive algorithm
picks A + B
value 19 · 8 subsets checked
Greedy heuristic
picks B + C
value 18 · 3 items examined
The heuristic settled for 18 where the optimum is 19 — fast, but wrong.
Note. The exhaustive algorithm always inspects all 23 = 8 subsets; the greedy heuristic examines at most 3 items. Correctness is bought with work, and the heuristic trades the guarantee for speed.
Marr's Three Levels
If the mind runs procedures, at what level of description should a theory of it be pitched? The most influential answer holds that any system that processes information must be understood at three distinct levels, and that confusing them is a standard source of error (Marr, 1982). The computational level asks what problem the system solves and why — what is being computed, and what makes that the right thing to compute given the organism's goals and environment. The algorithmic level asks how: which representations the system uses for its inputs and outputs, and which procedure transforms one into the other. The implementational level asks what physical substrate — neurons, silicon — carries the procedure out.
The three levels are loosely coupled, and that is the point. A single computational problem can be solved by many different algorithms, and a single algorithm can be implemented in many different physical media, so a complete explanation needs all three and cannot be read off from any one alone. The framework gives the algorithm a precise place in the explanation of mind: it is the bridge between the abstract problem the organism faces and the wet machinery that solves it. It also licenses a research strategy that defined a generation of cognitive science — specify the computational problem first, then ask which algorithm the mind might use, treating the brain's implementation as a separate question (Marr, 1982). The demonstration below presents one everyday task described at each of the three levels in turn.
One Task, Three Levels
Marr argued that any information-processing system must be described at three loosely coupled levels. Pick a task and read the same ability analysed at each level in turn — the algorithm always sits in the middle, bridging the problem above and the hardware below.
Computational level
What is computed, and why?
Given two numbers, return their sum — the arithmetic function of addition.
Algorithmic level
Which representation and procedure?
Column addition: align the digits, add each column from right to left, carrying any overflow into the next column.
Implementational level
What physical substrate?
Number-sensitive neurons in parietal cortex — or, equivalently, the adder circuit of a pocket calculator.
Note. The three levels are largely independent: one computational problem admits many algorithms, and one algorithm admits many physical implementations, so a full account needs all three.
Cognitive Architectures
If a mental ability is explained by the algorithm that produces it, then a theory of the whole mind is a specification of the fixed machinery within which all those algorithms run — the memory stores, the control structure, the way knowledge is represented and retrieved. Such a specification is a cognitive architecture, and building one is the most ambitious form the algorithmic view of mind can take. Two architectures have dominated the field. ACT-R models cognition as the interplay of a declarative memory of facts and a procedural memory of condition-action rules, with a sub-symbolic layer of activations and utilities deciding which fact is retrieved and which rule fires (Anderson, 1996). SOAR casts all of cognition as search in problem spaces, driven by a single uniform learning mechanism, and was offered explicitly as a candidate unified theory that one architecture might account for the whole range of intelligent behaviour (Laird, Newell & Rosenbloom, 1987).
A cognitive architecture is an algorithmic theory in the strongest sense: it is a running program whose behaviour can be compared, step for step and millisecond for millisecond, against human data. That is its scientific appeal and its burden — the theory is forced to be complete and explicit, with no hand-waving about how one stage feeds the next, because an incomplete program does not run. Architectures connect to the broader notion of a cognitive architecture and to artificial intelligence, with which they share both ancestry and methods.
Figure 1
Marr's three levels of analysis
Worked Example
To see why the guarantee an algorithm buys is worth its cost, compare two procedures for the same task: finding a target in a sorted list of one million items. The naive algorithm, linear search, inspects entries one at a time from the start; in the worst case the target is last, so it makes 1,000,000 comparisons. Binary search instead inspects the middle entry and, because the list is sorted, discards half the remaining range at every step. The number of comparisons it needs in the worst case is the number of times one million can be halved before one item remains, which is the smallest whole number k with 2 raised to the k at least one million.
Because 2 to the 19th is 524,288 (below one million) and 2 to the 20th is 1,048,576 (above it), that smallest k is 20. Binary search therefore settles the question in at most 20 comparisons where linear search may need a million — a worst-case speed-up of 1,000,000 divided by 20, or 50,000 times. Both procedures are algorithms: each is guaranteed to find the target if it is present. The example makes the general lesson concrete — the right algorithm can change not merely how fast a problem is solved but whether solving it is feasible at all, and the same jump from a procedure that scales linearly to one that scales logarithmically recurs throughout both computer science and models of efficient human search. The SearchCostDemo below lets the reader vary the list size and watch the two costs diverge.
Linear Search vs. Binary Search
Both procedures find a target in a sorted list, and both are guaranteed to succeed — but one scales linearly and the other logarithmically. Vary the list size and watch the worst-case costs diverge.
Linear search
1,048,576
comparisons
Binary search
20
comparisons
Speed-up
52,429×
fewer steps
Note. The vertical axis is logarithmic, so the straight red line is in fact exponential growth: each step rightward doubles the list. Binary search’s logarithmic cost is the near-flat green line. At one million items the gap is the 50,000× of the Worked Example.
Discussion
The algorithmic view of mind has been the organizing idea of cognitive psychology for more than half a century, but its relationship to real human thought has always been a negotiation. People are not general-purpose computers running optimal algorithms; they are finite agents who must act before they have finished thinking. The enduring tension is therefore between the algorithm as a normative standard — the procedure that would be correct given unlimited resources — and the heuristic as a descriptive reality, the shortcut a bounded mind actually uses (Simon, 1956; Tversky & Kahneman, 1974). Table 1 lays the two methods side by side on the dimensions that matter for a theory of cognition.
The modern resolution does not pick a side; it dissolves the opposition. The resource-rational programme asks what procedure is optimal once the cost of computation itself is counted, and shows that many of the heuristics once filed as irrational departures from the algorithm are in fact the rational choice for an agent with the mind's actual time and memory budget (Lieder & Griffiths, 2020). On this view the gap between algorithm and heuristic was partly an artifact of ignoring the price of thinking. The framing has been generalized into a broad account of computational rationality that spans brains, minds, and machines, treating all three as agents choosing procedures under resource constraints (Gershman, Horvitz & Tenenbaum, 2015), and into the proposal that human intelligence is best understood precisely through the limitations that force it to be clever rather than exhaustive (Griffiths, 2020).
| Dimension | Algorithm | Heuristic |
|---|---|---|
| Correctness | Guaranteed, if a solution exists | Usually good, occasionally wrong |
| Cost | Can be prohibitive as the problem grows | Low and roughly constant |
| Fit to the mind | A normative standard the mind approximates (Newell, Shaw & Simon, 1958) | A descriptive account of what people do (Gigerenzer & Gaissmaier, 2011) |
| Reconciled by | Resource-rational analysis: the optimal procedure once the cost of computation is counted (Lieder & Griffiths, 2020) | |
Table 1. The algorithm and the heuristic as the two poles of problem-solving method in cognitive psychology, and the resource-rational framework that reconciles them by pricing computation itself.
Current Directions
The most active frontier returns the algorithmic view of mind to its original ambition: a procedure that produces human-like intelligence. Deep learning has shown that a single family of algorithms, trained by gradient descent on large datasets, can learn representations for perception and language that long resisted hand-built procedures (LeCun, Bengio & Hinton, 2015). This has reopened the oldest question in the field — whether such learned algorithms resemble the mind's, or merely match its outputs. One influential critique argues that human intelligence rests on structured, model-based procedures that build causal theories and generalize from a handful of examples, capacities current statistical learners still lack (Lake, Ullman, Tenenbaum & Gershman, 2017).
A second direction brings the two traditions into contact. Reinforcement learning, once a slow procedure requiring vast experience, has been joined to fast, episode-like memory, yielding systems that learn from few examples much as people do and that map suggestively onto the brain's own learning algorithms (Botvinick et al., 2019). More broadly, cognitive computational neuroscience now treats the search for the mind's algorithms as a joint enterprise of psychology, neuroscience, and machine learning, asking which procedures the brain runs and how its hardware implements them — Marr's three levels, pursued together rather than one at a time (Kriegeskorte & Douglas, 2018). The algorithm, defined formally almost a century ago, remains the unit in which these converging fields write their theories.
Common Misconceptions
- An algorithm is just any set of instructions.
- A genuine algorithm must be finite, definite, effective, and general, and it must guarantee a correct result; a vague list of steps that may not halt or may be read two ways is not one (Turing, 1937).
- Algorithms and heuristics are the same kind of thing.
- They differ exactly on the guarantee: an algorithm trades cost for certainty, a heuristic trades certainty for cheap speed, and the mind leans heavily on the latter (Simon, 1956; Gigerenzer & Gaissmaier, 2011).
- Saying the mind runs algorithms means the brain is a digital computer.
- The algorithmic level is deliberately separate from the implementational one: the same procedure can run on neurons or silicon, so the claim is about what the mind computes, not about its wetware (Marr, 1982).
- Using heuristics instead of algorithms is simply irrational.
- Once the cost of computation is counted, a heuristic is often the optimal choice for a finite agent; resource-rational analysis shows many apparent biases to be rational under real constraints (Lieder & Griffiths, 2020).
Glossary
- Algorithm.
- A finite, definite, effective, and general procedure that is guaranteed to produce a correct output for any valid input.
- Backtracking.
- A search strategy that extends a partial solution step by step and retreats as soon as the current path cannot be completed.
- Bounded rationality.
- The principle that a real agent chooses the best option reachable within its limited time, memory, and computation, rather than the globally optimal one.
- Cognitive architecture.
- A specification of the fixed memory stores and control processes within which all of a mind's particular procedures run, such as ACT-R or SOAR.
- Computational level.
- In Marr's framework, the level of analysis that specifies what problem a system solves and why that is the right problem.
- Deterministic.
- A property of a procedure whose next step is fixed entirely by its current state, so that identical inputs always yield identical outputs.
- Heuristic.
- A problem-solving shortcut that is usually effective and cheap but, unlike an algorithm, carries no guarantee of a correct result.
- Implementational level.
- In Marr's framework, the level of analysis that specifies the physical substrate, such as neurons or silicon, that carries a procedure out.
- Means-end analysis.
- A heuristic that repeatedly selects the operator that most reduces the difference between the current state and the goal state.
- Problem space.
- The set of all states a problem can be in, together with the operators that move between them, over which a solver searches.
- Resource-rational analysis.
- An approach that identifies the optimal procedure for an agent once the cost of computation itself is included in the account.
- Satisficing.
- Accepting the first option that meets an adequacy threshold rather than searching on for the optimum; the behavioural signature of bounded rationality.
- Search.
- The process of exploring a problem space by applying operators to states until a goal state is reached.
- Time complexity.
- A measure of how the number of steps a procedure takes grows with the size of its input, such as linear or logarithmic growth.
- Tractability.
- Whether a problem can be solved with resources that grow manageably with its size; an intractable problem forces reliance on heuristics.
Key Researchers
John R. Anderson
(b. 1947). R. K. Mellon University Professor of Psychology and Computer Science at Carnegie Mellon University; creator of the ACT-R cognitive architecture, among the most developed algorithmic theories of human cognition. Wikipedia - Faculty Page
Gerd Gigerenzer
(b. 1947). Director emeritus at the Max Planck Institute for Human Development; architect of the fast-and-frugal heuristics programme, which argues that simple procedures can outperform elaborate algorithms under uncertainty. ORCID - Wikipedia - Faculty Page
Thomas L. Griffiths
(b. 1976). Henry R. Luce Professor at Princeton University; a leader of the computational-rationality and resource-rational research programmes that reconcile the ideal algorithm with the limits of a finite mind. ORCID - Wikipedia - Faculty Page
David Marr
(1945-1980). Vision scientist whose three levels of analysis gave the algorithm its canonical place between the computational problem a mind solves and the physical machinery that solves it. Wikipedia
Allen Newell
(1927-1992). Co-founder of artificial intelligence; co-creator of the General Problem Solver and the SOAR architecture, and a champion of unified, procedural theories of cognition. Wikipedia
Herbert A. Simon
(1916-2001). Nobel laureate and co-founder of artificial intelligence; originator of bounded rationality and satisficing, which explain why a finite mind uses heuristics rather than exhaustive algorithms. Wikipedia
Joshua B. Tenenbaum
(b. 1972). Professor of computational cognitive science at MIT; a founder of the probabilistic-program account of human learning and a leading critic of purely statistical models of intelligence. Wikipedia - Google Scholar - Faculty Page
Alan M. Turing
(1912-1954). Mathematician and founder of theoretical computer science; his 1937 paper defined the formal notion of an algorithm as a procedure a machine can carry out. Wikipedia
Frequently Asked Questions
What is an algorithm?
An algorithm is a finite, unambiguous, step-by-step procedure that transforms an input into an output and is guaranteed to produce a correct result whenever one exists. The notion was made mathematically precise as the set of procedures a simple machine could carry out (Turing, 1937).
How is an algorithm different from a heuristic?
An algorithm guarantees a correct answer but can be costly, while a heuristic is a shortcut that is fast and usually right but carries no guarantee. Human problem solving relies mostly on heuristics, with the algorithm serving as the standard they approximate (Simon, 1956; Gigerenzer & Gaissmaier, 2011).
Why do algorithms matter to cognitive psychology?
The information-processing account of mind treats thinking as the execution of procedures over mental representations, so specifying the algorithm a person uses becomes a way of explaining a mental ability (Newell, Shaw & Simon, 1958).
What are Marr's three levels of analysis?
Marr argued that any information-processing system must be understood at three levels: the computational level (what is computed and why), the algorithmic level (which representation and procedure), and the implementational level (what physical substrate) (Marr, 1982).
Does the mind actually run algorithms?
It runs procedures, but rarely the exhaustive, optimal ones, because it has limited time and memory. Bounded rationality explains why a finite mind satisfices with heuristics rather than computing the ideal answer (Simon, 1956).
What is a cognitive architecture?
A cognitive architecture is a specification of the fixed memory and control machinery within which all of a mind's procedures run; ACT-R and SOAR are the two most developed examples (Anderson, 1996; Laird, Newell & Rosenbloom, 1987).
Are human heuristics simply irrational?
No. Resource-rational analysis shows that once the cost of computation is counted, many heuristics are the optimal choice for an agent with the mind's real constraints, so apparent biases can be rational (Lieder & Griffiths, 2020).
How do modern AI algorithms relate to human thinking?
Deep learning shows that one family of algorithms can learn perception and language from data, reopening the question of whether learned procedures resemble the mind's; critics argue human thought rests on structured, causal procedures that statistical learners still lack (LeCun, Bengio & Hinton, 2015; Lake, Ullman, Tenenbaum & Gershman, 2017).
References
Anderson, J. R. (1996). ACT: A simple theory of complex cognition. American Psychologist, 51(4), 355-365. https://doi.org/10.1037/0003-066X.51.4.355
Botvinick, M., Ritter, S., Wang, J. X., Kurth-Nelson, Z., Blundell, C., & Hassabis, D. (2019). Reinforcement learning, fast and slow. Trends in Cognitive Sciences, 23(5), 408-422. https://doi.org/10.1016/j.tics.2019.02.006
Gershman, S. J., Horvitz, E. J., & Tenenbaum, J. B. (2015). Computational rationality: A converging paradigm for intelligence in brains, minds, and machines. Science, 349(6245), 273-278. https://doi.org/10.1126/science.aac6076
Gigerenzer, G., & Gaissmaier, W. (2011). Heuristic decision making. Annual Review of Psychology, 62, 451-482. https://doi.org/10.1146/annurev-psych-120709-145346
Griffiths, T. L. (2020). Understanding human intelligence through human limitations. Trends in Cognitive Sciences, 24(11), 873-883. https://doi.org/10.1016/j.tics.2020.09.001
Kriegeskorte, N., & Douglas, P. K. (2018). Cognitive computational neuroscience. Nature Neuroscience, 21(9), 1148-1160. https://doi.org/10.1038/s41593-018-0210-5
Laird, J. E., Newell, A., & Rosenbloom, P. S. (1987). SOAR: An architecture for general intelligence. Artificial Intelligence, 33(1), 1-64. https://doi.org/10.1016/0004-3702(87)90050-6
Lake, B. M., Ullman, T. D., Tenenbaum, J. B., & Gershman, S. J. (2017). Building machines that learn and think like people. Behavioral and Brain Sciences, 40, e253. https://doi.org/10.1017/S0140525X16001837
LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature, 521(7553), 436-444. https://doi.org/10.1038/nature14539
Lieder, F., & Griffiths, T. L. (2020). Resource-rational analysis: Understanding human cognition as the optimal use of limited computational resources. Behavioral and Brain Sciences, 43, e1. https://doi.org/10.1017/S0140525X1900061X
Marr, D. (1982). Vision: A computational investigation into the human representation and processing of visual information. W. H. Freeman.
Newell, A., Shaw, J. C., & Simon, H. A. (1958). Elements of a theory of human problem solving. Psychological Review, 65(3), 151-166. https://doi.org/10.1037/h0048495
Simon, H. A. (1956). Rational choice and the structure of the environment. Psychological Review, 63(2), 129-138. https://doi.org/10.1037/h0042769
Turing, A. M. (1937). On computable numbers, with an application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, s2-42(1), 230-265. https://doi.org/10.1112/plms/s2-42.1.230
Tversky, A., & Kahneman, D. (1974). Judgment under uncertainty: Heuristics and biases. Science, 185(4157), 1124-1131. https://doi.org/10.1126/science.185.4157.1124