History and Evolution of AI

What You Will Learn

This exhaustive architectural history module delivers production-focused insights across the following historical and technical areas:

• Foundational Mechanics: The formal mathematical roots of the Turing Test, the Church-Turing Thesis, and the exact systemic outputs of the 1956 Dartmouth Summer Research Project.
• Symbolic AI vs. Connectionist AI: The deep paradigm division between top-down, rule-driven logic frameworks and bottom-up, data-driven statistical neural structures.
• Anatomy of the AI Winters: A rigorous analysis of the technical and operational failures that caused the 1974 and 1987 industry funding crashes, focusing on the Lighthill Report and the limits of combinatorics.
• The Expert Systems Era: The internal mechanics, physical hardware dependencies, and structural brittleness of rule-based knowledge engineering frameworks.
• The Shift to Statistical Subsystems: How the emergence of backpropagation algorithms, cheap storage, and distributed compute clusters catalyzed the transition from explicit programming to statistical pattern matching.
• The Deep Learning Transformation: The infrastructural, mathematical, and architectural milestones (such as AlexNet, ImageNet, and GPU parallelism) that unlocked multi-layered neural execution.
• Generative Foundation Topologies: A technical bridge mapping historical architectures directly to modern multi-headed attention mechanisms and distributed transformer systems.

Prerequisites

To fully absorb the system-level concepts, architectural blueprints, and historical software logic models presented in this module, you should possess:

• Basic Logic Competency: Familiarity with boolean algebra, propositional calculus, first-order predicate logic, and graph theory primitives.
• Algorithmic Understanding: Awareness of classical search strategies (e.g., depth-first search, breadth-first search, heuristic optimization) and compute complexity metrics (Big-O notation).
• Systems Engineering Context: General awareness of hardware structures (the differences between CPU sequential processing and GPU massive vector parallelization).

The Conceptual Foundations (1940s – 1950s)

Featured Snippet Optimization Answer:
The History of Artificial Intelligence formally began in the 1940s and 1950s with the mathematical formalization of mechanical computation. Key milestones include Alan Turing’s 1950 introduction of the Turing Test (Imitation Game), which defined functional machine intelligence based on behavioral indistinguishability from human output, and the Dartmouth Workshop in 1956. Organized by John McCarthy, Marvin Minsky, Nathaniel Rochester, and Claude Shannon, this workshop established AI as an independent academic field and coined the phrase "Artificial Intelligence." Early research focused on symbolic logic, formal proofs, and top-down heuristic search engines.

Alan Turing and the Mechanization of Thought

The formalization of automated intelligence started well before the availability of silicon microprocessors. In his seminal 1936 paper, "On Computable Numbers, with an Application to the Entscheidungsproblem," British mathematician Alan Turing proved that a universal abstract computing machine could execute any conceivable mathematical computation if it could be expressed as a formal algorithm. This framework, known as the Universal Turing Machine, separated software logic from physical hardware mechanisms.

In 1950, Turing published his landmark paper, "Computing Machinery and Intelligence," in the journal Mind. Recognizing that defining "intelligence" was a slippery philosophical task, he replaced the question with a practical operational challenge: the Imitation Game, now known as the Turing Test.

The system architecture of the Turing Test is straightforward yet rigorous. An independent human interrogator communicates with two isolated entities via textual interfaces (such as a teleprinter or command-line terminal). One entity is a real human participant; the other is an automated computing platform. If the interrogator cannot reliably distinguish the machine from the human after a series of free-form natural language text exchanges, the machine passes the test. This framework established a core operational principle that guided early AI development: intelligence could be measured by external, observable behavior rather than internal conscious experience.

The 1956 Dartmouth Workshop: Coining the Discipline

In the summer of 1956, a small group of mathematicians, logicians, and engineers gathered at Dartmouth College in Hanover, New Hampshire. The event, organized by John McCarthy (Dartmouth), Marvin Minsky (Harvard), Nathaniel Rochester (IBM), and Claude Shannon (Bell Laboratories), formally launched AI as a distinct, dedicated engineering field. The original proposal document laid out a bold agenda based on a core working hypothesis:

"Every aspect of learning or any other feature of intelligence can in principle be so precisely described that a machine can be made to simulate it."

The workshop brought together pioneers who introduced early foundational systems that shaped the first two decades of AI research:

