Intelligence versus Computation: What Makes a System Truly Intelligent?

Intelligence and computation are closely related but fundamentally different concepts. Computation concerns the execution of formally specified operations on information. Intelligence concerns an agent’s capacity to acquire, organize, and apply information to achieve goals across relevant tasks and environments, particularly when uncertainty, novelty, and adaptation are involved.

A calculator performs computation. A machine-learning system also performs computation, but its computational processes may support prediction, generalization, decision-making, or adaptive behavior. A sophisticated program is not automatically intelligent merely because it performs billions of calculations, and an intelligent system need not demonstrate every human cognitive ability.

Understanding this distinction is foundational to artificial intelligence (AI), cognitive science, computer science, robotics, machine learning, and the philosophy of mind.

1. DEEP DEFINITION: THE MATHEMATICAL, HISTORICAL, AND CONCEPTUAL FOUNDATIONS

1.1 What is computation?

Computation is the execution of information-processing operations according to formally defined rules or transformations.

In classical computability theory, a computation can be represented as a function:

y = f(x)

Where:

• x represents the input.
• f represents a computable function or procedure.
• y represents the resulting output.

For example, a program that calculates the square of an integer implements:

f(x) = x²

Given x = 7, the program returns 49.

The program can produce the correct result without understanding what squaring means, why the result matters, or how it might be used in a changing environment.

This distinction separates the successful execution of a computation from broader claims about intelligence.

Formal computation and the Turing machine

In his foundational 1936 work, published in 1937, Alan Turing introduced a mathematical model of effective computation that became central to theoretical computer science. [1]

A deterministic Turing machine can be specified as:

M = (Q, Σ, Γ, δ, q₀, q_accept, q_reject)

Where:

• Q is a finite set of internal states.
• Σ is the input alphabet.
• Γ is the tape alphabet.
• δ is the transition function.
• q₀ is the initial state.
• q_accept is the accepting state.
• q_reject is the rejecting state.

The transition function is commonly represented as:

δ: Q × Γ → Q × Γ × {L, R}

This describes how the machine changes state, writes a symbol, and moves its reading head.

A Turing machine establishes a formal model of what an algorithm can compute. It does not, by itself, provide a complete theory of intelligence.

A computational system may manipulate symbols correctly while lacking mechanisms for meaningful environmental interaction, learning, goal selection, or generalization.

Moreover, computation is not restricted to ordinary digital computers. Analog, probabilistic, and quantum computing provide additional models of information processing, although their precise computational properties differ.

1.2 What is intelligence?

There is no single universally accepted operational definition of intelligence spanning humans, animals, artificial agents, and hypothetical nonbiological systems.

Nevertheless, many influential definitions share several recurring themes:

1. Goal achievement: Acting effectively to accomplish objectives.
2. Learning: Improving performance through experience or acquired information.
3. Reasoning: Deriving conclusions and choosing actions from available representations.
4. Generalization: Applying acquired capabilities beyond previously encountered examples.
5. Adaptation: Responding appropriately to environmental changes.
6. Planning: Anticipating consequences and organizing actions.
7. Problem-solving: Discovering effective solutions under constraints.

These are useful dimensions of intelligence rather than a universally mandatory checklist.

Some AI systems demonstrate significant intelligence-related capabilities without learning after deployment. Others solve difficult problems using combinations of fixed knowledge, search, planning, and inference.

Consequently, intelligence should be examined in relation to the task, environment, information available, objectives, performance, and resources required.

1.3 Intelligence as sequential decision-making

One influential approach models intelligence through interaction between an agent and an environment.

At time t:

• The agent receives an observation oₜ.
• It maintains or constructs information about the environment.
• It selects an action aₜ.
• The environment changes.
• The agent receives subsequent observations and potentially a reward rₜ.

An agent’s policy can be represented as:

π(aₜ | hₜ)

Where hₜ denotes the interaction history available at time t.

A common reinforcement-learning objective is to maximize expected discounted return:

J(π) = Eπ[Σₜ₌₀∞ γᵗrₜ]

Where:

