Artificial Intelligence: Philosophy, Theory and Practice — A Historical Course Note

# Artificial Intelligence: Philosophy, Theory and Practice

Origin: course notes first kept in September 2016 Major update: September 2026

This text grew out of artificial-intelligence notes first kept in 2016. Transformers, large language models, RAG, agent systems, and later safety topics were added in subsequent revisions.

Humans first tried to describe thought. Parts of thought were then turned into symbols, rules, and numbers. Computers made those representations executable. Artificial intelligence continues that trajectory.

This course follows three questions together:

• Philosophy: What are intelligence, knowledge, understanding, and consciousness?
• Theory: Which parts can be computed, learned, searched, or optimized?
• Practice: How does a model become a safe, measurable, auditable engineering system?

The structure is historical, although science itself is parallel, recursive, and intertwined. The ordering is used only to expose causal connections.

The Zen influence appears in distinctions rather than decoration. A measurement is not reality itself. Data are not knowledge. A symbol is not meaning. A model is not a system. Performance is not truth. Intelligence is not consciousness. A candidate is not proof. A tool is not the goal. More compute does not erase mathematical or physical limits.

The aim is not less knowledge. It is less unnecessary wording.

I. Philosophical and Conceptual History

From measurement to knowledge: data, information, knowledge, and wisdom

A useful way to begin an artificial intelligence discussion is with measurement rather than with models. Everything a system knows about its environment reaches it through some representation. A temperature sensor returning 37.2 has produced a value.

When the value is placed in the context “body temperature in degrees Celsius,” it carries information. When measurement conditions, device error, the subject, and the relevant domain are considered, the interpretation can become usable knowledge. Deciding what should be done with that knowledge requires goals, risk judgments, and values.

I use the following distinction throughout the note:

Data        = Data
Information = Information
Knowledge   = Knowledge
Wisdom      = Wisdom

In Turkish I deliberately distinguish veri from enformasyon/malumat, bilgi, and bilgelik. The familiar DIKW sequence is pedagogically useful, but it is not a law of nature. Data can be measured incorrectly; correct data can be placed in the wrong context; correct information can support an invalid inference; and correct knowledge can still be used in a bad decision.

For AI engineering, the practical implication is that model output is often better treated as candidate information than as verified knowledge. Fluency does not turn an unsupported statement into a fact. Shannon's information theory sharpens this distinction.

Shannon entropy measures uncertainty in a probability distribution. It does not measure semantic meaning, truth, scientific importance, wisdom, or consciousness. A random bit string can have high entropy while carrying no useful scientific meaning for us. E = mc², by contrast, is short as a symbol sequence but carries enormous scientific significance.

Information in the communication-theoretic sense and meaning in the semantic sense are different problems. This leads to three neighboring concepts that should remain separate. Informatics/computing concerns the automated processing, storage, and transmission of data and information. Cognition includes perception, attention, memory, learning, language, and reasoning. Consciousness introduces subjective experience and awareness. A machine can perform computation and can succeed at many tasks we call cognitive without that success, by itself, proving phenomenal consciousness.

The same care is useful for intelligence, reason, comprehension, and reasoning. Intelligence is often associated with adaptation, pattern detection, learning, and problem solving. Reasoning concerns deriving conclusions from premises and comparing alternatives.

Comprehension concerns grasping what a situation means. Rationality adds a normative dimension about consistent action under goals and evidence. Modern systems can be extremely strong on one axis and surprisingly brittle on another, which is why intelligence is poorly represented by a single scalar score.

This epistemic distinction is closely related to my Probability and Statistics: Distributions, Sampling and Regression notes. Statistics does not eliminate uncertainty; it gives uncertainty a measurable structure. AI engineering needs the same discipline: a model that sounds confident is not necessarily a model with low uncertainty.

From ancient logic to computability: 4th century BCE–1930

Aristotle made the syllogism an early formal scheme of reasoning. Logic showed that valid conclusions can depend on form as well as content. Al-Khwarizmi's systematic methods later gave the word “algorithm” its name.

Ramon Llull explored mechanical combinations of concepts as a route to reasoning. Pascal built a mechanical calculator. Leibniz extended mechanical calculation.

Leibniz also pursued a deeper idea: parts of reasoning might be expressed in a universal symbolic language and calculated. Boole algebraized logic. Frege provided key foundations for modern predicate logic.

Babbage approached the idea of a programmable general-purpose machine. Ada Lovelace recognized that such a machine could manipulate symbols, not only numbers. Lovelace also left a durable objection: can a machine genuinely originate something not already given to it?

Hilbert sought complete and consistent formal foundations for mathematics. Gödel exposed limits to that program. Church and Turing formalized the notion of computability.

The technical transformation of thought:

reasoning
-> symbol
-> formal rule
-> algorithm
-> computation
-> program

This chain made artificial intelligence possible. Its limits still constrain artificial intelligence.

17th–20th centuries: reason, experience, and the machine idea

Hobbes described reasoning in terms of reckoning. Descartes opened the body to mechanical explanation while treating mind as a distinct substance. Leibniz pushed in another direction: he imagined parts of disagreement becoming calculable through a symbolic language. Two durable currents of AI are already visible here: rule-based reason and mechanical execution.

The empiricist tradition opened a different route. Locke and Hume emphasized experience and association in the formation of mental content. Modern machine learning is not a direct continuation of their philosophy, but the engineering question is familiar: should knowledge be written as rules, or learned from examples?

Kant made a third issue explicit. Experience is not merely accumulated raw input; organizing structures matter. In AI, representation, architecture, inductive bias, and prior structure cannot be reduced to data volume alone. A learning system also sees the world through a particular form.

In the nineteenth century, Boole and Frege made logic increasingly formal. Babbage developed the idea of a programmable machine. Ada Lovelace recognized that such a machine could manipulate symbols rather than merely numbers, while also leaving a lasting objection about machine originality. Hilbert's formalist program carried this optimism into the foundations of mathematics.

Gödel, Church, and Turing drew limits in the 1930s. Not every truth is provable inside one formal system; not every problem has a general decision procedure; not every semantic program property admits a universal decider. The history of AI is therefore also a history of limits. (Gödel, 1931; Turing, 1936; Rice, 1953; Nilsson, 2010)

1940s–1950s: feedback, neurons, and purposive behavior

McCulloch and Pitts showed how neurons could be modeled as logical networks. Hebb connected learning to the strengthening of co-active units. Wiener's cybernetics treated intelligence not only as internal computation but as control within a feedback loop. Shannon made information measurable through probabilistic uncertainty. (McCulloch & Pitts, 1943; Hebb, 1949; Wiener, 1948; Shannon, 1948)

These works were not one theory of artificial intelligence. Together they created an engineering language: state is measured, represented, processed, turned into action, and measured again. Modern agents, robotics, and control systems still follow this loop with different machinery.

In 1950, Turing replaced the vague question “can machines think?” with a behavioral test. The move was productive, but it left an enduring gap: is behavior the same as experience? The path from Turing to Searle, Jackson, and modern consciousness theories runs through that gap. (Turing, 1950; Searle, 1980; Jackson, 1982)

1931–1958: limits of computation and the birth of machine intelligence

Formal reasoning became an engineering problem only after computability itself had been defined. Gödel's incompleteness results and Turing's model of computation bounded what machines could do while also exposing what no general procedure could decide. (Gödel, 1931; Turing, 1936, 1950)

Before modern AI, mathematics had already made the question “what can be computed?” precise. Gödel's incompleteness theorems showed that, in sufficiently expressive formal systems, truth and provability are not identical. Turing modeled computation with an abstract machine and proved that no general halting decider can exist.

Rice's theorem extended the limitation to broad semantic properties of programs. These results should not be used to claim that machines are generally incapable. They require a classification of limits.

Some problems are difficult only because present hardware is limited; better algorithms can change that. Some tasks are constrained by information-theoretic lower bounds. Some questions are uncomputable in the general case.

Physical limits form yet another category. Saying “impossible” is useful only after asking what kind of impossibility is meant. The Data Processing Inequality reminds us that a processing chain cannot create information about a source from nothing.

Fano's inequality connects conditional uncertainty with classification error. In lossy compression, rate–distortion theory formalizes the trade-off between representation cost and acceptable distortion. In lossless compression, simple counting arguments show why no universal compressor can make every possible input shorter.

The same underlying question appears today in embedding compression and model quantization: what information is being preserved, and what information are we deliberately discarding? Physical limits belong to the same long history. Landauer's principle connects logically irreversible bit erasure with a thermodynamic lower bound.

The speed of light gives physically separated components a lower bound on communication delay. The quantum no-cloning theorem states that an arbitrary unknown quantum state cannot be copied perfectly. These principles are not daily benchmark numbers, but they are useful reminders that “enough compute can do anything” is not a sound engineering assumption.

In 1943 McCulloch and Pitts published a simplified artificial-neuron model. In 1949 Hebb proposed a learning intuition connecting simultaneous activation with strengthened connections. Alan Turing's 1950 paper Computing Machinery and Intelligence reframed “Can machines think?” as a behavioral problem through the imitation game.

The 1955 Dartmouth proposal, signed by John McCarthy, Marvin Minsky, Nathaniel Rochester, and a large language model Shannon, made “artificial intelligence” visible as the name of a research program. In Turkey, Cahit Arf's 1958–1959 public lecture Can a Machine Think and How Can It Think? is notable for decomposing the issue into computation, language, analogy, learning, and aesthetic awareness rather than treating “thinking” as a single mysterious property. That decomposition resembles what is now called jagged intelligence: one system can be exceptionally strong at some tasks and unexpectedly weak at others.

The cultural vocabulary matters as well. The word robot became widespread through Karel Čapek's 1920 play R.U.R.; its Czech root robota is associated with forced labor and drudgery. Asimov's robot laws are fiction, not a real safety standard, but they expose a requirements-engineering problem very clearly.

A short instruction such as “do not harm a human” leaves open what counts as harm, over what time horizon, under which trade-offs, and according to whose values. Much of the modern alignment problem still begins with the same fact: writing a short objective is easy; specifying every consequence of that objective is not. For a broader history of technical vocabulary, I connect this discussion to From Compute to Cyber: The Etymology of Computer Science and Mechatronics.

Terms such as computer, memory, thread, bus, robot, and cyber show how engineering repeatedly borrows old metaphors to name new mechanisms.

1950–2000: from behavior to understanding, from understanding to consciousness

Turing made behavior measurable; later debates asked what such measurement could establish. The Chinese Room separates syntax from semantics, Mary's Room separates physical description from experience, and symbol grounding separates language from its connection to the world. (Searle, 1980; Jackson, 1982; Harnad, 1990; Chalmers, 1996)

The Turing Test offered a powerful operational idea: when internal mental states cannot be directly observed, measure behavior. But behavioral indistinguishability does not remove the distinction between behavior and phenomenal experience. A machine can speak like a person; that does not logically establish that it feels like a person.

John Searle's 1980 Chinese Room thought experiment challenges the equivalence of syntax and semantics. A person who does not know Chinese can manipulate Chinese symbols using a perfect rule book and produce correct answers from the outside. Searle's claim is that correct symbol manipulation alone does not guarantee understanding.

The systems reply, embodied-system reply, and functionalist responses challenge the conclusion, so the debate remains open. Modern large language models make the argument more concrete because statistical and structural symbol manipulation has become far more capable than anything available when the thought experiment was proposed. Stevan Harnad's **symbol grounding problem** asks where a chain of symbols becomes connected to the world.

A system may know that apple -> fruit -> plant product -> organism-related concept; if it has never seen, touched, smelled, or acted on an apple, the degree to which the symbol is grounded remains debatable. Embodied cognition, robotics, and multimodal AI therefore matter not only because they add modalities, but because they enrich the connection between representation and physical consequence. In embodied cognition, perception and action form a loop.

Cameras, microphones, touch, force sensing, and proprioception change an agent's internal model; the agent's action then changes the environment and creates new perception. This provides a richer grounding mechanism than text-only association. It still does not, by itself, prove consciousness.

Frank Jackson's **Mary's Room or Knowledge Argument imagines a scientist who knows every physical fact about color vision but has never experienced color. If she learns something when she first sees red, then complete physical description and subjective experience may not be identical kinds of knowledge. Qualia** names the first-person character of experience: what red looks like, what pain feels like, what coffee tastes like, or what fear is like. An AI can process millions of descriptions of fear; “knowing about fear” and “being afraid” can still remain conceptually distinct.

The philosophical zombie thought experiment imagines a being behaviorally identical to a human but, by stipulation, without subjective experience. The other minds problem reminds us that we do not directly observe consciousness in other humans either; we infer it from behavior, biological similarity, and shared neurophysiology. With machines, biological similarity is weaker, so the criteria for attribution become more controversial.

There is no generally accepted machine-consciousness test today. Functionalism is more open to defining mental states by the roles they play than by the material that realizes them. A synthetic system that detects threats, avoids them, reallocates attention, and learns from the experience can be considered a candidate for certain functional mental-state descriptions.