• John McCarthy: Invented the LISP (List Processing) programming language, which became the standard software language for symbolic AI due to its unique ability to treat code as data.
• Marvin Minsky: Co-founded the MIT AI Laboratory, championing a structural approach focused on symbolic cognitive models and micro-worlds.
• Allen Newell and Herbert Simon: Demonstrated the Logic Theorist, an early software application that successfully proved 38 of the first 52 geometric theorems in Whitehead and Russell's Principia Mathematica using heuristic tree searches. This was a clear, early proof that computers could process symbols, not just numerical values.

The Grand Architectural Schism: Symbolic AI vs. Connectionist AI

From its inception, artificial intelligence research split into two fundamentally opposing theoretical and structural paradigms: Symbolic (Top-Down) AI and Connectionist (Bottom-Up) AI. This schism shaped research priorities, driven by competing ideas of how the human brain processes information.

+----------------------------------------------------------------------------------------------------+
|                                     THE GRAND ARCHITECTURAL SCHISM                                 |
+----------------------------------------------------------------------------------------------------+

PARADIGM A: SYMBOLIC (GOFAI)                               PARADIGM B: CONNECTIONIST (NEURAL)    
Top-Down Reasoner                                          Bottom-Up Learning Matrix             
                                                                                                  
+------------------------------+                           +--------------------------------+    
| Human Domain Knowledge       |                           | Large-Scale Raw Data Tensors   |    
+------------------------------+                           +--------------------------------+    
               |                                                           |                     
               v                                                           v                     
+------------------------------+                           +--------------------------------+    
| Explicit Production Rules    |                           | Multi-Layered Neural Topology  |    
| (IF-THEN / Predicate Logic)  |                           | (Weight Vector Optimization)   |    
+------------------------------+                           +--------------------------------+    
               |                                                           |                     
               v                                                           v                     
+------------------------------+                           +--------------------------------+    
| Inference Mechanism (Prolog) |                           | Output Activation Matrix       |    
+------------------------------+                           +--------------------------------+    
               |                                                           |                     
               v                                                           v                     
[ Deterministic Proof / Match ]                            [ Probabilistic Inference Score ]    
    

Symbolic AI: Good Old-Fashioned AI (GOFAI)

Symbolic AI operates on the Physical Symbol System Hypothesis, formulated by Newell and Simon. This theory asserts that a physical symbol system possesses the necessary and sufficient means for generating general intelligent action. According to this view, thinking is equivalent to algebraic symbol manipulation following explicit syntactic rules.

The software architecture of a Symbolic system is top-down. Human domain experts explicitly define concepts, relations, and operational logic, converting real-world information into formal semantic networks, taxonomies, and first-order predicate calculus. The software processes these symbols using logical deduction mechanisms, such as resolution and unification. New facts are derived from existing premises with mathematical certainty, making the system highly auditable and interpretable.

Connectionist AI: The Neural Network Approach

In contrast, Connectionist AI models intelligence as an emergent property of large networks of simple, interconnected processing units. Inspired by biological neuroscience, this paradigm skips explicit rule engines. Instead, it builds multi-layered network topographies where knowledge is distributed across numeric weight matrices linking artificial neurons.

The system architecture of a Connectionist network is bottom-up. Rather than hard-coding business logic, developers construct optimization algorithms that expose the network to raw, unmapped data. The network iteratively updates its internal connection weights to minimize error scores against an objective loss function. The system learns parameters directly from the data, bypassing manual rule writing. This model excels at processing messy, non-linear real-world information like images, raw audio streams, and unstructured text patterns.

The Golden Years and the First AI Winter (1956 – 1974)

The post-Dartmouth era, often called the "Golden Years," was characterized by intense optimism, significant government funding, and impressive breakthroughs in limited, artificial environments called micro-worlds.

Early Breakthroughs and Computational Optimism

Early researchers achieved notable milestones by using heuristic search trees to solve structured logic puzzles. Key developments from this period include:

• ELIZA (1966): Developed by Joseph Weizenbaum at MIT, ELIZA was one of the earliest natural language processing programs. By using pattern matching and string substitution rules, it simulated a Rogerian psychotherapist, illustrating how simple syntactic scripts could mimic human conversation.
• The Geometry Theorem Prover (1959): Created by Herbert Gelernter, this system used explicit heuristic filters to prune massive search spaces, proving complex geometric theorems that initially challenged human students.
• Shakey the Robot (1966-1972): Built at SRI International, Shakey was the first general-purpose mobile robot capable of reasoning about its own actions. It unified computer vision, automated natural language command processing, and logical planning using the STRIPS planning engine.