• π represents the agent’s policy.
• rₜ represents the reward at time t.
• γ is a discount factor, typically satisfying 0 ≤ γ < 1.
• Eπ represents expectation over trajectories induced by the policy and environment.

This formulation captures goal-directed behavior over time.

However, it is not a universal definition of intelligence. The quality of the reward function, the scope of the environment, and the agent’s ability to generalize remain essential.

A system can maximize a poorly chosen reward while behaving dangerously or contrary to human intentions.

1.4 The Legg–Hutter universal intelligence framework

Shane Legg and Marcus Hutter proposed a formal measure of machine intelligence in 2007. [4]

Their framework evaluates an agent across a weighted collection of computable environments.

A commonly presented formulation is:

Υ(π) = Σμ∈E 2^(−K(μ)) Vμ(π)

Where:

• Υ(π) is the proposed universal intelligence of policy π.
• E is a specified class of computable, reward-bounded environments.
• K(μ) is the Kolmogorov complexity of environment μ relative to a chosen universal reference machine.
• 2^(−K(μ)) weights environments by algorithmic simplicity.
• Vμ(π) represents the expected total reward obtained by policy π in environment μ.

The framework formalizes an important intuition: intelligence involves achieving goals across different environments rather than succeeding at one memorized task.

It also has important limitations.

Kolmogorov complexity is generally incomputable, the formulation depends on representational choices and environmental assumptions, and the resulting universal measure is not a practical everyday benchmark for deployed AI.

It should therefore be understood as a theoretical contribution rather than an established numerical test for all forms of intelligence.

1.5 Generalization and skill-acquisition efficiency

A machine can achieve extraordinary accuracy on familiar examples without demonstrating equally strong capabilities on unfamiliar problems.

This raises a central distinction:

Learned task proficiency is not identical to general intelligence.

François Chollet’s 2019 research, On the Measure of Intelligence, emphasized skill-acquisition efficiency and the importance of separating genuine generalization from performance obtained through extensive prior knowledge or training experience. [5]

Consider two systems trained to recognize visual patterns.

System A achieves excellent accuracy on familiar images but deteriorates when objects appear under new lighting conditions.

System B performs slightly less accurately on familiar images but adapts more effectively to unfamiliar combinations of shapes, orientations, and textures.

Depending on the task distribution and evaluation objective, System B may demonstrate stronger transfer or generalization despite having a lower score on the original benchmark.

This does not prove that System B is universally more intelligent.

It demonstrates why capability evaluation must extend beyond a single performance statistic.

1.6 The fundamental distinction: computation versus intelligence

Dimension	Computation	Intelligence
Fundamental question	What operations are performed?	How effectively does the system solve problems or achieve goals?
Central concern	Formal transformations and procedures	Competence, reasoning, adaptation, and generalization
Goal awareness	Not required	Goal-directed behavior is central in many operational definitions
Learning	Optional	Important in many definitions, but not universally required
Environmental interaction	Not required	Important in agent-oriented accounts
Uncertainty handling	May or may not be included	Often an important capability
Performance evaluation	Correctness, time, space, numerical stability	Success, transfer, robustness, efficiency, and reliability
Implementation	Algorithms, circuits, computational processes	Computational or biological mechanisms supporting intelligent behavior

The two concepts are not mutually exclusive.

In digital AI systems, computational processes implement the mechanisms responsible for intelligence-related behavior.

The distinction is between the underlying process of computation and the functional capabilities produced by that process.

1.7 Historical development

1936–1937 — Alan Turing and formal computability

Turing’s work established foundational principles for defining effective computational procedures and investigating the limits of algorithmic calculation. [1]

1950 — Computing machinery and intelligence

In Computing Machinery and Intelligence, Turing examined whether machines could exhibit thinking-related behavior and introduced the imitation game as an experimental approach to the question. [2]

The imitation game evaluates behavior under specified conversational conditions; it is not a conclusive test of consciousness, understanding, or general intelligence.

1955–1956 — The Dartmouth AI research initiative

John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon proposed the 1956 Dartmouth research project, advancing the scientific ambition of investigating how machines might simulate aspects of learning and intelligence. [3]

Late twentieth century — Multiple AI paradigms