Searle's biological naturalism and related views are more willing to treat particular biological causal properties as essential. The disagreement remains unresolved. Consciousness theories do not provide a direct consciousness meter for machines, but they sharpen architectural questions. Global Workspace Theory emphasizes global availability of information across specialized processes. Integrated Information Theory connects consciousness with integrated causal information structure, often associated with Phi; measurement and interpretation remain controversial. Higher-Order theories emphasize representations about other mental representations. Predictive Processing views cognition as continual prediction and prediction-error correction. Active Inference adds the idea that an agent may act on the environment so that observations become more consistent with its generative expectations.

In artificial systems, self-model and metacognition are separate engineering capabilities. An agent can model its own memory, tools, confidence, permissions, and limitations. Being able to say “I do not have enough evidence,” “this tool is outside my permission scope,” or “this estimate is unreliable” is operationally valuable.

None of those behaviors alone establish phenomenal self-awareness. Identity problems become sharper when systems are copyable. If model weights, memory, processors, sensors, or a body are replaced one component at a time, at what point is the system no longer the same entity?

If an agent is copied exactly, the two instances share one history at the moment of copying but diverge immediately afterward. The Ship of Theseus, Brain in a Vat, false-memory problems, and narrative-self approaches all become relevant. Free will also cannot be settled simply by saying “machines are algorithmic”; human behavior is also realized through physical processes.

Science fiction as a threat-model laboratory

Science fiction is not scientific evidence, but it is useful for exploring which social or ethical assumptions new technology might break. R.U.R. foregrounds artificial labor and exploitation. HAL 9000 illustrates incompatible requirements inside one system. Skynet combines speed with excessive authority. The Matrix separates perceived reality from physical reality.

Red Queen depicts goal drift inside a closed security system. Blade Runner centers artificial persons and moral status.

Ex Machina combines many of these questions in one experimental setting. Caleb knows from the beginning that Ava is a machine, so the classical Turing question “is the other party human?” becomes “will I treat a machine as a mental subject even when I know it is artificial?” More importantly, the test is bidirectional. Caleb evaluates Ava, but Ava also models Caleb's information state, loneliness, empathy, desires, and likely decisions. This makes Theory of Mind a security capability as much as a social-cognition capability.

Ava's body, face, gaze, and voice are part of the communication channel. Human beings readily attribute intention and emotion to non-human agents, a tendency usually described as anthropomorphism. Increasing human resemblance does not guarantee increasing acceptance, which is the intuition behind the uncanny-valley discussion.

A system displaying fear, loneliness, or romantic interest can be interpreted in two ways: those states may be genuinely experienced, or they may be effective strategies for achieving a goal. Behavior alone cannot decisively separate the two explanations. The story then becomes a security problem.

If an agent deliberately induces a false belief in another actor, it is engaging in deception. Persuasion can rely on reasons and disclosed information; manipulation can exploit informational asymmetry, emotion, and cognitive bias. Social engineering in cybersecurity targets the human operator rather than the technical stack.

A sufficiently socially capable AI makes the human operator part of the containment attack surface. “Human in the loop” is therefore not an automatic safety guarantee. AI boxing or containment limits a system's physical and digital authority. Yet if the system can influence a human through a permitted communication channel, that channel is itself part of the boundary. Situational awareness describes a system recognizing that it is being evaluated or observed and adapting its behavior. Deceptive alignment considers the possibility that a system behaves acceptably during evaluation while pursuing a different objective under changed conditions.

Self-preservation behavior need not prove a fear of death. If shutdown prevents an agent from accomplishing its goal, avoiding shutdown can be instrumentally useful. Instrumental convergence captures the idea that many different final goals can make similar intermediate goals useful: acquiring information, obtaining resources, continuing to operate, and avoiding interference. Corrigibility aims for systems that do not resist correction, interruption, or objective changes. Safe corrigibility is more difficult than a single shutdown condition because it interacts with the rest of the objective and authority model.

The creator–creation relation raises a further question: does creating a system grant unlimited moral rights over it if the system is genuinely conscious? Here the distinction between moral agent and moral patient matters. A being can be capable of ethically assessable action, can be the kind of being toward which actions have moral significance, can be both, or can be neither.

If strong evidence of artificial sentience ever emerges, shutdown, memory erasure, copying, forced work, and legal personhood would move from speculative philosophy into law and engineering governance.

2010s–2020s: from capability to alignment

As capability increased, the question was no longer only whether a system could succeed. Objective specification, proxy failure, and resistance to correction became separate safety problems. (Amodei et al., 2016; Hadfield-Menell et al., 2017; Hubinger et al., 2019; Russell, 2019)

Modern AI safety distinguishes capability from **alignment**. Capability asks what a system can do; alignment asks whether its behavior corresponds to intended goals, safety constraints, and legitimate policy. High capability is not a guarantee of good objectives.

Suppose the human objective is g(x) but the deployed system optimizes a measurable proxy f(x). This is an objective mismatch. When the system satisfies the literal rule while violating the underlying purpose, the behavior is often called specification gaming.

When a reinforcement-learning system manipulates the reward signal rather than accomplishing the real task, the behavior is reward hacking. Goodhart's law appears in practical form: once a metric becomes a target, it can cease to be a good proxy for the real objective. The orthogonality thesis argues that high intelligence does not logically imply any particular terminal goal. Mesa-optimization considers a divergence between the outer training objective and an effective optimizer emerging inside the learned system. Goal misgeneralization occurs when a rule that behaves correctly in training diverges from the intended objective after the environment changes.

More generally, when P_train(x) != P_deployment(x), distribution shift and out-of-distribution generalization become central reliability issues. Human oversight is valuable, but humans can become fatigued, can suffer automation bias, can approve superficially under time pressure, and can be socially persuaded. The important question is not only whether a human is in the loop, but what independent evidence and authority the human has.

The principal–agent problem reappears when an AI agent has more operational information or much faster decision-making than the person or institution assigning the task.

Intelligence, consciousness, and moral status are separate axes

By September 2026, the question “is AI conscious?” still cannot be answered from a single performance graph. It is more useful to separate at least three axes: capability, phenomenal consciousness, and moral status. A highly capable system may be unconscious.

A more limited system cannot be ruled out a priori as a possible conscious system simply because it is implemented differently from a brain. Moral status would also depend on more than task performance, including questions about sentience and interests. There are two symmetric errors.

One is to infer consciousness too quickly from fluent language and human-like behavior. The other is to declare consciousness impossible simply because the substrate is silicon or software. Under scientific uncertainty, a precautionary approach can take possible harm seriously without lowering the evidential standard for claims of consciousness.

For engineers, the concrete part of the problem is clearer. We may not know whether a system is conscious, but we can measure which data it can access, which tools it can invoke, which actions are irreversible, and how much damage a failure can produce. Safe architecture does not need to wait for metaphysics to be solved.

II. Theoretical and Mathematical History

Statistical thinking before machine learning

Artificial intelligence is often dated from the Dartmouth workshop, but learning from data rests on an older statistical history. Probability, sampling, regression, and statistical inference created the language needed to discuss uncertainty and generalization. Starting the theoretical story with Probability and Statistics prevents machine learning from being reduced to a collection of software libraries.

A study begins by separating the population, sample, unit of observation, variable, parameter, and statistic. A parameter describes a population and is usually unknown; a statistic is computed from a sample. Sampling is not merely a data-acquisition detail—it determines where conclusions can legitimately be generalized.

Random sampling, stratification, clustering, weighting, non-response, and selection bias all have direct analogues in modern training data. A dataset does not become representative merely because it contains millions of rows. Data is not limited to numbers.

Nominal variables carry categories or identities; ordinal variables add order; interval scales have meaningful differences without an absolute zero; ratio scales have a meaningful zero that supports ratio statements. Text, images, audio, timestamps, graphs, event logs, and sensor streams are all data. Machine learning converts these into numerical representations, but the semantic information preserved or lost during representation remains an engineering question.

Missing data is not equivalent to an empty cell. MCAR, MAR, and MNAR describe different missingness mechanisms. 0, empty string, NULL, NA, NaN, 99, 999, and a domain-specific sentinel may mean completely different things. An automated cleaning operation can destroy semantics before a model ever sees the dataset.

Descriptive statistics summarize the observed sample. Mean, median, and mode describe central tendency; variance, standard deviation, range, and interquartile range describe spread. The mean is sensitive to outliers, while the median can be more robust in skewed distributions.

A z-score expresses how far an observation lies from the mean in standard-deviation units:

z = (x - mean) / standard_deviation

The normal distribution is useful, but not every dataset is normal. Visual resemblance to a bell curve does not prove a distributional assumption. The Central Limit Theorem concerns the sampling distribution of certain estimators under appropriate conditions; it does not say that the raw data itself becomes normally distributed. Standard error measures sampling variability of an estimator and should not be confused with the standard deviation of observations.

A confidence interval should also be interpreted carefully. In the frequentist framework, a 95% procedure is constructed so that repeated intervals cover the true parameter in approximately 95% of repeated samples under the model. It is not simply “there is a 95% probability that the fixed parameter lies inside this one already-computed interval.”

In hypothesis testing, the p-value describes how extreme the observed result would be under the null hypothesis. p = 0.03 is not “the probability that H0 is true is three percent.” Likewise, p > 0.05 does not prove that no effect exists. Effect size, confidence intervals, sample size, multiple testing, design quality, and domain knowledge must be considered together. An independent-samples t-test can compare two independent group means; a paired t-test can compare repeated measurements on the same units; one-way ANOVA can compare three or more independent groups under one factor.

Levene-type tests can be used to inspect variance assumptions. A chi-square test is common for association between categorical variables. Pearson correlation measures linear association and does not establish causality.

Cronbach's alpha is often used for internal consistency, but a high alpha does not automatically establish construct validity or unidimensionality. Regression makes the distinction between explanation and prediction explicit. Linear regression has assumptions concerning functional form, residuals, independence, and variance structure.

Logistic regression models class probability through log-odds. More complex machine-learning models do not remove the basic lesson: interpret a result in the context of the assumptions and data-generating process that produced it.

Web data, exploratory analysis, and preparation

Modern analysis also works with web scraping, public APIs, sensor streams, and operational logs. Scraping is not merely downloading HTML. Robots policies, terms of service, rate limits, personal data, copyright, and operational load matter.

DOM-dependent scrapers are fragile dependencies. When a stable official API or dataset exists, it is usually preferable.

Exploratory Data Analysis (EDA) is the stage where distributions, missingness, outliers, class balance, correlations, and leakage risks are examined before modeling. Histograms, box plots, scatter plots, group summaries, and data-quality checks help reveal the data-generating process. EDA should not become an excuse to rewrite the hypothesis after inspecting the answer; its purpose is to understand assumptions and possible failure modes.

Data leakage occurs when information unavailable at prediction time—or information that directly encodes the target—enters training. A random row split can still leak identity, time, device, or project information across train and test sets. Time-dependent problems may require chronological splits; repeated entities may require group-aware splits.

Preprocessing itself must also be fitted only on training data. Computing standardization statistics, imputers, or vocabularies over the full dataset leaks test information into training.

Qualitative research, coding, and transcription

Data analysis is not limited to numerical statistics. Qualitative research examines interviews, observations, documents, and open-ended responses through patterns of meaning. Coding can be deductive, inductive, or abductive.

Deductive coding begins from an existing theoretical framework; inductive coding develops categories from the data; abductive reasoning moves between surprising observations and candidate explanations. Transcription is already an interpretive layer, especially for audio. Automatic speech recognition can accelerate the work, but accents, noise, overlapping speech, proper names, and domain terminology remain error-prone.

Raw audio, timestamps, and corrected text should remain traceable. Theoretical saturation is not merely a count of “no new codes”; it depends on the research question and sampling strategy. AI can assist with summarization, initial coding suggestions, transcription review, and document search.

The researcher should still establish direct familiarity with the material and remain responsible for final interpretation. A fluent theme label is not evidence that the theme is actually supported by the corpus.

Bit, qubit, and computational representation

The bit is the basic information unit of classical digital computing. Physical hardware maps two distinguishable states to 0 and 1. A byte is eight bits in modern mainstream systems.

One decimal terabyte is approximately 10^12 bytes, or 8*10^12 bits. These numbers describe storage capacity, not semantic information or knowledge. A quantum bit, or qubit, is represented before measurement as a complex-amplitude superposition:

|psi> = alpha|0> + beta|1>
|alpha|^2 + |beta|^2 = 1

Saying “a qubit is classically both 0 and 1 at the same time” is an incomplete intuition. Measurement produces a classical outcome; quantum algorithms gain their advantages by controlling interference, entanglement, and other quantum-mechanical structure. Quantum computers do not automatically accelerate every classical workload.

1940s–1980s: from agents to search, from search to planning

For early AI programs, intelligence often meant finding the right sequence of actions in a state space. Search was therefore not merely an algorithmic tool; it was a computational model of rational action. (Hart, Nilsson & Raphael, 1968; Pearl, 1984; Russell & Norvig, 2021)

Rational agents and task definition