The Wall of Combinatorial Explosion

Despite these early wins, researchers soon hit severe performance bottlenecks when trying to transition applications out of clean sandbox micro-worlds into messy, high-dimensional real-world deployments. Early algorithms scaled exponentially rather than polynomially, encountering the combinatorial explosion.

To find an optimal path or resolve a logic proof, early programs evaluated permutations across growing search trees. In a simple micro-world with a handful of state variables, computers could check every path. However, when real-world variables, environmental noise, and cross-domain contexts were added, the number of required computations quickly surpassed the physical memory and processing cycles of 1970s mainframe hardware.

The Lighthill Report and the 1974 Crash

In 1973, the British Science Research Council commissioned Professor James Lighthill to evaluate the state of AI research in the United Kingdom. His highly critical findings, published as the Lighthill Report, concluded that AI technologies had failed to deliver on their ambitious promises. He argued that existing models were only effective in simplified toy domains and fell completely short when applied to complex practical problems.

Simultaneously, the Defense Advanced Research Projects Agency (DARPA) in the United States faced growing pressure to focus public funding exclusively on immediate, measurable military outcomes. The combination of the Lighthill Report and changing funding priorities cut off deep research capital, triggering the First AI Winter (1974–1980). AI laboratories faced major funding cuts, research projects were downscaled, and public interest shifted away from autonomous software research.

The Resurgence and Fragility of Expert Systems (1980s)

The field experienced a major resurgence in the 1980s by shifting away from the pursuit of general-purpose, human-level intelligence. Researchers instead pivoted toward specialized, narrow domain expertise, giving rise to the era of Expert Systems and knowledge engineering.

The Architecture of an Expert System

An Expert System is a specialized software application that simulates the decision-making capabilities of a human expert within a highly focused operational area. Its architecture relies on a strict separation of concerns, decoupling the recorded institutional facts from the logical execution mechanisms.

+---------------------------------------------------------------------------------------------------+
|                                   EXPERT SYSTEM NODE ANATOMY                                      |
+---------------------------------------------------------------------------------------------------+

[ Domain Expert ] ---> ( Knowledge Engineer ) ---> [ Knowledge Base ]

		|

		| (Production Rules: IF-THEN)

		v

[ Operational Telemetry Payload ] -----------------> [ Inference Engine ]

		|  - Forward Chaining (Data-Driven)

		|  - Backward Chaining (Goal-Driven)

		v

[ Executed Action Output ]

The system architecture consists of three core components:

• The Knowledge Base: A specialized repository containing explicit domain facts, structural relationships, and heuristics, represented as production rules (IF-THEN conditional structures).
• The Inference Engine: The processing mechanism that applies the knowledge base rules to incoming data. It uses two main logical approaches:
  • Forward Chaining: A data-driven approach that starts with known facts and applies rules to derive new conclusions.
  • Backward Chaining: A goal-driven approach that starts with a target hypothesis and works backward to see if available evidence supports it.
• The User/API Interface: The communication layer that ingests external variables and returns the final deduced action along with an audit trail of the rules triggered during execution.

Commercial Success: XCON and MYCIN

Expert systems delivered clear commercial value across highly structured enterprise domains:

• XCON (eXpert CONfigurer): Developed by Digital Equipment Corporation (DEC), XCON automated the custom selection and configuration of components for VAX computer systems. By replacing manual engineering reviews with over 2,500 production rules, it reduced processing errors and saved the company millions of dollars annually.
• MYCIN: Developed at Stanford University, MYCIN identified bacterial infections and recommended customized antibiotic dosages. It used a specialized inference engine equipped with certainty factors to reason under medical uncertainty, frequently outperforming general practitioners in diagnostic precision.

The Knowledge Acquisition Bottleneck and the Second AI Winter

Despite their commercial success, expert systems had architectural limitations that eventually led to another funding crash. The primary bottleneck was knowledge acquisition. Human experts do not naturally think in clean, sequential IF-THEN structures. Extracting nuance from specialists and translating it into rigid code blocks required years of manual translation by specialized knowledge engineers.

