Alan Turing, Computation, and the Machine Model of Reasoning: Computability, Limits, and AI

Last Updated June 23, 2026

Alan Turing, Computation, and the Machine Model of Reasoning examines one of the decisive shifts in the history of algorithms: the movement from procedure as something humans perform to computation as something that can be modeled by an abstract machine. Turing did not merely describe a device. He created a way to reason about reasoning itself: what can be carried out by definite rules, what can be encoded as symbols, what can be executed mechanically, and what lies beyond general procedure.

Turing’s 1936 paper on computable numbers introduced a machine model that made effective calculation mathematically precise. The model was simple: a tape, a head, a finite set of states, symbols, and rules for moving, writing, and changing state. Yet this simplicity was profound. It showed that computation could be studied apart from any particular human calculator, desk machine, or engineering technology. It gave mathematics a model of effective procedure.

Turing’s significance is therefore larger than the phrase “Turing machine.” He helped define the modern boundary between what can be computed and what cannot. He clarified the limits of mechanical method. He anticipated the idea of a universal machine that can simulate other machines when given their descriptions. He later asked how machine behavior might relate to intelligence. Together, these ideas made computation a philosophical, mathematical, technical, and institutional question.

This article introduces Alan Turing, computation, computable numbers, Turing machines, effective procedure, finite states, tape, symbols, transition rules, machine tables, universal machines, decidability, undecidability, the Entscheidungsproblem, the halting problem, Church-Turing thesis, formal reasoning, machine intelligence, imitation game, artificial intelligence, code, data, programs, abstraction, limits of automation, and responsible algorithmic reasoning. It argues that Turing matters because he made computation thinkable as a machine model of reasoning: powerful, general, formal, and limited.

Why Turing Matters

Turing matters because he gave computation a model. Earlier algorithmic traditions contained procedures, tables, symbolic methods, mechanical devices, and programmable visions. Turing’s distinctive contribution was to define effective calculation in terms of a simple abstract machine. This made it possible to ask mathematical questions about computation itself: what can be computed, what cannot, and what it means for a procedure to be mechanical.

The Turing machine is not important because it resembles a modern laptop. It does not. It is important because it strips computation down to essential features: finite rules, symbolic representation, local action, memory, state, and stepwise change.

Turing matters because he made computation a mathematical object and a philosophical problem.

Back to top ↑

The Problem of Effective Procedure

Before Turing, mathematicians and logicians were already asking whether mathematical reasoning could be reduced to rules. Hilbert’s Entscheidungsproblem asked, in effect, whether there was a general method for deciding the truth of statements in a formal system. To answer that kind of question, one first needs a precise account of what a “method” is.

Turing’s machine model answered by formalizing the idea of effective procedure. A procedure must be carried out by definite steps. It must operate on symbols. It must not require intuition at each step. It must be finite in its rule description. It must be mechanical in the sense that each next move is determined by the current state and symbol.

Turing’s machine model begins by making “method” precise enough to analyze.

Back to top ↑

Computable Numbers and Finite Means

Turing’s 1936 paper begins with computable numbers. A computable number is one whose decimal expansion can be calculated by finite means. This framing is important because it does not start with electronic computers. It starts with the question of what it means for a value to be calculable by an effective method.

Computable numbers gave Turing a way to connect mathematical objects with mechanical procedure. If a number’s digits can be generated by a definite rule process, then the number is computable. If no such process exists, then it is not computable in that sense. This turns computation into a boundary question.

The idea of finite means is the hinge between human calculation and machine computation.

Back to top ↑

The Turing Machine as an Abstract Model

A Turing machine is an abstract computational device. It is not a blueprint for a practical computer. It is a mathematical model of what a rule-governed calculating agent can do. The model includes an indefinitely extendable tape divided into squares, symbols written on the tape, a head that reads and writes, a finite set of states, and a transition table that determines what happens next.

Its power comes from its minimalism. By making the machine simple, Turing made computation analyzable. The question becomes: can this kind of machine carry out the procedure? If yes, the process is computable in the formal sense. If no general machine can do it, then the problem reveals a limit of mechanical reasoning.

The Turing machine is a model of effective reasoning reduced to local symbolic action.

Back to top ↑

Tape, Symbols, States, and Rules

The tape, symbols, states, and rules matter because they show how reasoning can be made mechanical. The machine does not understand a problem in a human sense. It follows rules. Yet if the right representation and rule system are supplied, the machine can perform meaningful computation.