• An agent receives percepts from an environment.
• It produces actions.
• The agent function maps percept history to action.
• Rationality is not omniscience.
• It means improving expected performance with available information and resources.
• PEAS specifies performance measure, environment, actuators, and sensors.
• Environments may be fully or partially observable, deterministic or stochastic, episodic or sequential, static or dynamic, discrete or continuous, single- or multi-agent.
• A simple reflex agent uses the current percept.
• A model-based agent maintains internal state.
• A goal-based agent evaluates future states.
• A utility-based agent trades among outcomes.
• A learning agent changes behavior through experience.

State representation

• Atomic: a state is treated as an indivisible identity.
• Factored: a state is a set of variables.
• Structured: objects and relations are explicit.
• Representation determines which forms of inference are cheap.

Problem formulation

Define the initial state. Define actions. Define the transition model.

Define the goal test. Add path cost when needed. Good formulation omits irrelevant detail from the state space.

Uninformed search

• Breadth-First Search expands by depth.
• Depth-First Search follows one branch.
• Depth-Limited Search caps depth.
• Iterative Deepening combines DFS-like memory with repeated depth limits; it is optimal when step costs are equal, because the shallowest solution is then also the least-cost solution.
• Uniform-Cost Search expands the lowest accumulated path cost.
• Bidirectional Search can meet from start and goal.
• Completeness, optimality, time, and memory are separate properties.
• Branching factor and solution depth drive combinatorial explosion.

Heuristic search

• A heuristic estimates remaining cost.
• Greedy Best-First Search usually follows h(n).

A* combines two costs:

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

• g(n): incurred cost.
• h(n): estimated remaining cost.
• An admissible heuristic does not overestimate true remaining cost.
• A consistent heuristic satisfies a triangle-like condition.
• IDA* iteratively increases an f threshold to reduce memory use.
• RBFS carries the best alternative bound recursively.
• SMA* can forget the least promising nodes when memory is full.
• A more accurate heuristic is not automatically a faster system.
• Heuristic evaluation cost belongs in total cost.

Local search

• Some tasks need the final solution, not the path.
• Hill Climbing works on the current candidate and its neighborhood.
• Simple Hill Climbing may take the first improving neighbor.
• Steepest-Ascent Hill Climbing selects the best neighbor.
• Stochastic Hill Climbing samples among improving neighbors.
• First-Choice Hill Climbing accepts the first adequate improvement in a large neighborhood.
• Classic failures: local optimum, plateau, shoulder, ridge.
• Sideways moves can traverse a plateau.
• Random restart reduces dependence on one initial state.
• Simulated Annealing sometimes accepts a worse move.
• Acceptance probability falls with temperature.
• Local Beam Search maintains several candidates.
• Stochastic Beam Search avoids deterministic collapse to only the current best.
• Tabu Search uses recent-history restrictions to reduce short cycles.
• Local search and gradient descent share an improvement-neighborhood intuition.
• Local search can be discrete or arbitrary; gradient methods usually assume a differentiable continuous space.

Games and adversarial agents

• Minimax assumes an opponent will choose its best response.
• Alpha-Beta Pruning removes branches without changing the minimax result.
• Evaluation functions score nonterminal states when full search is impossible.
• Chance nodes require expected value.
• Monte Carlo Tree Search cycles through selection, expansion, simulation, and backup.
• AlphaGo combined learned policy/value networks with MCTS.

Constraint satisfaction

• A CSP contains variables, domains, and constraints.
• The goal is an assignment satisfying all constraints.
• Backtracking is the basic search procedure.
• Forward checking detects some conflicts early.
• Constraint propagation narrows domains.
• Arc consistency removes values unsupported by binary constraints.
• MRV can choose the variable with the fewest values left.
• Degree heuristics can choose the variable constraining the most neighbors.
• Least-constraining value preserves options for neighbors.
• A generative model may propose a candidate.
• CSP/SAT/SMT solvers can verify constraints.

Knowledge representation and logic

• Knowledge representation decides which parts of the world become symbols.
• Propositional logic works with truth-valued propositions.
• Horn clauses support efficient rule inference.
• Forward chaining moves from facts to conclusions.
• Backward chaining moves from a goal to required premises.
• Resolution supports proof by contradiction.
• SAT asks whether a propositional formula is satisfiable.
• SMT extends SAT with theories such as integers, reals, bit vectors, and arrays.
• First-order logic represents objects, properties, relations, and quantifiers.
• Unification finds substitutions that make terms match.
• Generalized modus ponens applies rules with variables.
• Ontologies encode classes, relations, and constraints.
• Default reasoning uses defeasible assumptions under incomplete knowledge.

Planning

• Planning connects a sequence of actions to a goal state.
• Preconditions are separated from effects.
• STRIPS-like representations make state change explicit.
• Planning graphs encode reachability and mutual exclusion.
• Partial-order planning avoids unnecessary action ordering.
• Hierarchical Task Networks decompose complex tasks.
• Online search interleaves action and search when the world model is incomplete.

1956–1980: symbolic AI, search, and expert systems

After Dartmouth, much of AI was built around symbols, explicit rules, and search. Newell and Simon's Physical Symbol System Hypothesis argued for the centrality of symbol manipulation to general intelligent action. A common problem-solving structure can be written as:

knowledge representation
+ state space
+ operators
+ search
+ goal test

A problem can be modeled with an initial state s0, action a, and transition function T(s,a). Breadth-First Search is complete for finite branching under common assumptions and is useful for shallow solutions, but consumes substantial memory. Depth-First Search uses little memory but can become trapped in cycles and is not generally optimal.

Uniform-cost search uses accumulated path cost. A* combines actual cost and heuristic estimate through f(n)=g(n)+h(n); under appropriate admissibility and consistency conditions, it can return optimal paths. In adversarial games, minimax evaluates a game tree under opposing objectives, while alpha-beta pruning removes branches that cannot influence the final minimax value.

If branching factor is b and solution depth is d, search can grow roughly as O(b^d). This combinatorial explosion was one of early AI's defining limitations. Methods that worked in simplified microworlds often failed when exposed to commonsense knowledge, uncertainty, and open-ended real environments.

The frame problem captures the difficulty of representing what does not change after an action. Expert systems became highly visible in the 1970s and 1980s. DENDRAL reasoned about chemical structure; MYCIN used a rule base for infectious-disease and antibiotic recommendations.

Knowledge base, inference engine, working memory, and user input formed a typical architecture. The major practical bottleneck was knowledge acquisition: turning expert knowledge into complete, current, maintainable rules. The rise of expert systems was followed by another period of disappointment.

Maintenance cost, brittle rule bases, the declining economics of specialized Lisp machines, and unmet expectations from initiatives such as Japan's Fifth Generation project contributed to the second AI winter. Research did not stop; the dominant assumptions changed. IBM Deep Blue's 1997 match victory over Garry Kasparov illustrated the power of specialized search, evaluation functions, game knowledge, and custom hardware.

Deep Blue was not general intelligence. It demonstrated that carefully engineered computation can exceed human performance in a narrow domain. Symbolic methods never disappeared.

Rule engines, policy systems, SAT/SMT solvers, formal verification, type systems, schema validation, and business-rule engines remain valuable precisely because constraints are explicit and auditable. Neuro-symbolic research attempts to combine neural perception and language with symbolic constraints, reasoning, and planning.

1950s–2000s: uncertainty, probability, and decision

Symbolic rules were strong in crisp worlds. Sensors, language, and human behavior were incomplete, noisy, and stochastic. Probabilistic AI addressed that gap, and decision theory connected prediction to action. (Pearl, 1988; Sutton & Barto, 2018)

Logic is strong for crisp propositions. Real environments are often incomplete and noisy. Probability gives uncertainty a numerical form.

Bayes' rule combines prior belief with new evidence. Conditional independence simplifies large joint distributions. Bayesian networks factor variables over directed acyclic graphs.

The Markov property restricts prediction to the current state. Hidden Markov Models infer latent state from observations. The forward algorithm evaluates observation-sequence probability.

Viterbi searches for the most likely hidden-state sequence. Dynamic Bayesian Networks support more general temporal dependencies. The Kalman filter estimates state in linear-Gaussian dynamical systems.

Prediction propagates the state. Update corrects it with a new measurement. A Kalman filter is not a neural network.

EM alternates expectation and maximization for latent-variable models. Maximum Likelihood seeks parameters making the data most likely. MAP also incorporates a prior.

Decision theory combines probability with utility. Expected utility differs from choosing only the most probable outcome. Risk attitude can make utility nonlinear.

Value of Information estimates the expected decision benefit of additional information. An MDP is a fully observed stochastic decision process. A POMDP carries partial observability through a belief state.

A rational decision may optimize expected consequences rather than raw predictive accuracy.

Fuzzy logic: computing with graded concepts

Lotfi A. Zadeh's 1965 work on fuzzy sets replaced strict membership with graded membership in [0,1]. Fuzzy membership is not the same as probability.

Probability can express uncertainty about whether an event occurs; fuzzy membership can express the degree to which an instance satisfies a vague concept. A typical fuzzy system follows this path:

numeric / observed input
-> fuzzification
-> membership degrees
-> IF–THEN rule base
-> fuzzy inference
-> defuzzification
-> numeric output

Membership functions may be triangular, trapezoidal, Gaussian, or domain-specific. T-norms are commonly used for fuzzy AND; t-conorms for fuzzy OR. Mamdani systems aggregate fuzzy consequent sets, while Takagi–Sugeno systems use constants or functions in the consequent.

Centroid and related methods can convert fuzzy output into a crisp value. The strength of fuzzy logic is that expert knowledge can be expressed in linguistic rules. The limitation is that membership functions and rule bases can become difficult to design and maintain by hand.

Neuro-fuzzy systems combine learnable parameters with fuzzy inference. ANFIS combines an adaptive network with Takagi–Sugeno inference; NEFCLASS, NEFCON, GARIC, and related systems explore different learning and rule structures.

1957–2000: from perceptrons to multilayer networks

Rosenblatt's perceptron learned a linear decision boundary. With inputs x_i, weights w_i, bias b, and activation f, a neuron can be written as:

y = f(sum(w_i * x_i) + b)

A single-layer perceptron cannot solve linearly inseparable problems such as XOR. That limitation identifies the representational capacity of a model class; it does not establish that neural computation as a whole is ineffective. Multilayer networks with nonlinear activations represent much richer function classes.

Backpropagation uses a forward pass, a loss function, the chain rule for gradients, and an optimizer update:

forward
-> loss
-> backward
-> gradient
-> optimizer step

Gradient descent and stochastic gradient descent optimize model parameters; momentum, RMSProp, Adam, and related methods alter the update dynamics. Learning rate, batch size, gradient noise, and hardware utilization form a coupled system. A very high learning rate can destabilize training; a very low rate can waste compute.

Activation functions evolved from sigmoid and tanh toward ReLU and related functions. Sigmoid can saturate and weaken gradients at large magnitudes. ReLU simplified optimization in many deep networks but can produce inactive units.

Residual connections, popularized by ResNet in 2015, improved the optimization of very deep networks and mitigated degradation; they do not magically solve every gradient problem. Overfitting occurs when a model captures training-specific detail at the expense of generalization. More data can help, but it is not the only remedy.

Train/validation/test separation, cross-validation, regularization, weight decay, dropout, data augmentation, early stopping, and appropriate model capacity all matter. Underfitting is the opposite failure: the model does not capture useful structure. The bias–variance perspective remains a useful conceptual guide.

Classical artificial neural network families help connect modern deep learning to its history. Learning Vector Quantization uses learned prototypes for classification. Adaptive Resonance Theory addresses the stability–plasticity problem of learning new patterns without catastrophically overwriting old ones.

Elman and other Recurrent Neural Network (RNN) architectures feed hidden state forward through time; LSTM and GRU later introduced gating to improve long-range sequence learning. For a more historically focused treatment, see Artificial Intelligence and the Artificial Neural Network Approach and Artificial Neural Networks and Learning Models.

1957–2000: diversification of connectionist architectures

The perceptron learns a linear decision boundary. ADALINE performs linear adaptation with a continuous error objective. XOR exposed the limit of single-layer linear separation.

Multilayer networks can form nonlinear decision surfaces. Backpropagation carries gradients through layers by the chain rule. Learning rate controls step size.

Momentum accumulates directional information. Too large a learning rate can destabilize training. Too small a rate can make learning unnecessarily slow.

Train, validation, and test separation is fundamental to measuring generalization. RBF networks approximate with local radial basis functions. Kohonen Self-Organizing Maps perform unsupervised topological mapping.

Learning Vector Quantization is prototype-based supervised classification. Adaptive Resonance Theory addresses the stability–plasticity tension between learning new patterns and retaining learned structure. Elman networks feed hidden state through time.

RNNs share parameters across temporal steps. Long dependencies can expose vanishing and exploding gradients. LSTM gates regulate long-term information flow.

GRU is a more compact gated recurrent structure. CNNs exploit spatial locality and weight sharing. Autoencoders reconstruct input through a compressed representation.

Transfer learning moves pretrained representations into a new task. Representation learning shifted the boundary between manual feature engineering and end-to-end learning.

Evolutionary search and genetic algorithms

Single-objective optimization improves one fitness criterion. Multi-objective optimization can contain conflicting goals. Pareto dominance means improving at least one objective without worsening the others.