Symbolic reasoning, expert systems, search algorithms, probabilistic methods, neural networks, and machine learning demonstrated different approaches to constructing intelligent behavior through computation.

2007 — Universal intelligence formalization

Legg and Hutter developed a mathematical account relating intelligence to goal achievement across a broad class of environments. [4]

2019 — Skill-acquisition efficiency

Chollet proposed a framework emphasizing generalization and the efficiency of acquiring new skills, challenging overreliance on narrow benchmark performance. [5]

2023–2024 — Operational and governance definitions

The OECD’s updated AI-system definition emphasized machine-based inference, outputs, objectives, and varying degrees of autonomy and post-deployment adaptiveness. The NIST AI Risk Management Framework also reinforced the need to evaluate AI within its operational and societal context. [6, 8]

These developments collectively demonstrate that computation explains how information processing can be implemented, while intelligence remains a broader question involving behavior, competence, goals, and evaluation.

2. TECHNICAL MECHANICS: HOW COMPUTATION SUPPORTS INTELLIGENCE

2.1 The relationship between algorithms and intelligent behavior

An algorithm is a precisely specified procedure for performing an operation or solving a problem.

Algorithms can support intelligence through several mechanisms:

• Representing relevant aspects of a problem.
• Searching among possible solutions.
• Learning from data.
• Estimating uncertain quantities.
• Reasoning about relationships and constraints.
• Selecting actions that satisfy objectives.
• Revising strategies when new evidence becomes available.

No single mechanism is sufficient to characterize all AI systems.

A symbolic theorem prover, statistical classifier, neural language model, and autonomous robot may use substantially different computational mechanisms while demonstrating different intelligence-related capabilities.

2.2 Deterministic computation

A deterministic computational procedure returns the same output when executed with identical inputs and identical relevant internal state.

For example:

y = 2x + 5

When x = 10:

y = 25

This operation requires no learned parameters, environmental model, or contextual interpretation.

Determinism alone, however, does not exclude artificial intelligence.

A rule-based planner can be deterministic while performing sophisticated inference and problem-solving.

Similarly, a trained neural network may produce deterministic outputs under fixed inference settings.

Therefore:

Deterministic does not mean non-intelligent, and probabilistic does not automatically mean intelligent.

2.3 Statistical learning

A machine-learning system may estimate a relationship between inputs and outputs from observed data.

A supervised model can be represented as:

ŷ = fθ(x)

Where:

• x is the input.
• θ represents model parameters.
• fθ is the parameterized predictive function.
• ŷ is the prediction.

Training commonly seeks parameters that minimize an empirical loss:

θ = arg minθ [(1/n) Σᵢ₌₁ⁿ L(fθ(xᵢ), yᵢ) + λΩ(θ)]*

Where:

• L is the loss function.
• n is the number of training examples.
• Ω(θ) is a regularization function.
• λ controls regularization strength.

After optimization, the model uses its acquired parameters to process new inputs.

The computational operations remain mathematical, but their parameters may encode statistical relationships learned from experience.

Learning is therefore an important mechanism through which computation can support intelligent behavior.

However, successful optimization of a training objective does not guarantee robustness, valid reasoning, fairness, or generalization.

2.4 Neural computation and representation learning

Artificial neural networks combine mathematical transformations with trainable parameters.

A standard feedforward layer can be expressed as:

h⁽ˡ⁺¹⁾ = φ(W⁽ˡ⁾h⁽ˡ⁾ + b⁽ˡ⁾)

Where:

• h⁽ˡ⁾ represents the current layer’s activations.
• W⁽ˡ⁾ represents learned weights.
• b⁽ˡ⁾ represents biases.
• φ represents an activation function.

Multiple layers can create representations useful for image recognition, language processing, speech analysis, forecasting, and other tasks.

The network does not acquire intelligence merely by having numerous parameters or layers.

Its capabilities depend on architecture, training objectives, data, optimization, evaluation, and the relationship between learned representations and the intended environment.

Large parameter counts and computational expenditure are not universal measurements of intelligence.

2.5 Search, planning, and reasoning

Not all intelligent behavior requires neural networks.

A planning system can search through possible action sequences to identify a suitable solution.