This distinction is central. Mechanical reasoning does not require consciousness at each step. It requires a representation and a rule system that preserve the structure of the problem. A calculation becomes a sequence of configurations. Each configuration determines the next one.

Turing’s model shows how reasoning can be simulated by controlled symbol manipulation.

Back to top ↑

The Human Computer Behind the Machine

Turing’s model is often called a machine model, but it is also based on a disciplined analysis of human calculation. A human computer works with limited attention, writes symbols, follows instructions, consults current marks, changes written work, and proceeds step by step. Turing abstracts this activity into a machine.

This is historically important. Turing did not begin with electronic machinery. He began with the idea of what a human calculator can do when following a definite method. The machine model is therefore a bridge from human procedure to formal computation.

Turing’s machine formalizes the disciplined limits of a human calculator following rules.

Back to top ↑

Universal Machines and Program as Description

One of Turing’s deepest insights was the universal machine. A universal Turing machine can simulate any other Turing machine when given a suitable description of that machine. This is the conceptual ancestor of stored-program computing: a machine can treat instructions as data.

This idea changed the meaning of computation. Instead of building a different machine for every task, one general machine can execute different procedures depending on the description it receives. This is a foundation for modern software. A program is not only a set of actions; it is a symbolic description that can itself be stored, copied, interpreted, and executed.

The universal machine makes computation programmable in principle.

Back to top ↑

Decidability, Undecidability, and the Entscheidungsproblem

The Entscheidungsproblem asked whether there is a general decision procedure for mathematical truth in a formal logical system. Turing’s work helped show that no such universal mechanical decision method exists. This was not a minor technical result. It was a boundary line for algorithmic reasoning.

To say a problem is undecidable is not to say people should stop thinking. It is to say no general algorithm can solve every instance of the problem under the formal conditions specified. This matters today because modern automation often promises more than any procedure can deliver.

Turing’s model is powerful because it reveals limits, not only possibilities.

Back to top ↑

The Halting Problem and the Limits of Automation

The halting problem asks whether there can be a general procedure that determines, for any program and input, whether the program eventually stops or runs forever. The answer is no. There is no universal algorithm that solves the halting problem for all possible programs and inputs.

This is one of the most important lessons in the history of algorithms. Even perfectly defined machines have limits. Even formal procedures cannot decide everything about formal procedures. This undercuts simplistic faith in automation: not every meaningful question can be settled by a general algorithm.

The halting problem shows that automation has internal mathematical boundaries.

Back to top ↑

Turing and Church

Turing’s work appeared in close relation to Alonzo Church’s work on lambda calculus and effective calculability. Church and Turing provided different formal approaches that converged on the same class of effectively computable functions. This convergence became associated with the Church-Turing thesis: the claim that the intuitive notion of effective computability is captured by these formal models.

The difference matters. Church’s lambda calculus formalizes computation through symbolic functions and application. Turing’s model formalizes computation through a machine-like process acting on symbols. Turing’s account was especially influential for the emerging idea of automatic computation because it made the machine aspect vivid.

Church and Turing together gave computation a formal foundation; Turing gave it a machine imagination.

Back to top ↑

Reasoning as Symbolic Mechanical Procedure

Turing’s work is sometimes described as a model of computation, but it is also a model of a kind of reasoning. It asks: what reasoning can be reduced to symbol manipulation by rules? The answer is powerful but limited. Many formal operations can be represented mechanically. But not every human judgment, interpretation, ethical choice, or contextual understanding is captured by a formal procedure.

This distinction is critical for the Algorithms & Computational Reasoning series. Algorithmic reasoning is not all reasoning. It is reasoning that has been formalized into operations over representations. Turing helps us see both what this makes possible and what it leaves out.

Turing’s model clarifies formal reasoning; it does not exhaust human reason.

Back to top ↑

From Computation to Computers

Turing’s abstract model preceded the modern computer as everyday technology, but it helped shape the theoretical foundation of computing. Later electronic computers gave physical form to general-purpose computation. Stored programs, memory, instruction sets, compilers, and operating systems all belong to a lineage in which procedures become machine-executable descriptions.

The relationship between Turing machine and modern computer should be handled carefully. A Turing machine is a formal model, not an engineering design. A modern computer is a physical system with finite memory, hardware constraints, operating systems, interfaces, networks, and users. Still, Turing’s abstraction explains why one general machine can perform many procedures.

Turing’s machine model explains computation at a level more fundamental than any particular computer.

Back to top ↑

Turing and Machine Intelligence