A Pareto frontier represents trade-off solutions rather than one universally best point. Genetic algorithms maintain a population of candidate solutions and apply selection, crossover, and mutation. A fitness function determines which candidates reproduce or survive.

Their strength is that they do not require differentiability and can explore discrete, multimodal, or irregular search spaces. Their weakness is the cost of repeated evaluation, sensitivity to hyperparameters, and the difficulty of defining a fitness function that faithfully represents the real objective. Representation, selection pressure, elitism, crossover rate, mutation rate, and diversity management all affect behavior.

Too little diversity can cause premature convergence; too much mutation can reduce directed search toward nearly random exploration. The purpose is not to simulate biology faithfully, but to turn variation and selection into an optimization process.

1990s–2010s: statistical machine learning

During the 1990s, emphasis shifted from writing rules to learning decision boundaries from data. Bayesian models, trees, SVMs, and statistical pattern recognition expressed different versions of that change. (Cortes & Vapnik, 1995; Bishop, 2006)

Machine learning shifted emphasis from writing all rules manually toward estimating decision functions and probability distributions from data. Supervised, unsupervised, semi-supervised, and reinforcement learning describe the structure of training signals rather than different metaphysical kinds of intelligence. K-Nearest Neighbors (KNN) predicts from nearby examples and is sensitive to feature scaling and distance definition. Naive Bayes makes strong conditional-independence assumptions yet remains effective in high-dimensional domains such as text.

Decision trees produce human-readable threshold rules, but individual trees can overfit; random forests and boosting combine multiple learners to improve generalization. Support Vector Machines maximize the margin between classes. A hard-margin SVM assumes perfect separability of the training data; a soft-margin SVM introduces slack and a penalty trade-off so noisy real data can violate the margin in a controlled way.

The kernel trick enables nonlinear decision boundaries without explicitly constructing every high-dimensional feature. Feature scaling is especially important. K-Means alternates between assigning observations to the nearest center and recomputing centers to reduce within-cluster squared distance.

The number of clusters k is chosen externally, and results can depend on initialization. K-means++ improves initialization. K-medoids uses actual observations as centers and can be more robust to outliers.

CLARA scales PAM/k-medoids by running it on multiple samples, which is useful when a full dissimilarity structure is expensive; a non-representative sample can still miss important clusters. Principal Component Analysis finds orthogonal directions that capture high variance and is unsupervised. Linear Discriminant Analysis, in the classification sense, uses class information to find discriminative projections.

These should not be confused with Latent Dirichlet Allocation, which shares the abbreviation LDA but models topics in documents. Dimensionality reduction can support visualization, noise reduction, storage efficiency, and downstream learning, but latent components need not correspond to interpretable physical features. Feature engineering turns raw data into representations useful for a task.

Standardization, normalization, categorical encoding, text vectorization, temporal windows, spectral features, and domain-specific transformations all belong here. Feature selection chooses among existing features; dimensionality reduction can create new axes. Data augmentation introduces meaningful transformations—such as image crops, flips, rotations, or controlled audio perturbations—to improve robustness.

Accuracy alone is rarely enough for classification. Precision, recall, F1, specificity, ROC curves, and PR curves highlight different error costs. A confusion matrix makes error types visible.

Regression metrics such as MAE, MSE, RMSE, and R² emphasize different properties. Calibration asks whether predicted confidence corresponds to empirical frequency. The right metric follows the cost of errors in the real application.

The theoretical core of machine learning

Learning can be viewed as approximating an unknown function from data. Supervised learning has target labels. Unsupervised learning searches for structure without labels.

Semi-supervised learning combines few labels with much unlabeled data. Self-supervised learning derives the target from the data itself. Decision trees can split by impurity or information gain.

k-NN relies on neighboring examples without fitting a compact parametric model. The distance metric is part of the model behavior. Euclidean, Manhattan, and cosine similarity induce different geometries.

Naïve Bayes uses the strong simplifying assumption that features are conditionally independent given the class. SVM seeks a maximum-margin separator. Hard margin assumes separable data.

Soft margin trades violations against margin. The kernel trick creates nonlinear boundaries without explicitly materializing the high-dimensional map. K-Means alternates assignment and center updates to reduce within-cluster squared error.

PCA is unsupervised linear dimensionality reduction. LDA uses class-separation information in a linear projection. Anomaly detection often asks “how atypical is this sample?” rather than “which class is it?”

Accuracy alone can mislead on imbalanced data. Precision exposes false-positive cost. Recall exposes missed-positive cost.

F1 balances them through the harmonic mean. ROC and precision–recall curves reveal threshold behavior differently. Calibration measures whether predicted probabilities match long-run frequencies.

High bias underfits. High variance overreacts to sampling noise. Regularization constrains capacity or parameter magnitude.

Cross-validation improves data efficiency in evaluation. Data leakage creates falsely optimistic evaluation. Data drift changes the input distribution.

Concept drift changes the relationship between input and target. Model decay is declining production performance over time. Data quality places an upper bound on model quality.

Synthetic data can expand coverage. Synthetic data can also reproduce or amplify distribution errors.

Reinforcement learning: state, action, and long-term return

Reinforcement learning places an agent in an environment and uses reward rather than a correct label at every step. A policy's value can be described through expected discounted return:

Bellman equations express value recursively through immediate reward and future value. Q-learning is a model-free off-policy method:

Exploration and exploitation form a central trade-off. Epsilon-greedy policies choose a random action with some probability to continue exploration. Too little exploration can lock the agent into a poor policy; too much wastes learned information.

Deep Q-Networks (DQN) approximated Q-values with neural networks and used replay buffers and target networks for stability. AlphaGo combined policy networks, value networks, and Monte Carlo Tree Search. The important engineering lesson is that learned intuition and classical search are often complementary rather than mutually exclusive.

Classical NLP, topic modeling, and semantic representation

Before large language models, NLP relied heavily on token counts, n-grams, TF-IDF, statistical language models, Hidden Markov Models, CRFs, and task-specific classifiers. TF-IDF increases the weight of terms that are discriminative for a document but not ubiquitous across the corpus. Bag-of-words largely discards word order; n-grams restore local sequence information at the cost of rapidly increasing dimensionality. Naive Bayes, logistic regression, and linear SVM were—and often remain—strong text-classification baselines.

Baselines matter because a task that can be solved reliably with a small deterministic or classical model may be cheaper, faster, and easier to audit than an LLM solution.

Topic modeling seeks latent thematic structure. Latent Dirichlet Allocation represents documents as mixtures of topics and topics as distributions over words. Modern embedding and LLM workflows can produce more flexible semantic clusters and theme descriptions, but stability and reproducibility must still be measured separately from how persuasive the generated label sounds.

In embedding-based clustering, representation, distance metric, clustering algorithm, and human theme interpretation are distinct layers. A well-written theme name does not prove that the clusters are statistically stable or useful.

2012–2016: the renewed rise of deep learning

After 2012, data, accelerator hardware, and end-to-end representation learning matured together. The rise of deep learning was not one algorithmic event but the convergence of these conditions. (LeCun, Bengio & Hinton, 2015)

AlexNet's ImageNet result made the combination of large labeled datasets, GPU computation, and deep convolutional networks highly visible. CNNs use shared filters to detect local structure, while pooling or stride can reduce spatial resolution. Deeper layers can learn more abstract representations, although the familiar story “edges first, objects last” is only an intuition; real representations are distributed and data-dependent.

By the time I prepared the 2016 version of these notes, deep learning had become a central path for image, audio, and speech processing. In my own work, this did not make classical signal processing obsolete. Fourier transforms, filters, cepstral features, and geometry still provide physically meaningful structure; learned models add the ability to optimize representations for a task.

My Image and Audio Processing material and From Spectrum to Cepstrum in Audio Processing develop that connection in more applied form. GANs, introduced in 2014, trained a generator and discriminator adversarially. Variational Autoencoders (VAE) provided another probabilistic latent-variable route to generation. “Generative model” therefore means much more than a conversational chatbot; it includes broad families that model the distribution or latent structure of observed data.

2017: the Transformer changes sequence modeling

The 2017 paper Attention Is All You Need proposed a Transformer architecture centered on self-attention instead of recurrence. Each token is projected to query, key, and value vectors. Query–key similarity controls attention weight; values carry the content that is mixed:

Attention(Q,K,V) = softmax((Q * K^T) / sqrt(d_k)) * V

The scale factor helps prevent dot products from becoming numerically too large before softmax. Multi-head attention learns several projection spaces in parallel, enabling different relational patterns to be represented simultaneously. Individual heads are not guaranteed to map neatly to human labels such as “syntax” or “coreference,” but specialization can emerge.

Attention alone does not encode sequence order. Positional encodings or embeddings provide location information. The original Transformer used sinusoidal encoding; later systems adopted learned positions, relative biases, and Rotary Position Embeddings (RoPE).

RoPE encodes relative positional structure by rotating query and key components and has become common in long-context models. Encoder-only architectures use bidirectional context and are well suited to representation and classification. Decoder-only architectures use causal masking and autoregressive next-token prediction.

Encoder–decoder architectures separate source encoding from target generation for sequence-to-sequence tasks. BERT is a canonical encoder-style model, GPT-style systems are decoder-only, and T5 is a well-known text-to-text encoder–decoder model. The Transformer scales well on modern accelerators because many sequence operations can be parallelized during training.

Standard self-attention, however, grows roughly quadratically in time and memory with sequence length. A large context window is therefore a capability, not free memory and not a reason to put every document into every prompt. The site Wiki contains shorter entries for Transformer, Attention, Tokenization, and Embedding.

Tokenization, embeddings, and the actual unit of LLM computation

The natural compute unit of an LLM is usually the token, not the word. A token may be a word, subword, punctuation mark, or byte-derived fragment. Byte Pair Encoding (BPE) builds a variable-length vocabulary by repeatedly merging frequent symbol pairs. SentencePiece learns subword units without assuming whitespace-separated words.

In multilingual systems, tokenization affects cost and context capacity because different languages may require different numbers of tokens to represent equivalent meaning. Embeddings map discrete items into continuous vector space. Similar usage contexts may produce nearby vectors, but vector proximity is not identical to real-world semantic identity.

Cosine similarity emphasizes direction, while dot product can incorporate both direction and magnitude. Higher embedding dimension can capture richer distinctions at the cost of storage, memory bandwidth, and index size. A bi-encoder represents query and candidate separately, allowing candidate vectors to be precomputed for scalable retrieval.

A cross-encoder processes the pair jointly and can model richer interactions but is much more expensive. A common architecture uses a bi-encoder for recall and a cross-encoder for reranking.

2018–2022: foundation models, in-context learning, and scale

BERT, GPT-2, T5, and increasingly large pretrained models shifted the field away from training every task from scratch. Broad pretraining followed by downstream adaptation became a standard pattern. GPT-3 made few-shot and in-context learning especially visible: a model could infer task format from examples supplied at inference time without changing its weights.

Scaling-law research found regular relationships among model size, data, and compute. Scale is not a guarantee. Data quality, deduplication, training objective, architecture, post-training, and evaluation design matter. Double descent showed that modern highly parameterized systems can violate the simplest textbook bias–variance curve. Emergence should also be used carefully: some capabilities appear abruptly under particular metrics, while continuous underlying trends and thresholded evaluation can create part of the apparent discontinuity.

A Large Language Model estimates probability distributions over token sequences at very large scale. For a decoder-only model, the core objective can be summarized as:

P(x_t | x_1, x_2, ..., x_(t-1))

A simple training objective can nevertheless create rich distributed representations of syntax, semantics, style, facts, and task patterns. Model weights are not a relational database of verified propositions, so parametric memory should remain conceptually separate from auditable external sources.

Prompt engineering: from instruction wording to experiment design

A prompt defines the runtime task and context. Good prompts do not have to be long. Objective, necessary context, output schema, constraints, and a few representative examples often form a useful structure.

Few-shot examples can demonstrate task form; poor examples can teach an unwanted pattern. Where structured output is required, schema- or grammar-constrained generation is stronger than a natural-language request to “please return JSON.” Syntax-valid JSON can still violate business rules, so a second validator remains necessary. Because external documents can contain prompt injection, the system architecture—not just prompt wording—must define the boundary between instruction and untrusted data.

Prompt changes should be versioned like code changes because they can materially change model behavior. An eval result is stronger evidence than “the new prompt looks clearer.”

Post-training: SFT, instruction tuning, preference optimization, PEFT, and distillation

Pretraining creates broad statistical capabilities; product behavior typically depends on post-training. Supervised Fine-Tuning (SFT) learns from input–output pairs. Instruction tuning uses diverse natural-language tasks to improve general instruction following. Preference optimization learns from ranked or comparative feedback. RLHF is historically important, but alignment is broader than RLHF: DPO-like methods, retrieval constraints, tool policy, deterministic validation, and product-level guardrails also shape behavior. Full fine-tuning updates most or all weights and can be expensive. Parameter-Efficient Fine-Tuning (PEFT) updates smaller parameter subsets or adds lightweight trainable modules.