For example, the A* search algorithm evaluates candidate states using:

f(n) = g(n) + h(n)

Where:

• g(n) is the known cost from the initial state to node n.
• h(n) estimates the remaining cost to the goal.
• f(n) estimates total path cost through n.

When the heuristic and algorithmic assumptions satisfy appropriate conditions, A* can provide optimal pathfinding guarantees.

A planning system may employ A* or related algorithms without learning new model parameters.

Yet the resulting system may demonstrate meaningful problem-solving capabilities in its defined environment.

This illustrates why the boundary between traditional algorithms and AI cannot be determined simply by whether a system contains a neural network.

2.6 Perception, inference, and action selection

A more comprehensive AI system may contain several interconnected computational functions.

Perception: Converts raw input into usable observations or representations.

Representation: Organizes the information needed for later reasoning or prediction.

Inference: Estimates hidden states, relationships, or likely outcomes.

Planning: Evaluates potential actions and their expected consequences.

Action selection: Chooses an output or operation according to an objective.

Feedback: Supplies observations about results and potentially supports system improvement.

These functions may be implemented through fixed algorithms, trained models, probabilistic inference, symbolic logic, or hybrid architectures.

A system need not implement every function to qualify as AI under a particular technical or regulatory definition.

2.7 A worked example: traditional rules versus learned inference

Consider a financial transaction screening system.

System A: Fixed threshold rule

A transaction is flagged when its amount exceeds a predetermined limit.

Decision = 1 if amount > threshold; otherwise 0

This is a deterministic computational rule.

Its behavior is directly specified by the developer.

System B: Learned risk estimation

A model uses transaction amount, timing, historical patterns, device characteristics, and other permitted variables to estimate a risk probability.

A simple logistic model might compute:

P(y = 1 | x) = 1 / (1 + e^(−(wᵀx + b)))

Where:

• x is the feature vector.
• w contains learned feature weights.
• b is a learned intercept.
• y = 1 represents the designated positive class.

The learned output can support a decision threshold or a human-review workflow.

System B uses computation to perform statistical inference based on acquired information.

It may detect patterns that were not manually encoded as explicit transaction rules.

Nevertheless, it may also produce false positives, become less reliable under distribution shift, or reproduce biases present in the training data.

System B’s use of machine learning provides evidence of an AI-related inference mechanism, not proof of superior intelligence or safer outcomes in every context.

2.8 How to evaluate intelligent capabilities

Computation and intelligence require different, although overlapping, evaluation methods.

Computational evaluation typically examines:

• Algorithmic correctness.
• Computational complexity.
• Execution latency.
• Memory requirements.
• Numerical precision.
• Throughput and scalability.
• Reproducibility.

Intelligence-oriented evaluation additionally considers:

• Task achievement under realistic conditions.
• Performance on unseen examples.
• Robustness to environmental change.
• Adaptability to new requirements.
• Multi-step reasoning performance.
• Planning effectiveness.
• Sample efficiency.
• Reliability under uncertainty.
• Safety and consequences of errors.

A simple generalization-gap measure is:

G = Performance(training-like data) − Performance(unseen data)

For a metric where larger values are better, a large positive gap may indicate limited generalization.

However, results depend on dataset design, distributional differences, measurement uncertainty, and the chosen performance metric.

For sequential decisions, another useful concept is regret:

Rₜ = Σₜ₌₁ᵀ [rₜ(π) − rₜ(π)]*

Here π* represents a specified comparator policy, and the expression measures cumulative reward differences under an appropriately defined evaluation setup.

These measures examine particular characteristics of performance. No single one establishes universal intelligence.

3. ARCHITECTURAL TEXT MAP: FROM COMPUTATION TO INTELLIGENT BEHAVIOR

The following reference architecture illustrates how computational components can contribute to an intelligent system.

Not every AI implementation contains every component, and the diagram should not be interpreted as a mandatory definition of AI.

3.1 Conceptual architecture

STAGE 1 — ENVIRONMENT AND INPUT

Physical environment / Digital environment
                     |
                     v
         Observations and inputs
                     |
                     v

STAGE 2 — COMPUTATIONAL PROCESSING