Turing later turned to the question of machine intelligence. In “Computing Machinery and Intelligence,” he famously reframed the question “Can machines think?” through the imitation game. This was not the same as proving that machines understand. It was a way to replace a vague metaphysical question with a more testable behavioral framing.

Turing’s AI relevance is often overstated and understated. He did not solve artificial intelligence. He did not claim that every machine output is thought. But he did provide a powerful way of asking how machine behavior, language, imitation, learning, and human judgment might relate.

Turing gave AI one of its deepest questions, but not permission to ignore limits.

Back to top ↑

The Imitation Game and Behavioral Framing

The imitation game matters because it changes the question from “what is thinking?” to “what can be observed in a structured interaction?” This move is powerful because it avoids endless disagreement over definitions. It is also limited because behavior can be ambiguous. A system may imitate competence without possessing understanding in the human sense.

Modern AI debates still orbit this tension. A language model may produce fluent answers. A recommender system may infer preferences. A classifier may outperform humans on narrow benchmarks. But behavior must be interpreted in context: training data, task design, evaluation, failure modes, and institutional use all matter.

The imitation game is a tool for reframing intelligence, not a complete substitute for judgment.

Back to top ↑

AI Caution After Turing

Turing’s work supports both ambition and caution. Ambition comes from the universal machine, formal computation, and the idea that symbol manipulation can perform astonishing work. Caution comes from undecidability, the limits of formal procedure, and the difficulty of interpreting machine behavior as intelligence.

This matters for modern AI. When a system produces useful results, we should ask what procedure, data, optimization, and representation make those results possible. When a system fails, we should ask whether the failure is technical, contextual, ethical, institutional, or conceptual. Turing’s legacy is not blind faith in machines. It is disciplined clarity about mechanical procedure.

Turing’s legacy supports powerful tools, careful limits, and responsible interpretation. AI belongs in the toolkit, not in control.

Back to top ↑

Back to top ↑

Mathematics, Computation, and Modeling

A Turing machine can be modeled as:

A machine configuration can be modeled as:

A transition can be modeled as:

A universal machine can be modeled as:

The halting problem can be modeled as:

These formulas are interpretive teaching models. They clarify Turing’s contribution without reducing all reasoning to machines.

Back to top ↑

Python Workflow: Turing Machine Reasoning Map

The Python workflow below creates a dependency-light interpretive map of Turing’s machine model of reasoning. It scores themes by formalization, machine abstraction, symbolic representation, universality, decidability, limit awareness, reasoning relevance, AI relevance, governance caution, and modern resonance, then writes reproducible CSV and JSON outputs.

# alan_turing_machine_reasoning_map.py
# Dependency-light workflow for mapping Turing's role in computation and machine reasoning.

from __future__ import annotations

from dataclasses import asdict, dataclass
from pathlib import Path
from statistics import mean
import csv
import json
from datetime import datetime, timezone

ARTICLE_ROOT = Path(__file__).resolve().parents[1]
TABLES = ARTICLE_ROOT / "outputs" / "tables"
JSON_DIR = ARTICLE_ROOT / "outputs" / "json"


@dataclass(frozen=True)
class TuringConfig:
    article: str = "alan_turing_computation_and_the_machine_model_of_reasoning"
    core_threshold: float = 0.80
    high_formalization_threshold: float = 0.86


def timestamp_utc() -> str:
    return datetime.now(timezone.utc).isoformat()


def write_csv(path: Path, rows: list[dict[str, object]]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    if not rows:
        path.write_text("", encoding="utf-8")
        return
    fieldnames = sorted({key for row in rows for key in row.keys()})
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=fieldnames, extrasaction="ignore")
        writer.writeheader()
        writer.writerows(rows)


def write_json(path: Path, payload: object) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")


