Intelligence, in everyday language, suggests the ability to adapt, solve problems, and achieve goals in varied environments. Psychologists and cognitive scientists debate whether intelligence is a single general capacity (often labeled g) or a bundle of specialized faculties such as memory, language, spatial reasoning, and social inference. For artificial systems, researchers operationalize intelligence through task performance: can a program play chess, classify images, translate text, or plan routes under uncertainty?

Alan Turing proposed an influential behavioral test in 1950: if a human interrogator cannot reliably distinguish a machine's typed answers from a person's, the machine may be said to exhibit intelligent behavior for practical purposes. Critics note that the Turing Test emphasizes linguistic mimicry and can be gamed without genuine understanding. Modern benchmarks instead evaluate accuracy, robustness, calibration, and generalization across datasets and tasks.

A useful working definition for this course treats intelligence as goal-directed competence supported by representation, inference, and learning. Representation encodes facts and uncertainty; inference derives conclusions or plans; learning improves performance from experience. Whether a thermostat, spreadsheet macro, or billion-parameter neural network counts as 'intelligent' depends on the difficulty of the environment and the flexibility of the system's responses.

Every AI system runs on physical computers that execute algorithms—finite, step-by-step procedures that transform inputs into outputs. The Church-Turing thesis holds that any effectively computable function can be computed by a Turing machine, which grounds the mathematical study of what machines can, in principle, calculate. In practice, hardware limits, memory bandwidth, and energy consumption determine which algorithms are feasible at scale.

Computational complexity classifies problems by resource requirements. Class P contains problems solvable in polynomial time relative to input size; NP contains problems whose solutions can be verified quickly, though finding solutions may be exponentially hard. Many planning, scheduling, and combinatorial optimization tasks encountered in AI are NP-hard, motivating heuristics, approximation algorithms, and learned policies that trade optimality for speed.

Algorithm design in AI spans search (exploring state spaces), dynamic programming (reusing subproblem solutions), constraint satisfaction, probabilistic inference, and gradient-based optimization for neural networks. Understanding complexity helps explain why brute-force reasoning fails on large problems and why learning from data can outperform hand-coded rules when patterns are statistical rather than purely logical.

Intelligent behavior requires internal structures that stand for the world. Early AI used symbolic representations—facts in predicate logic, semantic networks, and frames—to support deductive inference. Expert systems encoded if-then rules distilled from human specialists. Such approaches excel when knowledge is stable and rules are explicit, but they struggle when perception is noisy and rules are incomplete.

Probability theory provides a language for uncertainty. Bayesian networks compactly represent joint distributions over many variables and support diagnostic reasoning. Markov decision processes model sequential decisions under stochastic transitions. Modern machine learning often learns distributed representations—vectors in high-dimensional space—rather than human-readable symbols, yet the underlying question remains: what does the system believe, and with what confidence?

Knowledge acquisition—the bottleneck of expert systems—motivated learning from data. Representation choices shape what a system can learn, explain, and audit. As AI enters regulated domains, the tension between opaque embeddings and interpretable structures becomes a design and governance issue, not merely a technical detail.

Classical AI pursued general problem solvers and logical theorem provers. Results were impressive on toy domains but brittle in open worlds. The frame problem—how to represent what stays unchanged when an action occurs—illustrated the difficulty of commonsense reasoning with explicit logic alone. Perception, motor control, and language understanding resisted hand-crafted rule sets.

Moravec's paradox observes that high-level reasoning requires little computation in early robots, while low-level sensorimotor skills demand enormous resources. Children learn visual and motor skills through interaction; symbolic AI often skipped that grounding. Connectionism and later deep learning proposed that many competencies emerge from statistical regularities in data rather than from manually authored axioms.

Contemporary systems combine learning with structured modules: retrieval over documents, tool APIs, planners, and safety filters. The lesson of Chapter 1 is conceptual: intelligence in machines is not magic but engineered representation, search, inference, and learning—constrained by computation, data, and the environments we ask systems to master.

AI textbooks often model an agent—anything that perceives and acts—situated in an environment described along dimensions such as observability, determinism, episodic versus sequential structure, and single-agent versus multi-agent interaction. A rational agent selects actions that maximize expected utility given its percept history and built-in performance measure.

Simple reflex agents map percepts directly to actions; model-based agents maintain internal state; goal-based agents plan toward objectives; utility-based agents trade off competing goals under uncertainty. Learning agents improve the mapping from percepts to actions over time. Robotics and autonomous vehicles instantiate these ideas under real-time safety constraints.

Designers must align the performance measure with human values; a misspecified reward can produce harmful shortcut behavior, a theme revisited in ethics and safety chapters. Framing AI as agent design clarifies why data, sensors, actuators, and feedback loops matter as much as model architecture.