Data validation and preprocessing
                     |
                     v
   Feature or representation construction
                     |
                     v

STAGE 3 — INFERENCE AND REASONING

+---------------------------------------+
| Statistical or neural inference       |
| Symbolic reasoning and logical rules |
| Search and planning algorithms        |
| Retrieval and contextual information  |
+---------------------------------------+
                     |
                     v

STAGE 4 — GOAL-DIRECTED DECISION

Candidate outputs or possible actions
                     |
                     v
Objective and constraint evaluation
                     |
                     v
Policy / Controller / Decision mechanism
                     |
                     v

STAGE 5 — EXECUTION

Prediction / Recommendation / Decision
        / Generated content
        / Physical action
                     |
                     v

STAGE 6 — EVALUATION AND FEEDBACK

Outcome observation and measurement
                     |
                     v
Error, utility, risk and quality evaluation
                     |
        +------------+------------+
        |                         |
        v                         v
Monitoring and reporting   Authorized adaptation
                                  |
                                  v
                        Model or policy updating
                                  |
                                  v
                      Subsequent system operation

3.2 Interpretation of the architecture

The architecture contains two conceptually distinct dimensions.

Computational dimension

This includes data transformations, mathematical functions, storage operations, algorithms, and execution mechanisms.

Intelligence-related dimension

This includes task-relevant inference, problem-solving, planning, adaptation, generalization, and effective behavior under relevant conditions.

The intelligence-related capabilities are realized through the computational mechanisms but are not equivalent to the mere number or complexity of computations executed.

3.3 System boundaries and deployment considerations

A production AI system also requires supporting controls.

These may include:

• Authentication and authorization.
• Input validation.
• Data governance and privacy protection.
• Runtime resource limits.
• Tool and action permissions.
• Human oversight.
• Logging and incident investigation.
• Model versioning.
• Evaluation and rollback procedures.

These controls help make intelligent behavior dependable, accountable, and suitable for real-world deployment.

They should not be confused with intelligence itself.

A system can demonstrate substantial reasoning capability while remaining insecure, unreliable, or unsuitable for a sensitive application.

Conversely, a simple deterministic system can be highly reliable and preferable when the intended task does not require AI.

4. USE CASES, LIMITATIONS, AND PRACTICAL IMPLICATIONS

4.1 Scientific and engineering applications

Autonomous robotics

An autonomous robot may need to recognize obstacles, estimate its position, construct routes, and adjust actions as conditions change.

Low-level computations handle sensor processing, geometry, motion control, and actuator commands.

Higher-level intelligent capabilities may include perception under uncertainty, route planning, obstacle avoidance, and replanning.

A robot executing a fixed movement sequence is not equivalent to a robot that can navigate unfamiliar environments.

Principal limitations: Sensor error, uncertain environments, computational latency, incomplete maps, and unsafe action selection.

Medical decision support

A medical AI system may analyze images, recognize patterns, estimate probabilities, or assist with clinical information retrieval.

Its mathematical computations support inference, but the quality of its recommendations depends on the validity of its data, intended use, and evaluation.

Principal limitations: Dataset bias, distribution shift between clinical populations, calibration errors, incomplete patient information, and potentially harmful overreliance.

Medical AI performance on a benchmark does not establish clinical safety or independent diagnostic authority.

Intelligent transportation

Traffic prediction and route planning systems may combine graph algorithms, historical observations, learned models, and dynamic optimization.

A shortest-path algorithm computes routes according to specified costs.

An adaptive traffic system may additionally learn congestion patterns and adjust recommendations when conditions change.

Principal limitations: Unpredictable events, delayed data, conflicting objectives, privacy concerns, and feedback effects in transportation networks.

Cybersecurity

Security systems may use rule-based detection, statistical anomaly detection, and learned classification models.

A signature matcher performs deterministic pattern matching.

A learned anomaly detector may identify statistically unusual activity without relying exclusively on known signatures.

Principal limitations: False alarms, adversarial manipulation, attacker adaptation, and differences between training and operational environments.

Language and knowledge systems

Language models use extensive computation to estimate and generate sequences of tokens.

They can support translation, summarization, programming, question answering, and other language-related tasks.