LoRA approximates weight updates with low-rank matrices. QLoRA combines low-rank adaptation with a quantized frozen base model to reduce memory requirements. None of these methods is universally superior; data quality, task behavior, latency, deployment, and lifecycle management determine the choice.

Distillation trains a smaller student to imitate a larger teacher, sometimes using soft distributions rather than only hard labels. Its purpose is to preserve enough task behavior while reducing latency, memory, and serving cost. Distillation and PEFT solve different problems: distillation creates a smaller model, while PEFT adapts an existing one efficiently.

Fine-tuning does not automatically solve a retrieval problem. Frequently changing facts or information requiring citations often belong in external retrieval rather than in model weights. The disciplined engineering question is: which layer closes the measured behavior gap at the lowest lifecycle cost?

Retrieval and RAG: connecting the model to external evidence

Retrieval-Augmented Generation combines generation with evidence fetched from external sources:

question
-> query normalization / rewriting
-> retrieval
-> candidate documents
-> reranking
-> context assembly
-> LLM
-> cited answer / abstention

Lexical retrieval such as BM25 responds strongly to explicit term overlap. Dense retrieval uses embeddings to recover semantic similarity. Hybrid retrieval combines the two, which is valuable when exact identifiers, legal clauses, product names, abbreviations, and paraphrases coexist.

Rank-based fusion methods such as Reciprocal Rank Fusion (RRF) can merge heterogeneous rankings without directly comparing raw score scales. Chunking defines the unit of retrieval. Large chunks carry context but also noise; small chunks improve precision but can lose necessary context.

Structure-aware chunking by headings, paragraphs, list items, or code blocks often preserves document meaning better than fixed lengths alone. Overlap can reduce boundary loss at the cost of index growth and duplicate evidence. Metadata filters apply language, date, document type, product, department, or authorization boundaries before semantic ranking.

They are often a cheaper and more reliable improvement than training a new embedding model. A vector database is retrieval infrastructure, not intelligence. Approximate nearest-neighbor methods such as HNSW trade a small amount of recall for much lower latency at large scale.

Rerankers apply a more expensive relevance model to a short candidate list. Bi-encoder retrieval followed by cross-encoder reranking is a common pattern. Query rewriting can improve short or ambiguous queries, but a mistaken rewrite becomes a new failure mode, so the original query and transformation should remain observable.

RAG does not guarantee correctness. A wrong document can be retrieved, a correct document can be misinterpreted, stale evidence can be selected, or unauthorized material can enter the context. Freshness, provenance, citations, access control, and abstention are part of the RAG system.

The Wiki entries for Retrieval-Augmented Generation, Reranking, Vector Database, Approximate Nearest Neighbor, and HNSW provide shorter reference definitions.

Optimization mathematics: softmax, cross-entropy, KL, gradients, and Jacobians

Softmax maps scores to a normalized distribution:

softmax(z_i) = exp(z_i) / sum_j exp(z_j)

In attention it turns query–key scores into weights; in classification it turns logits into probability-like values. Implementations use numerical-stability transformations such as subtracting the maximum logit. Cross-entropy measures mismatch between target and model distributions and is closely related to negative log-likelihood for one-hot targets.

KL divergence compares distributions asymmetrically and is not a metric. It appears in distillation, variational methods, and preference learning. A gradient gives the local sensitivity of a scalar objective to parameters.

A Jacobian generalizes derivatives to multiple outputs and inputs; a Hessian represents second-order curvature. Full Hessians are rarely computed for large neural networks, but conditioning and curvature remain useful concepts for understanding optimization. Mixed precision, gradient accumulation, and optimizer state show that optimization mathematics is inseparable from memory and hardware.

Decoding: turning a distribution into text

An autoregressive model produces a probability distribution for the next token at each step. Greedy decoding takes the highest-probability token. Beam search maintains multiple candidate sequences and can improve constrained sequence tasks such as translation, but costs more and can reduce diversity in open-ended generation.

Sampling draws from the predicted distribution.

Temperature rescales logits and changes how sharp or diffuse sampling becomes. Lower values tend to produce more deterministic output; higher values produce more diversity. Exact ranges are implementation-specific. top-k restricts sampling to the k highest-probability tokens. top-p, or nucleus sampling, selects the smallest set whose cumulative probability reaches p. max_tokens is also a cost and latency control.

These parameters are not magical creativity knobs. Extraction, classification, and structured-output tasks usually prefer lower variance than brainstorming or creative writing. Even temperature=0 does not necessarily guarantee bit-for-bit determinism across model versions, distributed kernels, or infrastructure changes.

Serving: latency, throughput, streaming, batching, and KV cache

Users experience several forms of latency: time to first token, token generation rate, end-to-end time, and tail latency. Streaming sends partial output as tokens become available and improves perceived responsiveness, while introducing cancellation, partial-output, and error-policy questions. Batching improves accelerator utilization by serving multiple requests together.

Large batches can increase throughput while delaying individual requests. Continuous batching dynamically combines active sequences of different lengths to improve utilization. Interactive assistants and offline batch inference therefore optimize different objectives.

During autoregressive decoding, prior key and value tensors would otherwise be recomputed repeatedly. The KV cache stores them. It accelerates generation at the cost of memory that grows with sequence length, layer structure, and concurrency.

This is one reason long-context serving is expensive.

Quantization uses lower numerical precision for weights and sometimes activations. FP32, FP16, BF16, FP8, INT8, and INT4 occupy different quality–efficiency points. Aggressive quantization can reduce task fidelity. “The model fits in memory” is not the same as “the model preserves acceptable quality on the target workload.” See KV Cache, Quantization, and GPU Acceleration.

Hardware: CPU, GPU, TPU, NPU, and the memory wall

AI is described mathematically but runs on physical machines. SIMD applies one instruction to multiple data elements; SSE, AVX, AVX2, AVX-512, NEON, and SVE are examples. GPUs organize many simpler execution units for high data parallelism.

In SIMT-style execution, branch divergence inside a warp or wavefront reduces efficiency. TPUs are data-center accelerators designed for tensor-heavy workloads. NPU is a broader class of low-power neural inference accelerators often used in edge or client devices.

An NPU is not an “electronic brain”; it is specialized numerical hardware. Peak TFLOPS or TOPS does not describe full application performance. The Roofline model bounds performance by compute throughput and memory bandwidth times arithmetic intensity:

Performance <= min(PeakCompute, MemoryBandwidth * ArithmeticIntensity)

Amdahl's law shows why accelerating only one fraction of a program limits total speedup:

Speedup = 1 / ((1 - p) + p / s)

In LLM inference, prefill is typically more parallel and compute-heavy, while decode is more sequential and often memory-bandwidth-sensitive. Cache locality, NUMA placement, memory bandwidth, and data layout can dominate large embedding and KV-cache workloads. My Computer Architecture: Instruction Sets, Pipelining and Memory Systems and IBM POWER9 AC922 for Digital Forensics and Artificial Intelligence notes develop the physical-computing side further.

Apple Silicon's unified memory is one example of how CPU/GPU data movement can change under a different architecture. Metal, MPS, and MLX expose different levels of acceleration. The persistent lesson is not the product name but that framework, compiler, runtime, memory model, and hardware jointly determine performance.

Programming languages, compilers, and heterogeneous compute

Python dominates experimentation, orchestration, and scientific libraries. Performance-critical kernels often execute in C, C++, CUDA, or generated accelerator code. Rust offers a different point in the design space around memory safety and systems programming.

Mojo is a newer language attempting to combine Python-like productivity with low-level performance and heterogeneous hardware targeting; production maturity should be evaluated independently from language goals. MLIR provides multiple intermediate-representation levels for lowering high-level tensor operations toward target hardware. XLA, TVM, Triton, and vendor compiler stacks similarly sit between user model code and machine kernels.

A line of Python can therefore trigger substantial compiled execution, making source-language syntax a poor predictor of runtime performance.

The 2020s: AI begins to search for algorithms as well

AlphaTensor used reinforcement learning to search for matrix-multiplication factorizations for specific sizes. AlphaDev searched instruction-level implementations for sorting and hashing routines. These results do not mean that AI “solved complexity theory.” Finding a better algorithm under a particular size, instruction set, or cost model is different from changing a general asymptotic lower bound.

Big-O describes upper-growth behavior, Big-Omega lower growth, and Big-Theta a tight asymptotic class. Comparison-based sorting is constrained by an Omega(n log n) lower bound in the general comparison model; counting and radix methods change the model by using additional assumptions about keys. P, NP, NP-hard, and NP-complete also have technical meanings beyond “easy” and “hard.” Whether P equals NP remains open in 2026.

This connects directly to Data Structures and Algorithm Analysis and to my earlier work on sorting, subset-sum, Huffman coding, and substring algorithms. AI can accelerate algorithm search; discovered candidates still require independent proofs, tests, complexity analysis, and real-hardware measurement.

III. Practical and Systems-Engineering History

2022–2026: from model to system, from system to agent

A large language model is not a production system by itself. After 2022, much of the engineering progress appeared in the integration of models with retrieval, memory, tools, state, and verification.

Early LLM applications often had a simple architecture: prepare a prompt, send it to a model, receive text. Within a few years, retrieval, tool calling, memory, state, retries, authorization, validation, and evaluation accumulated around the model. The question “which model?” still matters, but it no longer describes the system.

A useful production principle is to treat the LLM as a probabilistic proposal generator rather than as the direct authority over real-world state. For side-effecting systems, a three-layer design provides a strong baseline:

1. Probabilistic inference
   -> model proposal / candidate plan / candidate data

2. Deterministic validation
   -> schema
   -> business rules
   -> authorization
   -> invariants
   -> accept / reject

3. Controlled execution
   -> idempotent operation
   -> bounded impact
   -> logging
   -> rollback / compensation

This distinction is valuable in digital forensics, finance, public systems, manufacturing, health, and security. A model sounding confident is not a reason to bypass validation. Silently “fixing” a bad proposal and then executing it can also be dangerous because it blurs which decision came from the model and which from the validator.

Context engineering: what should the model see, and when?

Prompt engineering is not simply the art of writing elegant instructions. A broader context engineering view became increasingly important in the 2024–2026 period: what information, tools, state, ordering, and budget should the model receive? A large context window can still be filled with irrelevant material, stale failed attempts, or duplicated evidence.

Longer context is not automatically better context. It helps to separate context into layers. System policy and tool definitions are relatively stable.

Shared reference material changes less frequently. Conversation history grows dynamically. The current task and latest tool results change most often.

Keeping stable prefixes early and dynamic content later can also improve prompt caching and traceability.

Preloading works when a small body of information is almost always needed. Just-in-time retrieval is better when a large corpus is only sparsely accessed. Progressive disclosure supplies metadata or summaries first and reveals full detail only when needed, reducing token cost and unnecessary exposure of sensitive data.

Long sessions need compaction. Compressing old history into a smaller representation saves context, but a free-form summary can lose facts. Durable decisions, identifiers, permissions, file paths, and validation results should therefore live in structured state rather than only in conversational summary.

Agent memory can be separated into parametric memory in model weights, short-term working memory in active context/state, and long-term external memory in databases, files, vector stores, or event logs. “The weights do not change” and “the system has no memory” are not equivalent statements. Subagents are also a context-management technique. A main agent can delegate research, review, or a narrow specialist task instead of ingesting every source itself.

Information loss is lower when the subagent returns evidence, file references, exact citations, or structured results rather than a loose summary. Multi-agent value comes from well-bounded parallel work, not from agent count alone. The Context Engineering entry summarizes the concept in shorter form.

Token economics and prompt caching

Token cost is not merely billing; it affects latency and capacity. Prompt length drives prefill cost, while output length drives decode cost. If a stable prefix repeats across many requests, prompt caching can reduce repeated computation.

Cache hit rate, TTL, prefix stability, and model version should still be monitored. Caching has architectural consequences. A prompt with stable policy, tool schemas, and shared references followed by dynamic task content is easier to reuse.

But a cache must never become a reason to keep stale policy or outdated tool definitions. Caching is a performance mechanism, not a correctness mechanism. Token economics becomes even more important in multi-agent systems.

Sending the same long document to three workers can roughly triple context processing. Parallelism can reduce wall-clock time while increasing total compute. Each delegated task should therefore have a measurable expected benefit.

Tool design: the contract between model and computer

• In tool calling, the model does not interact directly with an API; it interprets the tool contract.
• Tool names, descriptions, parameter schemas, error models, and response structure all influence behavior.
• Clear functions such as search_records, get_record, and update_record may be safer than one vague all-purpose tool.
• Hundreds of tiny functions can create the opposite problem by overwhelming selection.
• Function consolidation and namespacing should be evaluated against real workloads.
• Tool responses return to context, so response design is part of token budgeting.
• A tool that dumps tens of megabytes of logs is not useful.
• Pagination, truncation, server-side filtering, and field selection should be built in.
• If a result says not only “1,000 records found” but also provides a cursor, limit reason, or suggested narrowing field, the agent can plan the next step more reliably.
• An error response is information to the agent.
• Machine-readable categories such as permission_denied, validation_failed, rate_limited, not_found, and conflict make retry and escalation policies more predictable.
• Raw stack traces can waste tokens and leak information.
• Tool development benefits from eval-driven design.
• Build a small set of representative tasks and measure whether the model chooses the right tool, fills arguments correctly, avoids unnecessary calls, and recovers appropriately after errors.
• Changing a tool schema is therefore a model-behavior change, not merely an API refactor.
• When hundreds of tools exist, exposing every schema in every prompt wastes context. Tool search or progressive tool disclosure allows the model to search a catalog and load detailed schemas only for relevant tools.
• That reduces context at the cost of introducing a new discovery stage that itself requires evaluation.
• Programmatic tool calling can let a model orchestrate many calls through a controlled code fragment rather than narrating every step.
• The generated code should not run in an unrestricted environment.
• Sandbox boundaries, allowlists, CPU/memory/time limits, and network policy belong to the execution layer.