def turing_themes() -> list[dict[str, object]]:
    return [
        {"theme_id": "effective_procedure", "formalization": 0.98, "machine_abstraction": 0.92, "symbolic_representation": 0.92, "universality": 0.76, "decidability": 0.86, "limit_awareness": 0.92, "reasoning_relevance": 0.98, "ai_relevance": 0.78, "governance_caution": 0.86, "modern_resonance": 0.98},
        {"theme_id": "turing_machine_model", "formalization": 0.98, "machine_abstraction": 0.98, "symbolic_representation": 0.96, "universality": 0.86, "decidability": 0.90, "limit_awareness": 0.92, "reasoning_relevance": 0.96, "ai_relevance": 0.82, "governance_caution": 0.86, "modern_resonance": 0.98},
        {"theme_id": "universal_machine", "formalization": 0.96, "machine_abstraction": 0.98, "symbolic_representation": 0.96, "universality": 0.98, "decidability": 0.88, "limit_awareness": 0.90, "reasoning_relevance": 0.94, "ai_relevance": 0.86, "governance_caution": 0.86, "modern_resonance": 0.98},
        {"theme_id": "undecidability_and_limits", "formalization": 0.98, "machine_abstraction": 0.92, "symbolic_representation": 0.90, "universality": 0.86, "decidability": 0.98, "limit_awareness": 0.98, "reasoning_relevance": 0.96, "ai_relevance": 0.86, "governance_caution": 0.96, "modern_resonance": 0.98},
        {"theme_id": "human_computer_abstraction", "formalization": 0.92, "machine_abstraction": 0.96, "symbolic_representation": 0.92, "universality": 0.78, "decidability": 0.82, "limit_awareness": 0.88, "reasoning_relevance": 0.96, "ai_relevance": 0.80, "governance_caution": 0.84, "modern_resonance": 0.94},
        {"theme_id": "imitation_game_machine_intelligence", "formalization": 0.82, "machine_abstraction": 0.84, "symbolic_representation": 0.88, "universality": 0.76, "decidability": 0.74, "limit_awareness": 0.88, "reasoning_relevance": 0.90, "ai_relevance": 0.98, "governance_caution": 0.94, "modern_resonance": 0.98},
        {"theme_id": "ai_caution_after_turing", "formalization": 0.86, "machine_abstraction": 0.88, "symbolic_representation": 0.88, "universality": 0.86, "decidability": 0.88, "limit_awareness": 0.98, "reasoning_relevance": 0.94, "ai_relevance": 0.98, "governance_caution": 0.98, "modern_resonance": 0.98},
    ]


def score_theme(row: dict[str, object], config: TuringConfig) -> dict[str, object]:
    reasoning_score = mean([
        float(row["formalization"]),
        float(row["machine_abstraction"]),
        float(row["symbolic_representation"]),
        float(row["universality"]),
        float(row["decidability"]),
        float(row["limit_awareness"]),
        float(row["reasoning_relevance"]),
        float(row["ai_relevance"]),
        float(row["governance_caution"]),
        float(row["modern_resonance"]),
    ])

    if reasoning_score >= config.core_threshold and float(row["formalization"]) >= config.high_formalization_threshold:
        interpretive_status = "core_turing_machine_reasoning_thread"
    elif reasoning_score >= config.core_threshold:
        interpretive_status = "major_turing_machine_reasoning_thread"
    else:
        interpretive_status = "supporting_turing_machine_reasoning_thread"

    return {
        "theme_id": row["theme_id"],
        "formalization": round(float(row["formalization"]), 6),
        "machine_abstraction": round(float(row["machine_abstraction"]), 6),
        "symbolic_representation": round(float(row["symbolic_representation"]), 6),
        "universality": round(float(row["universality"]), 6),
        "decidability": round(float(row["decidability"]), 6),
        "limit_awareness": round(float(row["limit_awareness"]), 6),
        "reasoning_relevance": round(float(row["reasoning_relevance"]), 6),
        "ai_relevance": round(float(row["ai_relevance"]), 6),
        "governance_caution": round(float(row["governance_caution"]), 6),
        "modern_resonance": round(float(row["modern_resonance"]), 6),
        "reasoning_score": round(reasoning_score, 6),
        "interpretive_status": interpretive_status,
    }


def interpretation_cautions() -> list[dict[str, str]]:
    return [
        {"caution": "do_not_treat_turing_machine_as_physical_laptop", "meaning": "A Turing machine is an abstract model, not an engineering design."},
        {"caution": "do_not_claim_all_reasoning_is_computation", "meaning": "Turing formalizes effective procedure, not every form of human judgment."},
        {"caution": "do_not_ignore_undecidability", "meaning": "Turing's legacy includes limits of automation."},
        {"caution": "do_not_reduce_turing_to_ai_slogan", "meaning": "The imitation game is important but not a complete theory of intelligence."},
        {"caution": "do_not_confuse_computability_with_feasibility", "meaning": "A computable task may still be impractical because of time, memory, or context."},
    ]