However, fluent output does not guarantee factual accuracy, grounded understanding, or reliable reasoning.

Principal limitations: Unsupported factual claims, prompt sensitivity, context limitations, data contamination, privacy risks, and unreliable behavior outside evaluated conditions.

4.2 Computation is not synonymous with understanding

A central philosophical question concerns whether successful computational manipulation of representations constitutes genuine understanding.

The computational theory of mind proposes that important aspects of cognition can be explained in computational terms.

Other perspectives emphasize embodiment, environmental interaction, biological mechanisms, or alternative accounts of cognition.

These debates remain active in philosophy and cognitive science. [7]

No consensus establishes that executing a particular algorithm is sufficient to produce subjective experience or consciousness.

Equally, the absence of a validated consciousness test prevents simplistic conclusions based solely on an AI system’s hardware, architecture, or conversational behavior.

Claims about intelligence, understanding, and consciousness should therefore be distinguished.

4.3 Computational complexity is not a universal intelligence measure

A system can perform enormous numbers of operations and remain incapable of solving relatively simple problems outside its specified domain.

Conversely, a compact planning algorithm may solve an important decision problem efficiently.

The following quantities measure different properties:

Computational cost: How many operations or resources are required.

Algorithmic complexity: How resource requirements grow with problem size.

Model capacity: What functions or representations a model architecture can express.

Task capability: How successfully a system performs a specified task.

Generalization: How performance transfers beyond the conditions used to develop or tune the system.

Intelligence: A broader and definition-dependent assessment of competence across tasks and environments.

These dimensions may correlate in particular settings, but they must not be treated as interchangeable.

4.4 Learning is not always necessary for intelligent behavior

A system may perform sophisticated reasoning using an established knowledge base and a fixed inference algorithm.

It may generate plans, establish logical consequences, or solve previously unseen problems without updating its parameters.

Likewise, a trained model may retain fixed parameters during inference yet respond effectively to new inputs.

Learning is a significant route to intelligent behavior, but post-deployment learning is not a universal requirement.

4.5 Benchmark performance is not equivalent to general intelligence

AI benchmarks are useful only within their measurement scope.

Potential distortions include:

• Training-data overlap with evaluation examples.
• Overfitting to repeatedly used benchmarks.
• Inadequate representation of real-world variation.
• Evaluation tasks that reward memorization.
• Failure to account for external tools or information.
• Differences in computational budgets.
• Scoring methods that conceal important failure categories.

A rigorous evaluation should report what was measured, the conditions under which it was measured, uncertainty where applicable, and limitations on generalization.

Chollet’s work on skill-acquisition efficiency is especially relevant to this distinction. [5]

4.6 Intelligence does not guarantee truthfulness or safety

A system capable of complex inference may still produce unsupported conclusions.

A system capable of planning may optimize an incorrectly specified objective.

A system capable of learning may acquire undesirable correlations from biased data.

As a result, intelligence-related performance must be evaluated separately from:

Factual reliability: Whether statements agree with verifiable evidence.

Robustness: Whether performance remains acceptable under relevant perturbations.

Safety: Whether system behavior avoids unacceptable harm.

Security: Whether the system resists unauthorized manipulation.

Fairness: Whether harmful disparities are appropriately identified and managed.

Accountability: Whether responsible people and organizations can explain and govern system behavior.

NIST AI RMF 1.0 provides an established framework for managing these concerns in their deployment context. [8]

4.7 The limits of formal intelligence definitions

Formal theories are valuable because they require explicit assumptions and measurable quantities.

Nevertheless, they often depend on choices about:

• Which environments count.
• Which goals are valued.
• Which observations are available.
• Which actions are permitted.
• How rewards are assigned.
• How computational resources are limited.
• How previous knowledge is represented.
• Whether social, physical, or cultural context matters.

A theory that precisely measures intelligence under one set of assumptions may not fully capture intelligence under another.

Accordingly, universal intelligence measures, human intelligence assessments, and AI benchmarks should not be collapsed into one supposedly definitive scale.

4.8 Practical framework for distinguishing computation from intelligence

When analyzing a software product, research system, or autonomous agent, the following questions provide a useful engineering framework.