As these rule bases expanded into tens of thousands of assertions, they became deeply fragile and unmanageable. Rules often contradicted one another, creating logical conflicts that were incredibly difficult to debug. The software could not learn on its own; any update to corporate policy or market conditions required manual code refactoring.

At the same time, specialized hardware systems like Lisp Machines lost their competitive edge to cheaper, high-performance desktop computers from vendors like Sun Microsystems. By 1987, the high maintenance costs and brittle nature of these systems caused market interest to collapse, triggering the Second AI Winter (1987–1993).

The Data-Driven Turn: Machine Learning and Big Data (1990s – 2010)

In the 1990s, AI research underwent a profound structural transformation. Teams abandoned top-down symbolic programming and moved toward statistical machine learning, shifting from deduction to induction.

The Shift from Logic Rules to Empirical Statistics

Instead of manually writing rules to describe a concept, developers began building statistical models that learned pattern parameters directly from data. This approach redefined the developer's role. Rather than coding explicit decision trees, engineers focused on writing objective functions and optimization routines. The algorithm analyzed large datasets to discover the statistical boundaries that mapped inputs to targets. This pivot was accelerated by key mathematical refinements, including:

• Support Vector Machines (SVMs): Pioneered by Vladimir Vapnik, SVMs mapped low-dimensional data into high-dimensional vector spaces using kernel functions, making non-linear classification tasks mathematically manageable. To explore these boundaries, review our module on Support Vector Machines and Kernel Methods.
• Probabilistic Graphical Models: Judea Pearl introduced Bayesian networks into the field, providing a clean framework for reasoning under uncertainty using causal probability distributions rather than rigid boolean logic. For a deeper look at these statistical frameworks, see our guide on Probability and Statistics for Data Science.

Deep Blue vs. Kasparov (1997)

In May 1997, IBM’s Deep Blue supercomputer defeated reigning world chess champion Garry Kasparov in a formal six-game match. This was a major milestone for computational processing power, demonstrating that machines could outperform humans in complex strategic domains.

Deep Blue's architecture was a hybrid system that combined massive parallel hardware processing with heuristic search optimization. Running on a specialized IBM supercomputer cluster, the system evaluated up to 200 million chess positions per second. It used a custom evaluation function that assessed positional variables alongside deep alpha-beta minimax search trees. While highly effective, Deep Blue was an expert system tailored for a specific board game; it lacked the ability to generalize its reasoning to any other application domain.

The Internet Boom and Ingestion Scaling

The late 1990s and 2000s saw the rapid rise of the consumer internet, which completely transformed the AI landscape by generating massive volumes of raw operational data. Web browsers, financial platforms, enterprise application logs, and digital media channels produced an ongoing stream of text, user clicks, consumer profiles, and transactional metadata.

This surge in digital interaction provided the high-volume data required to fuel statistical machine learning models. Concurrently, the development of distributed file systems and framework clusters (such as Apache Hadoop and MapReduce) allowed teams to scale data processing across cheap, commodity hardware. For the first time, engineers had both the statistical models and the massive datasets needed to train them effectively at scale.

The Deep Learning Revolution (2012 – Present)

The modern era of AI is defined by the absolute dominance of Deep Learning, an advanced connectionist approach based on multi-layered artificial neural network topologies.

The Convergence of Three Pillars

The deep learning boom was not sparked by a sudden change in basic neural mathematics; the foundational math of backpropagation had been well understood since the 1980s. Instead, it was unlocked by the convergence of three distinct technological pillars:

The ImageNet Inflection Point (2012)

The breakthrough moment occurred during the 2012 ImageNet Large Scale Visual Recognition Challenge (ILSVRC). ImageNet was a massive public dataset containing over 14 million labeled images across thousands of distinct categories, curated by Stanford Professor Fei-Fei Li to give researchers a benchmark for computer vision systems.

In 2012, a deep convolutional neural network named AlexNet—designed by Alex Krizhevsky, Ilya Sutskever, and Geoffrey Hinton—won the competition. While traditional computer vision models struggled to achieve an error rate below 26%, AlexNet achieved an error rate of 15.3%. This massive jump in performance proved the power of deep learning over hand-crafted computer vision pipelines, prompting AI labs worldwide to pivot toward deep neural architectures.