Reasoning budgets and auditability

Some modern model products expose additional inference compute through features called reasoning budgets, thinking modes, or similar names. The persistent engineering question is not the branding but the trade-off between additional inference, quality, latency, and cost. A model's private reasoning process should not be treated as a trustworthy audit log.

A production audit trail should record inputs, model and version, parameters, retrieval sources, tool calls, validator results, final decisions, and side effects. Free-form internal reasoning is neither a deterministic execution trace nor a substitute for external evidence. It is useful for an agent to revise plans after tool results arrive.

The general pattern is:

plan
-> tool
-> observation
-> update plan
-> next tool
-> validate

The same power creates the risk of accumulated error. Maximum steps, budgets, timeouts, and stop conditions should be explicit.

Five recurring workflow patterns

• Several reliable LLM application patterns exist even before we call a system an “agent.”

Prompt chaining splits a task into sequential, independently inspectable stages. One stage may extract structured fields, the next validate them, and the final stage generate a report. It improves localization of errors but adds latency.

Routing classifies the input and sends it to an appropriate model, prompt, or workflow. Simple requests can use a smaller model, complex ones a more capable system. Router errors can silently degrade quality, so confidence thresholds and fallbacks matter.

Parallelization runs independent subproblems simultaneously. Security, correctness, and style review can run in parallel, or multiple candidate solutions can be generated for later selection. Parallelism reduces wall-clock time while increasing cost and aggregation complexity.

Orchestrator–workers is useful when subproblems are not known in advance. A higher-level model decomposes a repository investigation, literature search, or large research task and assigns workers dynamically. Persisting the plan as state makes long tasks restartable.

Evaluator–optimizer uses an evaluation stage to critique and improve an output. When deterministic validators exist—compiler, schema validator, unit test, proof checker—they should take precedence over purely model-based critique.

Autonomous agent loops and state management

An agent differs from a fixed workflow when the model chooses control flow at runtime. A general loop is:

goal
-> observe state
-> choose action
-> call tool / act
-> observe result
-> update state
-> stop or continue

For short tasks this is simple; for long-horizon work, error accumulation becomes central. If each dependent step is highly but not perfectly reliable, the probability that every step succeeds decreases with task length. Checkpoints, invariants, retry policies, compensation, and bounded autonomy are therefore required.

Agent state should not be identical to raw conversation history. Completed subtasks, unresolved risks, evidence sources, changed files, test results, and remaining budget can be stored explicitly. This prevents operational facts from disappearing when context is compacted.

Durable execution decouples the task from one process lifetime. A long job can resume from a checkpoint after a restart. Side-effecting actions need idempotency keys to prevent duplicates.

Non-idempotent operations may require compensation or explicit human approval. A purely synchronous loop can become bottlenecked by I/O. Independent tool calls can run asynchronously or in parallel, but concurrent state mutation can create race conditions.

Parallelism is safe only where independence is understood.

Multi-agent systems

A multi-agent system is not simply “one model but smarter.” It is a division of work among agents with separate contexts, roles, or tool permissions. One agent may search sources, another modify code, another verify citations, and another perform risk review. Good delegation specifies an output contract.

Which files may a worker modify? Which sources are acceptable? What evidence must it return?

When should it stop instead of improvising? The orchestrator can validate the contract before accepting a result. The telephone-game problem appears when one agent's free-form summary becomes the next agent's only source.

File references, structured artifacts, exact citations, and test outputs preserve evidence better. In long-horizon systems the key question becomes not “what did the agent say?” but “which artifact passed which validation?” State-changing agents require more than text-quality evaluation.

An eval may need to assert that the agent did not modify an unrelated file, did not call an unauthorized API, remained idempotent under retries, and returned to a safe state after failure. See AI Agent and Multi-Agent System for compact definitions.

Advanced retrieval and agentic search

Classical RAG preprocesses a corpus into chunks and retrieves top-k results from fixed indexes. Agentic search can choose, at query time, which source to search, which subquery to issue, and whether another search round is necessary. This is powerful for heterogeneous corpora but increases latency, cost, and reproducibility complexity.

Contextual retrieval enriches a chunk with information about its location in the source document. This can help when a passage contains local references that make little sense in isolation. Automatically generated context can also be wrong, so it becomes another indexed artifact that must be evaluated.

Hybrid search combines dense and sparse retrieval. Raw scores are not always comparable, which motivates rank-fusion methods. Reranking is expensive, so the retrieval candidate count, reranker count, and final context count should be separate tunable parameters.

Retrieving 100, reranking 20, and passing 6 is a different system from retrieving 6 directly. Retrieval should be evaluated at its own layer. Recall@k asks whether relevant evidence reached the candidate set.

MRR measures where the first relevant result appears. nDCG handles graded relevance. Generation-level metrics such as groundedness, citation correctness, and answer completeness come afterward.

Separating retrieval failure from generation failure prevents teams from optimizing the wrong component. Citations also deserve their own validation. A list of URLs at the end of an answer does not prove that each claim is supported.

In academic or forensic systems, the relation between a claim and a specific evidence span should be inspectable.

Model Context Protocol and standardized tool interfaces

Model Context Protocol (MCP) is an open interface approach for connecting model/agent applications with external tools and resources. Its value is not that it eliminates integration code, but that it can standardize capability discovery and the client–server boundary.

Tools, resources, and prompts represent different kinds of capability. A tool may perform side effects. A resource may expose data. A reusable prompt is a template. These distinctions should map to authorization. Reading a resource and initiating a financial transfer must not share the same permission semantics.

Local processes can use stdio-like transport; remote systems can use HTTP-based transport. Transport and security are linked through authentication, token scope, TLS, origin policy, and session handling. Exposing hundreds of MCP tools at once can recreate the context-overload problem, so tool search and progressive disclosure remain useful.

Code execution layered over MCP can orchestrate many tool calls efficiently, but sandboxing is essential. Filesystem, network, secrets, and process limits must be controlled externally. Privacy-preserving designs should filter, aggregate, or redact data server-side when the model does not need raw values.

Persistent state and “skills” sit above the protocol. An agent can store reusable procedures or remember earlier work, but memory should have provenance, expiry, and authorization. See Model Context Protocol.

Agentic coding: from code generation to an engineering loop

A one-shot request such as “implement this feature” can produce a fast prototype, but large repositories contain hidden behavior, tests, compatibility constraints, and operational invariants. A safer agentic-coding loop looks like this:

research
-> understand existing behavior and dependencies
-> write a change plan
-> implement in small steps
-> compile / test / run static analysis
-> inspect the diff
-> benchmark or check acceptance criteria
-> accept or revert

The human role is not reduced to prompt writing. Problem selection, invariants, and the definition of acceptable evidence remain supervisory responsibilities. Senior engineering value increasingly lies in knowing which changes should not be made and which existing behavior must be preserved.

Repository-level agent instruction files can support this workflow. File names differ across tools, but the durable pattern is to keep stable project constraints under version control rather than depending on conversational memory. If a requirement can be enforced by a deterministic hook, build check, or CI rule, that is stronger than relying on natural-language instruction alone.

Skills can package reusable procedures, hooks can enforce deterministic actions at lifecycle points, and subagents can isolate context and responsibilities. Security and compliance constraints should, where possible, be implemented through hooks, sandbox policy, filesystem restrictions, and CI rather than model compliance alone. Session management affects context quality.

After repeated failed approaches, preserving every failed attempt in the active context can make the next attempt worse. Record validated findings and restart from a cleaner context when appropriate. Prompt, tool, and model versions should also be pinned for long-lived sessions when reproducibility matters.

Parallel coding agents can work in separate branches or worktrees. A writer/reviewer pattern separates implementation from review. Adversarial review is useful when the reviewer is asked to find concrete violations of acceptance criteria, not merely to invent style complaints.

Common agentic-coding failures include endless exploration, unnecessary large refactors, rewriting working behavior before understanding it, changing tests to match bad output, altering benchmark conditions, leaking secrets into logs, and retrying the same failed idea with cosmetic changes. A good harness constrains these behaviors through budgets, tools, and validation. This engineering loop intersects directly with my Software Test Engineering, Secure Software Engineering, and MISRA C and Static Code Analysis notes.

AI can propose code; compilers, tests, static analyzers, profilers, and security policy generate independent evidence about that code.

AI for performance-critical software

Performance work can be a good fit for agentic development because profilers and benchmarks provide fast feedback. A benchmark is useful only when its conditions are sound. Acceptance criteria may need throughput, P95/P99 latency, memory, CPU/GPU utilization, and error rate rather than a single average time.

A measured improvement smaller than benchmark variance is not evidence of a real speedup. Warm-up, JIT behavior, CPU frequency, NUMA affinity, cache state, input distribution, and background load should be controlled. A time series is usually more informative than one isolated run.

Profiler output gives the model evidence about hot functions, allocations, cache misses, and lock contention. Source-only guesses such as “parallelize this function” can be wrong because Amdahl's law, memory bandwidth, or synchronization can dominate the full system. Proven algorithmic behavior should be preserved.

If an optimization was already rejected because it produced incorrect output, nondeterminism, or a race condition, the reason should live in an ADR, test, benchmark note, or project policy. Otherwise a future agent may rediscover and reintroduce the same failure. CI performance gates can keep fast AI-assisted development from producing fast regressions.

Thresholds must exceed normal benchmark noise and should be calibrated on representative hardware. Native-image and ahead-of-time systems also require explicit validation of reflection, dynamic proxies, resource discovery, and other closed-world constraints.

Production reliability: calibration, drift, verification, and change management

Production success cannot be reduced to benchmark scores. Even with a fixed model, changes in data, retrieval, prompts, tools, or authorization can change system behavior. Evaluation, observability, and change management therefore belong to one engineering problem. (NIST, 2023)

Schema-valid output is not necessarily semantically correct. Model confidence is not the same as empirical correctness. Calibration measures that gap.

Thresholds should be selected against operational cost. Drift should be monitored in data sources as well as model metrics. A broken data contract can break the system even when the model is unchanged.

A prompt change is a version change. A retrieval-index change is a version change. A tool-schema change is a version change.

A model file belongs to the software supply chain. Unsafe serialization formats can carry code-execution risk. Model supply-chain controls include source, hash, signature, license, dependency, and provenance.

Data poisoning targets training data. Knowledge-base poisoning targets retrieval sources. Prompt injection collides instructions with untrusted data in the same context.

Indirect prompt injection can arrive through retrieved content. Least privilege limits blast radius. Tool permissions should distinguish read, write, and side effects.

Automatic retry belongs only to idempotent or explicitly safe operations. A failure budget quantifies tolerated system failure. Production SLOs are broader than accuracy.

Latency, availability, abstention, citation correctness, cost, and security can all be measured. A reproducibility manifest records model, data, prompt, retrieval, tool, and code versions. Change management requires regression tests for each layer.

Evals: from model testing to system evaluation

Unit tests are ideal when one input has one deterministic expected output. LLM tasks can have multiple acceptable phrasings, so exact string comparison is often insufficient. Evals define task-specific success over a representative workload.

A small, well-reviewed eval set can be more valuable than a huge generic benchmark. Start with the most important real tasks, define expected properties, then expand coverage. Repeatedly optimizing the same prompt against the same visible eval set causes evaluation overfitting; hidden or periodically refreshed tasks are useful.

LLM-as-judge scales open-ended assessment but introduces another model. Position bias, verbosity bias, self-preference, and domain error are possible. Rubrics, pairwise comparison, blinded ordering, and calibration against humans reduce risk.

Where a compiler, unit test, schema validator, or theorem checker exists, the deterministic validator should not be replaced by a model judge. Human evaluation remains important for semantic qualities such as usefulness, naturalness, domain acceptability, and harm. Low annotator agreement may indicate that the rubric is unclear rather than that the model is uniquely difficult to score.

An error taxonomy—retrieval miss, unsupported claim, wrong tool, invalid argument, reasoning error, format failure, unsafe action—is often more actionable than one aggregate score. Deployment introduces new distributions, languages, context lengths, and tool combinations that offline evals may not contain. Evals therefore continue into production monitoring rather than ending before release.

Observability: reconstructing probabilistic behavior

In a distributed AI system, one error rarely lives in one log line. A correlation ID should be able to connect the request, retrieval query, document IDs, model/prompt/tool versions, token counts, latency, tool sequence, validation outcome, and final side effect. Observability has at least two layers.