Question 1: What computation does the system perform?

Identify the functions, algorithms, representations, and information-processing operations.

Question 2: What task or objective does the system address?

Describe the desired outcomes and the environment in which they matter.

Question 3: Does the system infer, reason, learn, search, or plan?

Identify concrete mechanisms rather than relying on marketing terminology.

Question 4: How does it handle uncertainty and unfamiliar inputs?

Test performance beyond ideal or previously observed conditions.

Question 5: What evidence demonstrates its capabilities?

Use representative evaluation data, appropriate baselines, and reproducible measurements.

Question 6: What are its operational boundaries?

Identify limitations involving resources, data quality, reliability, safety, and human oversight.

Question 7: Is AI actually necessary?

Determine whether a simpler deterministic, statistical, or conventional optimization approach could satisfy the requirements more reliably and economically.

This assessment avoids both overstating ordinary automation as advanced intelligence and overlooking legitimate AI capabilities implemented through established algorithms.

4.9 Open research questions

Several foundational questions remain unresolved.

Can general intelligence be measured independently of prior knowledge?

Researchers continue to investigate how experience, training, transfer, and generalization should influence intelligence assessment.

How should resource efficiency influence intelligence measurement?

An agent that solves problems with less data, energy, or computation may be preferable, but efficiency must be interpreted relative to the task and constraints.

Can intelligence be meaningfully compared across biological and artificial systems?

Human, animal, and machine capabilities differ in embodiment, goals, experience, and methods of interaction.

What is the relationship between intelligence and consciousness?

Existing evidence does not establish a universally accepted relationship between computational intelligence and subjective experience.

How should intelligence be evaluated in hybrid human–AI systems?

Collaborative performance may depend on interfaces, expertise, trust calibration, and organizational conditions rather than isolated model capabilities.

These questions reinforce the importance of treating intelligence as a multidimensional scientific subject rather than a synonym for computation.

5. RELATED ENCYCLOPEDIA TOPICS

The following registered sibling topics extend the distinction between computation and intelligence within the same foundational subdomain.

1. AI Systems versus Ordinary Automation — Examines the architectural and functional distinctions between conventional software automation and artificial intelligence.
2. Narrow AI, General AI, and Superintelligence — Explores differences in capability scope, generality, and hypothetical levels of machine intelligence.
3. Tasks, Environments, Goals, and Autonomy — Investigates how intelligent agents operate within environments, pursue objectives, and exercise different degrees of autonomy.

6. REFERENCES

[1] Turing, A. M. (1937). On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, s2-42(1), 230–265. Original manuscript received in 1936.

https://doi.org/10.1112/plms/s2-42.1.230

[2] Turing, A. M. (1950). Computing Machinery and Intelligence. Mind, 59(236), 433–460.

https://doi.org/10.1093/mind/LIX.236.433

[3] McCarthy, J., Minsky, M. L., Rochester, N., & Shannon, C. E. (1955/2006). A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence, August 31, 1955. Reproduced in AI Magazine, 27(4).

https://doi.org/10.1609/aimag.v27i4.1904

[4] Legg, S., & Hutter, M. (2007). Universal Intelligence: A Definition of Machine Intelligence. Minds and Machines, 17, 391–444.

https://doi.org/10.1007/s11023-007-9079-x

[5] Chollet, F. (2019). On the Measure of Intelligence. arXiv:1911.01547.

https://arxiv.org/abs/1911.01547

[6] Organisation for Economic Co-operation and Development (OECD). (2024). Explanatory Memorandum on the Updated OECD Definition of an AI System. OECD Artificial Intelligence Papers, No. 8. OECD Publishing, Paris.

https://doi.org/10.1787/623da898-en

[7] Stanford Encyclopedia of Philosophy. (2024 revision). The Computational Theory of Mind. Stanford University, Winter 2024 Edition.

https://plato.stanford.edu/archives/win2024/entries/computational-mind/

[8] Tabassi, E. (2023). Artificial Intelligence Risk Management Framework (AI RMF 1.0). NIST AI 100-1. National Institute of Standards and Technology.

https://doi.org/10.6028/NIST.AI.100-1