def main() -> None:
    config = TuringConfig()
    themes = turing_themes()
    scored = [score_theme(row, config) for row in themes]
    cautions = interpretation_cautions()

    summary = {
        "article": config.article,
        "timestamp_utc": timestamp_utc(),
        "themes_reviewed": len(scored),
        "core_threads": sum(1 for row in scored if row["interpretive_status"] == "core_turing_machine_reasoning_thread"),
        "major_threads": sum(1 for row in scored if row["interpretive_status"] == "major_turing_machine_reasoning_thread"),
        "supporting_threads": sum(1 for row in scored if row["interpretive_status"] == "supporting_turing_machine_reasoning_thread"),
        "mean_reasoning_score": round(mean(float(row["reasoning_score"]) for row in scored), 6),
        "cautions": len(cautions),
        "interpretation": "Turing should be studied as a bridge between effective procedure, machine abstraction, universal computation, formal limits, and AI-era caution.",
    }

    write_csv(TABLES / "turing_themes.csv", themes)
    write_csv(TABLES / "turing_machine_reasoning_map.csv", scored)
    write_csv(TABLES / "interpretation_cautions.csv", cautions)
    write_csv(TABLES / "turing_reasoning_summary.csv", [summary])

    write_json(JSON_DIR / "turing_config.json", asdict(config))
    write_json(JSON_DIR / "turing_machine_reasoning_map.json", scored)
    write_json(JSON_DIR / "interpretation_cautions.json", cautions)
    write_json(JSON_DIR / "turing_reasoning_summary.json", summary)

    print("Turing machine reasoning map complete.")
    print(TABLES / "turing_reasoning_summary.csv")


if __name__ == "__main__":
    main()

This workflow turns Turing’s legacy into a reproducible interpretive artifact: formalization, machine abstraction, symbolic representation, universality, decidability, limits, reasoning, AI relevance, governance caution, and modern resonance are documented together.

Back to top ↑

R Workflow: Computability Diagnostics

The R workflow reads the generated CSV outputs, summarizes Turing themes, visualizes dimensions, and writes an additional diagnostic table.

# alan_turing_machine_reasoning_summary.R
args <- commandArgs(trailingOnly = FALSE)
file_arg <- grep("^--file=", args, value = TRUE)

if (length(file_arg) > 0) {
  script_path <- normalizePath(sub("^--file=", "", file_arg[1]), mustWork = TRUE)
  article_root <- normalizePath(file.path(dirname(script_path), ".."), mustWork = TRUE)
} else {
  article_root <- getwd()
}

setwd(article_root)

tables_dir <- file.path(article_root, "outputs", "tables")
figures_dir <- file.path(article_root, "outputs", "figures")
dir.create(tables_dir, recursive = TRUE, showWarnings = FALSE)
dir.create(figures_dir, recursive = TRUE, showWarnings = FALSE)

map_path <- file.path(tables_dir, "turing_machine_reasoning_map.csv")
summary_path <- file.path(tables_dir, "turing_reasoning_summary.csv")

if (!file.exists(map_path)) {
  stop(paste("Missing", map_path, "Run the Python workflow first."))
}

turing_map <- read.csv(map_path, stringsAsFactors = FALSE)
summary <- read.csv(summary_path, stringsAsFactors = FALSE)

png(file.path(figures_dir, "turing_reasoning_dimensions.png"), width = 1200, height = 850)
score_matrix <- t(as.matrix(turing_map[, c("formalization", "machine_abstraction", "symbolic_representation", "universality", "decidability", "limit_awareness", "reasoning_relevance", "ai_relevance", "governance_caution", "modern_resonance")]))
barplot(score_matrix,
        beside = TRUE,
        names.arg = turing_map$theme_id,
        las = 2,
        ylim = c(0, 1),
        ylab = "Interpretive Score",
        main = "Alan Turing, Computation, and the Machine Model of Reasoning")
legend("bottomright",
       legend = rownames(score_matrix),
       cex = 0.68,
       bty = "n")
grid()
dev.off()

png(file.path(figures_dir, "turing_reasoning_score_by_theme.png"), width = 1000, height = 750)
barplot(turing_map$reasoning_score,
        names.arg = turing_map$theme_id,
        las = 2,
        ylab = "Reasoning Score",
        main = "Turing Machine Reasoning Score by Theme")
grid()
dev.off()

r_summary <- data.frame(
  themes_reviewed = summary$themes_reviewed[1],
  core_threads = summary$core_threads[1],
  major_threads = summary$major_threads[1],
  supporting_threads = summary$supporting_threads[1],
  mean_reasoning_score = summary$mean_reasoning_score[1],
  cautions = summary$cautions[1],
  diagnostic_note = "Turing should be studied as a bridge between effective procedure, machine abstraction, universal computation, formal limits, and AI-era caution."
)