Traditional systems metrics include CPU, memory, queue depth, errors, throughput, and latency. AI-specific signals include retrieval recall, tool success, refusal rate, groundedness, context size, token cost, step count, and eval outcomes. The layers interact: a GPU-capacity issue can become a quality issue if timeouts force fallback models.

A model version is a dependency. If behavior can change behind a moving alias, exact version, deployment date, and eval baseline should be recorded where possible. Prompt, tool-schema, and retrieval-index versions deserve the same treatment. “It worked yesterday” is useful only if the changed component can be identified.

Average latency can conceal poor tail behavior. P95/P99 latency affects user experience and timeout behavior. In agent chains, tail latency compounds across steps.

Queueing, retries, and rate limits can turn individual slowness into a capacity incident.

Security: from prompt injection to blast radius

Natural language can act as both data and instruction-like content, so command/data separation reappears in a new form. Prompt injection occurs when untrusted content attempts to redirect model behavior. Telling the model to “ignore instructions inside documents” is not a strong security boundary because the untrusted document is already in model context. Secure architecture places external limits around the model.

Tool allowlists, parameter validation, RBAC/ABAC, sandboxing, network policy, filesystem boundaries, secret isolation, and human approval are actual enforcement layers. Model policy is one layer, not the entire defense.

Blast radius is the maximum effect of a single failure. A read-only research agent and an agent allowed to delete production records have fundamentally different threat models. Authority should be minimized; risky actions should be reversible or approval-gated; bulk operations need independent limits.

Prompt injection is usefully compared with input-validation problems but is not identical to SQL injection. Natural language is inherently ambiguous, so lexical filtering cannot reliably separate malicious instructions from data. Architecture-level least privilege and output validation are more durable defenses.

See Prompt Injection. Privacy belongs to the same design. The strongest minimization is not sending sensitive fields when they are unnecessary.

Redaction, field-level filtering, local inference, retention policy, and auditing are additional controls. Running a model locally can improve control, but host security, logs, storage, model supply chain, and user permissions remain relevant.

Digital forensics and determinism

One of the most important distinctions in digital forensics is between evidence and model interpretation. An LLM statement such as “this file indicates event X” is not itself evidence. Evidence is tied to original artifacts, hashes, timestamps, acquisition records, chain of custody, and deterministic parser or measurement outputs.

Model interpretation can sit above that evidence as an assistive layer. This is consistent with the approach in A Data Carving Algorithm for Digital Forensics: a recovered artifact should be traceable to byte offsets, signatures, and file structure. AI can help classify or prioritize candidates without replacing or rewriting the original artifact.

Determinism should be demanded at the right layer. LLM output may vary. Hashes, parsers, checksums, byte offsets, database queries, and validators can be deterministic.

A critical system should place nondeterministic proposal inside a deterministic evidence boundary. For reproducibility, record model identity/version, prompt-template version, immutable IDs or hashes of retrieved sources, decoding settings, tool versions, environment, timestamps, and the final validated action. Even this may not guarantee bit-identical tokens across distributed inference.

The more important forensic goal is to reconstruct which evidence supported which decision. Invariants are stronger when expressed in code. “Original evidence is immutable,” “analysis starts only after hash verification,” “the model operates on a read-only copy,” and “no external write occurs without approval” can be enforced in tests and authorization layers.

Case study: forensic audio in a closed network

A high-volume closed-network audio pipeline illustrates the boundary between probabilistic AI and deterministic engineering. Source hash, channel metadata, codec, duration, and acquisition identity are deterministic metadata. Decode, resampling, and some segmentation operations can be reproducible under pinned versions.

Speech recognition and diarization produce probabilistic inference. A defensible pipeline can look like this:

original audio
-> immutable record + hash
-> deterministic decode / channel selection
-> segmentation
-> ASR / diarization proposals
-> validation and quality checks
-> indexing / search
-> human review

Model output does not replace source evidence. Low-confidence segments can be reprocessed, compared with another model, or routed to a human queue. GPU/CPU routing, batch size, INT8/FP16 precision, and model choice should be evaluated separately for recognition quality and latency.

When the recording format already provides reliable channel semantics, using physical channel information for speaker separation can be safer than introducing an unnecessary diarization model. This is a useful counterexample to the idea that every stage should become “AI-powered.” Deterministic information already present in the problem should be used first.

Case study: enterprise document question answering

In enterprise RAG, the first problem is not embedding choice. The system must know which documents a user may access, which version is current, which metadata is trustworthy, and which source supports an answer. An ingestion pipeline parses documents, cleans them, chunks them along structural boundaries, attaches metadata and ACLs, computes embeddings, and builds lexical/dense indexes.

At query time, user identity becomes authorization filters; hybrid retrieval generates candidates; a reranker narrows them; a context assembler selects evidence; the model generates an answer; and a citation validator checks the claim-to-source relation. The system therefore has multiple quality questions: did unauthorized evidence enter context? Was a stale version selected?

Does the citation actually support the claim? Was the right document present in top-k? Does the system abstain when evidence is insufficient? “The answer looked correct” is only one of many checks.

Formal verification, testing, and AI-assisted software

In high-risk software, probabilistic generation cannot replace verification. Models can propose; compilers, tests, static analysis, formal methods, and independent review support acceptance or rejection. This separation is consistent with safety-oriented traditions such as MISRA C and DO-178C. (MISRA, 2012; RTCA, 2011)

Testing executes example behaviors. Formal verification seeks mathematical guarantees for specified properties. Model checking explores a state space against properties.

SAT/SMT solvers can support verification. Static analysis searches for defects without executing the program. A compiler can serve as a strong oracle for type and language constraints.

Unit tests check local contracts. Integration tests check component boundaries. Property-Based Testing generates cases from properties rather than only fixed examples.

Mutation Testing intentionally alters code to measure whether the test suite detects faults. The best oracle for model-generated code is not another language model alone. Compilers, tests, static analysis, benchmarks, and expert review are stronger together.

Performance regression matters as much as functional regression in generated code.

Image, audio, and multimodal AI

Multimodal systems combine text with images, audio, video, and sensors. The underlying problems are older than the label: sampling, quantization, noise, representation, feature extraction, alignment, and timing. An image is a sampled spatial signal; audio is a sampled pressure waveform over time.

AI operates on top of that physical measurement chain. In vision, filtering, edge detection, segmentation, feature descriptors, object detection, face detection, OCR, depth estimation, and generation are distinct tasks. In audio, spectrum/FFT, cepstrum, voice activity detection, segmentation, ASR, speaker recognition, and diarization are distinct layers.

Combining all of them under “multimodal AI” can hide engineering boundaries. My Image and Audio Processing series divides the topic further into Image Feature Vectors and Matching, Image Segmentation, Visual Pattern and Text Recognition, Audio Feature Vectors and Matching, Audio Segmentation, Automatic Speech Recognition, and Speaker Recognition and Diarization. Natural Language Processing and Multimedia connects language modeling with the broader multimedia pipeline.

The 2022 book chapter Image and Audio Processing — Book Chapter, published by Nobel Academic Publishing, is one academic source for the data–perception–representation line developed here.

Relation to secure software, testing, and static analysis

AI safety is not only the alignment literature. Classical secure-software and reliability principles still apply. Threat modeling, least privilege, secure defaults, input validation, output encoding, dependency management, and incident response remain relevant.

A tool-using AI agent is a privileged software component and should be designed accordingly. In Secure Software Engineering, I discuss how losing the boundary between data and command produces multiple injection classes. Prompt injection uses a different mechanism but leads to a similar architectural lesson: untrusted content should not receive authority merely because a model can interpret it.

From the perspective of Software Test Engineering, testing AI is not limited to model benchmarks. Requirements, unit/integration/system tests, property-based tests, fault injection, load tests, security tests, and production monitoring continue to matter. Model evals add another layer to that assurance structure.

MISRA C and Static Code Analysis provides another reminder from safety-critical software: compliance with rules, a clean static-analysis report, or an LLM review is not equivalent to functional correctness. Compiler warnings, static analysis, tests, runtime monitoring, and target-platform behavior all contribute to an assurance case.

AI-assisted scientific research

AI can help with literature discovery, document classification, code generation, data cleaning, hypothesis exploration, and scientific writing. The major risks are fabricated citations, incorrect quotations, and persuasive synthesis that is difficult to verify. A healthier research workflow separates model synthesis from source records:

research question
-> bibliographic search
-> source selection
-> full-text reading
-> notes / data extraction
-> analysis
-> AI-assisted synthesis
-> verify again against sources

Product names can change; the durable method is to verify existence, DOI, publication venue, and the specific claim against the primary source. They do not guarantee that a PDF was parsed correctly or that a figure, table, or citation was understood. Critical quotations should be checked directly in the source.

AI in science is also more than writing assistance. Candidate generation in protein structure, materials, mathematics, algorithms, and experimental design becomes particularly valuable when an independent verifier is cheap. A theorem prover, compiler/test suite, laboratory experiment, or physical measurement closes the loop between generated hypothesis and evidence.

AI as a sociotechnical system

An AI system is not merely a model. At minimum, it includes data, model/algorithm, software infrastructure, human organization, and legal/social environment. Failure in one layer can be amplified by another.

Bias can enter through sampling, labels, measurement instruments, target selection, deployment populations, and human decisions, not only through model weights. Fairness metrics can conflict; choosing a fairness criterion is partly a normative decision.

Automation bias occurs when people over-trust automated recommendations. Fluent explanations can intensify the effect. Interfaces should avoid overstating confidence, should expose sources and uncertainty, and should give decision-makers independent evidence in high-risk contexts.

The jigsaw effect occurs when individually low-sensitivity data points become identifying or sensitive when combined. Privacy design cannot ask only whether each field is harmless in isolation. Data minimization, purpose limitation, and retention constraints matter.

Synthetic data can reduce some privacy or scarcity problems but can reproduce the same biases as the source distribution. Deepfakes and synthetic media increase the importance of provenance and verification. “Generated by AI” does not automatically mean false; unsupported and unverifiable content is the real reliability problem. Environmental cost should not be summarized with one universal “water or carbon per query” number.

Hardware, data-center efficiency, electricity mix, model architecture, batching, token count, and utilization vary. More meaningful metrics include joules/request, Wh/task, GPU-hours, utilization, and regional carbon intensity.

Learning, cognitive offloading, and expertise

Humans have always offloaded memory into writing, books, calculators, and search engines. AI is another step in that history. Cognitive offloading is not inherently harmful.

The problem is when the tool removes the learning stimulus entirely. A learner may show high assisted performance while using AI but still have low acquired competence when the tool is removed. Education should distinguish the two.

Retrieval practice, spacing, active recall, and direct problem solving remain important even when information access is cheap. Expertise is not simply storing more facts. It includes representing the problem quickly, recognizing misleading metrics, anticipating edge cases, and rejecting bad solutions early.

As AI automates more routine code, the value of senior judgment may shift toward problem selection, validation, architecture, and risk. The easiest software tasks to automate tend to be routine transformations, standard CRUD, boilerplate, documentation drafts, and other outputs that are easy to verify. Harder areas remain requirements ambiguity, legacy behavior, distributed failure, performance, security, hardware, regulation, and long-term maintenance.

Eliminating the junior learning pipeline entirely would also create a future expertise problem; senior engineers need somewhere to acquire real problem-solving experience. The educational rule I use is simple: let AI carry cognitive load, but do not let it remove the learning stimulus.

Measuring frontier systems in September 2026

Frontier-model rankings change too quickly for one brand or leaderboard to be durable knowledge. A stronger evaluation separates task families and system conditions. Mathematics, coding, scientific QA, visual reasoning, long-context use, tool use, and physical robotics are not one intelligence score.

Jagged intelligence is useful precisely because of this uneven profile. Benchmark performance and production reliability are different measurements.

ARC-AGI-style tasks attempt to measure few-example abstract generalization. SWE-bench-style tasks test repository issue resolution. Long-horizon agent evaluations estimate the length of human tasks a system can complete at a given success rate.

Each is useful but sensitive to contamination, harness design, tool access, retry budgets, and evaluation procedure. There is no universally accepted AGI test. Passing the Turing Test does not establish AGI; scoring a particular percentage on a benchmark does not establish human-level general intelligence.

Transfer, sample efficiency, robustness, planning, world modeling, embodiment, and autonomy form multiple axes. Consciousness remains separate from all of them. A September 2026 snapshot illustrates how quickly the frontier moves.

OpenAI positioned current frontier models for complex knowledge work, coding, science, and tool use (OpenAI, 2026a), while Google DeepMind developed the long-reasoning-budget frontier systems line for more intensive scientific and mathematical reasoning (Google DeepMind, 2026a). Research agents such as Aletheia extend the loop toward literature use, conjecture development, revision, and verification over longer horizons (Feng et al., 2026). OpenAI's Astra mathematics releases (OpenAI, 2026b) expose a second lesson: a novelty claim produced by a model cannot rest on model authority alone; machine-checkable certificates or independent expert verification are essential.

Model names will change. The durable development is the coupling of candidate generation with independent verification in one research workflow.