The Transformer Breakthrough and Large Language Models (LLMs)

In 2017, a team of researchers at Google published the paper "Attention Is All You Need," introducing a novel network architecture called the Transformer. This design replaced traditional recurrent neural networks (RNNs) and Long Short-Term Memory (LSTM) blocks with multi-headed self-attention mechanisms. To explore these historical sequential changes, read our guide on Recurrent Neural Networks and LSTM.

Transformers eliminated sequential processing constraints, allowing models to train on massive text corpuses in parallel across distributed GPU clusters. This architecture laid the groundwork for modern Large Language Models (LLMs) like GPT-4, Claude, and Llama. These models map semantic relationships across billions of parameters, transitioning AI from narrow pattern classification to complex generative tasks, abstract reasoning, and automated code generation. To master these modern state-of-the-art systems, consult our deep dive on Transformers and Large Language Models.

Visualizing the Complete Evolution of Artificial Intelligence

The flowchart below outlines the major evolutionary transitions of AI, mapping its shift from early rule-based symbolic deduction to modern data-driven neural networks:

+----------------------------------------------------------------------------------------------------------+
|                              CHRONOLOGICAL ARCHITECTURAL EVOLUTION OF AI                                 |
+----------------------------------------------------------------------------------------------------------+

[ 1943-1956: FOUNDATIONAL THEORIES ]

McCulloch-Pitts Neuron, Alan Turing's Imitation Game, 1956 Dartmouth Summer Research Project.

		|

		v

[ 1956-1974: THE FIRST SHIFT - GOFAI ]

Symbolic Logic, Heuristic Search Trees, Micro-world Sandboxes, ELIZA, STRIPS Planning.

		|

		v

	( 1974-1980: THE FIRST AI WINTER )

Combinatorial Explosion, The Lighthill Report critique, DARPA cuts funding.

		|

		v

	[ 1980-1987: KNOWLEDGE ENGINEERING ]

Commercial Expert Systems, Decoupled Knowledge Bases, Forward/Backward Inference Chaining (XCON, MYCIN).
		|

		v

	( 1987-1993: THE SECOND AI WINTER )

Knowledge acquisition bottleneck, high system maintenance costs, collapse of specialized Lisp hardware.

		|

		v

	[ 1993-2010: STATISTICAL MACHINE LEARNING ]

Inductive learning models, SVMs, Bayesian Graphical Networks, Deep Blue victory, Internet Big Data.

		|

		v

	[ 2012-PRESENT: THE CONNECTIONIST RENAISSANCE ]

Deep Learning, ImageNet (AlexNet), Hardware Acceleration via GPUs, Generative Transformers, LLMs.