write.csv(r_summary, file.path(tables_dir, "r_turing_reasoning_diagnostic_summary.csv"), row.names = FALSE)
print(r_summary)

The R layer makes the interpretive structure visible: formalization, machine abstraction, symbolic representation, universality, decidability, limit awareness, reasoning relevance, AI relevance, governance caution, and modern resonance can be compared across themes.

Back to top ↑

GitHub Repository

The companion repository contains reproducible workflows, synthetic interpretive data, outputs, calculators, documentation, and multilingual examples for this article.

Back to top ↑

A Practical Method for Studying Turing

A careful study of Turing asks how effective procedure, machine abstraction, universality, formal limits, and machine intelligence relate without collapsing into slogans.

This method lets Turing’s contribution remain foundational without becoming simplistic.

Back to top ↑

Common Pitfalls

The first pitfall is treating the Turing machine as a physical laptop. The second is saying all reasoning is computation. The third is ignoring undecidability. The fourth is reducing Turing to the imitation game. The fifth is confusing computability with practical feasibility.

Turing’s work is strongest when treated as a theory of computable procedure and its limits.

Back to top ↑

Why Turing Still Matters

Alan Turing still matters because he made computation precise. He showed how a simple machine model could capture effective procedure, how a universal machine could simulate other machines, and how formal reasoning could reveal the limits of mechanical solution. His work explains why computers are possible and why automation cannot decide everything.

He also matters because his ideas remain alive in AI. The imitation game continues to shape debates about machine intelligence, but his computability work also warns against overclaiming. A machine can execute rules, simulate procedures, produce outputs, and imitate behavior. But every system has formal, practical, interpretive, and ethical limits.

Turing’s legacy is therefore not merely technical. It is a discipline of clarity. Define the procedure. Specify the representation. Identify the machine. Track the states. Ask whether it halts. Know what cannot be decided. Interpret machine behavior carefully. AI belongs in the toolkit, not in control.

Back to top ↑

Related Articles

• Ada Lovelace, Programming, and the Imagination of Computation
• Alonzo Church, Lambda Calculus, and Effective Computation
• Computability and the Limits of Procedure
• The Halting Problem and the Limits of Automation
• Large Language Models and Procedural Reasoning

Back to top ↑

Further Reading

• Turing, A.M. (1936) ‘On Computable Numbers, with an Application to the Entscheidungsproblem’. Proceedings of the London Mathematical Society, 42, pp. 230–265.
• Turing, A.M. (1950) ‘Computing Machinery and Intelligence’. Mind, 59(236), pp. 433–460.
• De Mol, L. (2018) ‘Turing Machines’. Stanford Encyclopedia of Philosophy.
• Hodges, A. (2002) ‘Alan Turing’. Stanford Encyclopedia of Philosophy.
• Copeland, B.J. (1997) ‘The Church-Turing Thesis’. Stanford Encyclopedia of Philosophy.
• Hodges, A. (2014) Alan Turing: The Enigma. Princeton: Princeton University Press.
• Davis, M. (2000) The Universal Computer: The Road from Leibniz to Turing. New York: Norton.
• Copeland, B.J. (ed.) (2004) The Essential Turing. Oxford: Oxford University Press.

Back to top ↑

References

• Copeland, B.J. (1997) ‘The Church-Turing Thesis’. Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/church-turing/.
• Copeland, B.J. (ed.) (2004) The Essential Turing. Oxford: Oxford University Press.
• Davis, M. (2000) The Universal Computer: The Road from Leibniz to Turing. New York: Norton.
• De Mol, L. (2018) ‘Turing Machines’. Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/turing-machine/.
• Hodges, A. (2002) ‘Alan Turing’. Stanford Encyclopedia of Philosophy. Available at: https://plato.stanford.edu/entries/turing/.
• Hodges, A. (2014) Alan Turing: The Enigma. Princeton: Princeton University Press.
• Turing, A.M. (1936) ‘On Computable Numbers, with an Application to the Entscheidungsproblem’. Proceedings of the London Mathematical Society, 42, pp. 230–265. Available at: https://www.cs.virginia.edu/~robins/Turing_Paper_1936.pdf.
• Turing, A.M. (1950) ‘Computing Machinery and Intelligence’. Mind, 59(236), pp. 433–460. Available at: https://courses.cs.umbc.edu/471/papers/turing.pdf.

Back to top ↑