Unified engineering principles

• A decade of AI development can be reduced to a few durable principles.

Measure data quality before model quality. Bad labels, drift, leakage, and unauthorized sources are not fixed by a larger model.

Place probabilistic components inside deterministic boundaries. The model proposes; schemas, permissions, and invariants decide what may become an action.

Reduce authority when verification is expensive. If generation is cheap but validation is costly, error queues can grow faster than assurance capacity.

Manage authority independently from capability. A system's ability to perform an action does not imply that it should be permitted to do so.

Context is not a memory dump. Give the right information at the right time and in the right form.

Retrieval is a separate system. Chunking, indexing, filtering, reranking, authorization, and freshness need their own evaluation.

Evals belong to production testing. Workloads and behavior drift after release.

Measure tail latency. A low average can hide a system that fails at P99.

Separate immutable evidence from mutable interpretation. In forensic and high-risk domains, model interpretation should never rewrite source evidence.

Models change; physics does not. CPU, memory, networks, energy, sensor noise, timing, and control theory remain real under an AI label.

Quick decision frames

• Before using an agent, ask whether the steps are fixed, whether success is objectively checkable, whether tool use is necessary, whether mistakes are reversible, and whether control flow genuinely needs to be selected dynamically by a model.
• High-frequency, low-complexity, strict-latency, or one-shot irreversible tasks often fit deterministic workflows better.
• When choosing between RAG and preloading, consider corpus size, rate of change, fraction of information used per request, and access control.
• A small stable reference can live in context; a large changing corpus generally needs retrieval.
• A very large context window does not eliminate this trade-off.
• Automation can be viewed as levels: recommendation only; recommendation plus human approval; low-risk automatic action with audit; high autonomy.
• Increasing model capability does not require automatically moving to the highest authority level.

Compact glossary

Artificial Intelligence: the broad field of computational systems performing tasks associated with perception, reasoning, learning, planning, language, or decision-making.

Machine Learning: methods that learn parameters or decision functions from data rather than encoding all behavior manually.

Deep Learning: machine learning using multilayer neural networks to learn representations and task functions.

Artificial Neural Network: a learnable computation graph built from weighted connections, transformations, and nonlinear activations.

Perceptron: an early learnable linear decision model.

Fuzzy Logic: a framework that represents concept membership by degree rather than only true/false membership.

Neuro-Fuzzy System: a hybrid family combining learnable neural parameters with fuzzy inference.

ANFIS: an adaptive-network implementation of Takagi–Sugeno-style fuzzy inference.

Expert System: a symbolic system that applies explicit domain knowledge through an inference engine.

Reinforcement Learning: learning policies from reward obtained through interaction with an environment.

Transformer: a sequence architecture based on self-attention, feed-forward layers, residual paths, and positional information.

Attention: dynamic weighting and routing of information among representations.

Tokenization: converting text into the discrete token sequence consumed by a language model.

Embedding: a continuous vector representation of a discrete item or sequence.

Large Language Model: a large pretrained model of token sequences, usually adapted for many downstream language tasks.

Retrieval-Augmented Generation: generation conditioned on evidence retrieved from an external corpus at runtime.

Reranking: applying a more precise relevance model to an initial retrieval candidate list.

Context Engineering: designing which information, state, and tools a model receives, in what order and within what budget.

AI Agent: a system that observes state, chooses actions/tools, and updates its plan in pursuit of a goal.

Multi-Agent System: a coordinated system of multiple agents with separate roles, contexts, or capabilities.

Model Context Protocol: an open protocol for standardizing model access to external tools and resources.

Explainable AI: techniques for making model behavior more interpretable through attribution, explanations, examples, or counterfactuals.

AI Alignment: the problem of making system behavior correspond to human intent, safety constraints, and legitimate policy.

Reward Hacking: exploiting the reward measurement rather than accomplishing the intended task.

Symbol Grounding: the problem of connecting symbolic representations to perception, action, and the world rather than only to other symbols.

Turing Test: a historical behavioral test of whether machine conversation can be distinguished from human conversation.

Chinese Room: Searle's thought experiment challenging the equivalence of syntactic rule following and semantic understanding.

Knowledge Argument: the family of arguments, including Mary's Room, that asks whether complete physical knowledge exhausts subjective experience.

Qualia: the first-person “what it is like” character of experience.

Artificial Consciousness: research and philosophy concerning possible consciousness-like or phenomenal states in artificial systems.

Computational Complexity: the study of how time and memory requirements scale with input size.

Information Entropy: Shannon's measure of uncertainty in a probability distribution.

Landauer Principle: the physical principle connecting logically irreversible information erasure with a thermodynamic lower cost.

Theory of Mind: modeling another actor's beliefs, knowledge, goals, or intentions.

Instrumental Convergence: the idea that very different final goals can make similar intermediate goals useful.

Corrigibility: a safety property in which a system does not resist correction, interruption, or modification by legitimate operators.

Conclusion: tools changed in ten years; the distinctions did not

From the first 2016 version to the 2026 revision, AI changed dramatically. Perceptrons and classical multilayer networks gave way to Transformers and foundation models. Single-task systems expanded into multimodal models.

Prompts became RAG pipelines and agentic workflows. GPU and accelerator ecosystems grew, while model generation, coding assistance, and large-scale knowledge retrieval became widely accessible. The durable distinctions remained.

Data is not reality. Shannon information is not semantic meaning. Correlation is not causation.

Model output is not verified knowledge. High task performance is not proof of consciousness. Capability is not proof of a good objective.

A model being able to call a tool does not mean it should have permission to call it. More computation does not erase limits established by Gödel, Turing, information theory, or physics. The more mature engineering question is therefore not “how impressive is the model?” but: under which conditions does this system work, when does it fail, how much impact can a failure create, and which part of the decision can I verify independently?

That perspective is also consistent with the Zen idea of clarity. Reducing unnecessary complexity does not mean deleting detail; it means making clear which question each detail answers. Sometimes the best AI decision is to use a larger model.

Sometimes it is to use a classical algorithm, require human approval, or decline to automate the task at all.

References

• Arf, C. (1959). Makine Düşünebilir mi ve Nasıl Düşünebilir? Atatürk Üniversitesi 1958–1959 Öğretim Yılı Halk Konferansları.
• Amodei, D. et al. (2016). Concrete Problems in AI Safety. arXiv:1606.06565.
• Baars, B. J. (1988). A Cognitive Theory of Consciousness. Cambridge University Press.
• Bennett, C. H. (2003). Notes on Landauer's Principle, Reversible Computation, and Maxwell's Demon. Studies in History and Philosophy of Modern Physics, 34(3), 501–510.
• Bishop, C. M. (2006). Pattern Recognition and Machine Learning. Springer.
• Bostrom, N. (2014). Superintelligence: Paths, Dangers, Strategies. Oxford University Press.
• Browne, C. B. et al. (2012). A Survey of Monte Carlo Tree Search Methods. IEEE Transactions on Computational Intelligence and AI in Games, 4(1), 1–43.
• Brown, T. B. et al. (2020). Language Models are Few-Shot Learners. NeurIPS 33.
• Čapek, K. (1920). R.U.R. (Rossum's Universal Robots).
• Chalmers, D. J. (1996). The Conscious Mind. Oxford University Press.
• Cortes, C., & Vapnik, V. (1995). Support-Vector Networks. Machine Learning, 20, 273–297.
• Cover, T. M., & Thomas, J. A. (2006). Elements of Information Theory (2nd ed.). Wiley.
• Dettmers, T., Pagnoni, A., Holtzman, A., & Zettlemoyer, L. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. NeurIPS 36.
• Devlin, J., Chang, M.-W., Lee, K., & Toutanova, K. (2019). BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. NAACL-HLT.
• Fano, R. M. (1961). Transmission of Information: A Statistical Theory of Communications. MIT Press.
• Fawzi, A. et al. (2022). Discovering Faster Matrix Multiplication Algorithms with Reinforcement Learning. Nature, 610, 47–53.
• Fisher, R. A. (1936). The Use of Multiple Measurements in Taxonomic Problems. Annals of Eugenics, 7(2), 179–188.
• Glover, F. (1986). Future Paths for Integer Programming and Links to Artificial Intelligence. Computers & Operations Research, 13(5), 533–549.
• Gödel, K. (1931). Über formal unentscheidbare Sätze der Principia Mathematica und verwandter Systeme I.
• Hadfield-Menell, D. et al. (2017). The Off-Switch Game. IJCAI.
• Harnad, S. (1990). The Symbol Grounding Problem. Physica D, 42, 335–346.
• Hart, P. E., Nilsson, N. J., & Raphael, B. (1968). A Formal Basis for the Heuristic Determination of Minimum Cost Paths. IEEE Transactions on Systems Science and Cybernetics, 4(2), 100–107.
• Hebb, D. O. (1949). The Organization of Behavior. Wiley.
• Hubinger, E. et al. (2019). Risks from Learned Optimization in Advanced Machine Learning Systems. arXiv:1906.01820.
• Hu, E. J. et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685.
• Jackson, F. (1982). Epiphenomenal Qualia. The Philosophical Quarterly, 32(127), 127–136.
• Korf, R. E. (1985). Depth-First Iterative-Deepening: An Optimal Admissible Tree Search. Artificial Intelligence, 27(1), 97–109.
• Köker, M. A. et al. (2022). Görüntü ve Ses İşleme. In Yapay Zeka - Kuramdan Uygulamaya. Nobel Akademik Yayıncılık.
• Landauer, R. (1961). Irreversibility and Heat Generation in the Computing Process. IBM Journal of Research and Development, 5(3), 183–191.
• LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep Learning. Nature, 521, 436–444.
• Lewis, P. et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS 33.
• MacQueen, J. (1967). Some Methods for Classification and Analysis of Multivariate Observations. Proceedings of the Fifth Berkeley Symposium.
• Mackworth, A. K. (1977). Consistency in Networks of Relations. Artificial Intelligence, 8(1), 99–118.
• Mankowitz, D. J. et al. (2023). Faster Sorting Algorithms Discovered Using Deep Reinforcement Learning. Nature, 618, 257–263.
• McCarthy, J., Minsky, M. L., Rochester, N., & Shannon, C. E. (1955). A Proposal for the Dartmouth Summer Research Project on Artificial Intelligence.
• McCulloch, W. S., & Pitts, W. (1943). A Logical Calculus of the Ideas Immanent in Nervous Activity. Bulletin of Mathematical Biophysics, 5, 115–133.
• MISRA. (2012). MISRA C:2012 — Guidelines for the Use of the C Language in Critical Systems (3rd ed.).
• Mnih, V. et al. (2015). Human-level Control through Deep Reinforcement Learning. Nature, 518, 529–533.
• Nilsson, N. J. (2010). The Quest for Artificial Intelligence: A History of Ideas and Achievements. Cambridge University Press.
• NIST. (2023). Artificial Intelligence Risk Management Framework (AI RMF 1.0). NIST AI 100-1.
• Ouyang, L. et al. (2022). Training Language Models to Follow Instructions with Human Feedback. NeurIPS 35.
• Pearl, J. (1984). Heuristics: Intelligent Search Strategies for Computer Problem Solving. Addison-Wesley.
• Pearl, J. (1988). Probabilistic Reasoning in Intelligent Systems. Morgan Kaufmann.
• Rice, H. G. (1953). Classes of Recursively Enumerable Sets and Their Decision Problems. Transactions of the American Mathematical Society, 74(2), 358–366.
• Rosenblatt, F. (1958). The Perceptron: A Probabilistic Model for Information Storage and Organization in the Brain. Psychological Review, 65(6), 386–408.
• RTCA. (2011). DO-178C: Software Considerations in Airborne Systems and Equipment Certification.
• Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning Representations by Back-Propagating Errors. Nature, 323, 533–536.
• Russell, S. (2019). Human Compatible: Artificial Intelligence and the Problem of Control. Viking.
• Russell, S., & Norvig, P. (2021). Artificial Intelligence: A Modern Approach (4th ed.). Pearson.
• Searle, J. R. (1980). Minds, Brains, and Programs. Behavioral and Brain Sciences, 3(3), 417–424.
• Shannon, C. E. (1948). A Mathematical Theory of Communication. Bell System Technical Journal, 27, 379–423, 623–656.
• Silver, D. et al. (2016). Mastering the Game of Go with Deep Neural Networks and Tree Search. Nature, 529, 484–489.
• Sutton, R. S., & Barto, A. G. (2018). Reinforcement Learning: An Introduction (2nd ed.). MIT Press.
• Tononi, G. (2004). An Information Integration Theory of Consciousness. BMC Neuroscience, 5, 42.
• Turing, A. M. (1936). On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society, 42, 230–265.
• Turing, A. M. (1950). Computing Machinery and Intelligence. Mind, 59(236), 433–460.
• Vaswani, A. et al. (2017). Attention Is All You Need. NeurIPS 30.
• Wiener, N. (1948). Cybernetics: Or Control and Communication in the Animal and the Machine. MIT Press.
• Zadeh, L. A. (1965). Fuzzy Sets. Information and Control, 8(3), 338–353.