package com.enterprise.ai.history;

	import java.util.HashSet;
	import java.util.Objects;
	import java.util.Set;
	import java.util.logging.Logger;

	/

	* Represents a discrete clinical symptom fact used within the expert rule engine.
	*/
	class ClinicalFact {
		private final String symptomKey;
		private final boolean isPresent;
		public ClinicalFact(String symptomKey, boolean isPresent) {
			this.symptomKey = Objects.requireNonNull(symptomKey, "Symptom key cannot be null");
			this.isPresent = isPresent;
		}
		public String getSymptomKey() { return symptomKey; }
		public boolean isPresent() { return isPresent; }
	}

	/

	* Defines a structural rule block within the expert knowledge base.
	*/
	class ProductionRule {
	
		private final Set requiredSymptoms = new HashSet<>();
		private final String deducedCondition;
		private final double certaintyFactor;
		public ProductionRule(Set symptoms, String deducedCondition, double certaintyFactor) {
			this.requiredSymptoms.addAll(symptoms);
			this.deducedCondition = deducedCondition;
			this.certaintyFactor = certaintyFactor;
		}
		/
		* Evaluates active clinical facts against the rule parameters using forward chaining logic.
		*/
		public boolean evaluate(Set activeSymptoms) {
			return activeSymptoms.containsAll(requiredSymptoms);
		}

		public String getDeducedCondition() { return deducedCondition; }
		public double getCertaintyFactor() { return certaintyFactor; }
	}

	/

	* Historical Expert Knowledge Base and Inference Engine implementation.
	*/
	public class ExpertSystemDiagnosisEngine {
		
		private static final Logger logger = Logger.getLogger(ExpertSystemDiagnosisEngine.class.getName());
		private final Set knowledgeBase = new HashSet<>();
		public void registerRule(ProductionRule rule) {
				this.knowledgeBase.add(rule);
		}
		public void runInference(Set observedSymptoms) {
			logger.info("Starting forward-chaining inference evaluation across rules...");
			boolean ruleTriggered = false;

			for (ProductionRule rule : knowledgeBase) {
				if (rule.evaluate(observedSymptoms)) {
					logger.info(String.format("[INFERENCE TRIGGERED] Condition: %s | Certainty Factor: %.2f",
					rule.getDeducedCondition(), rule.getCertaintyFactor()));
					ruleTriggered = true;
				}
			}

			if (!ruleTriggered) {
				logger.warning("[SYSTEM FAILURE] No matching production rule found. Knowledge base is incomplete.");
			}

		}
		public static void main(String[] args) {
			ExpertSystemDiagnosisEngine engine = new ExpertSystemDiagnosisEngine();

			// Manually engineering the knowledge rules (The Knowledge Acquisition Bottleneck)
			Set<String> influenzaCriteria = new HashSet<>();
			influenzaCriteria.add("FEVER");
			influenzaCriteria.add("COUGH");
			engine.registerRule(new ProductionRule(influenzaCriteria, "INFLUENZA_A", 0.85));

			Set<String> allergyCriteria = new HashSet<>();
			allergyCriteria.add("SNEEZING");
			allergyCriteria.add("WATERY_EYES");
			engine.registerRule(new ProductionRule(allergyCriteria, "ALLERGIC_RHINITIS", 0.90));

			// Simulating patient intake symptoms
			Set<String> patientSymptoms = new HashSet<>();
			patientSymptoms.add("FEVER");
			patientSymptoms.add("COUGH");

			System.out.println("--- Executing 1980s Symbolic Expert System ---");
			engine.runInference(patientSymptoms);

		}
	}

package com.enterprise.ai.history;

import java.util.Arrays;
import java.util.logging.Logger;

/

* Demonstrates a Connectionist Neural Processor that evaluates raw inputs using statistical weights.
*/
public class ConnectionistNeuron {
		private static final Logger logger = Logger.getLogger(ConnectionistNeuron.class.getName());
		private final double[] weightVector;
		private final double biasParameter;
		public ConnectionistNeuron(double[] weights, double bias) {
			this.weightVector = Arrays.copyOf(weights, weights.length);
			this.biasParameter = bias;
		}
	/
	* Executes the non-linear Sigmoid activation function to map inputs to a probability space.
	*/
	private double computeSigmoid(double logit) {
		return 1.0 / (1.0 + Math.exp(-logit));
	}

	/
	* Computes the forward pass inference using vector dot products: z = (W * X) + b
	*/
	public double forwardInferencePass(double[] inputFeatures) {
		if (inputFeatures.length != weightVector.length) {
			throw new IllegalArgumentException("Feature vector dimensions must match model internal weight sizes.");
		}
			double rawAccumulation = biasParameter;
		for (int i = 0; i < inputFeatures.length; i++) {
			rawAccumulation += inputFeatures[i] * weightVector[i];
		}
			double predictionProbability = computeSigmoid(rawAccumulation);
			logger.info(String.format("Dot product z value computed: %.4f | Probability: %.4f", rawAccumulation, predictionProbability));
		return predictionProbability;
	}

	public static void main(String[] args) {
		// Simulating a model that has learned its weights from thousands of patient training records
		// Features array index: [0] = Normal Body Temperature Delta, [1] = Cough Intensity Metric
		double[] trainedWeights = {1.85, 2.42};
		double learnedBias = -2.10;

		ConnectionistNeuron modernNeuron = new ConnectionistNeuron(trainedWeights, learnedBias);

		// Simulation Data: Patient presents significant feature shifts
		double[] patientFeatures = {1.2, 0.95};
		
		System.out.println("\n--- Executing Modern Connectionist Statistical Inference ---");
		double outcomeProbability = modernNeuron.forwardInferencePass(patientFeatures);

		if (outcomeProbability >= 0.75) {
			System.out.println("Result Validation Action: Alert clinical triage. High probability classification.");
		} else {
			System.out.println("Result Validation Action: Maintain passive tracking profile.");
		}

	}
}