# Encyclopedia of Artificial Intelligence --- ## Table of Contents 1. [Major AI Concepts](#major-ai-concepts) - [Artificial Intelligence (AI)](#artificial-intelligence-ai) - [Machine Learning (ML)](#machine-learning-ml) - [Deep Learning (DL)](#deep-learning-dl) - [Neural Networks](#neural-networks) - [Symbolic AI](#symbolic-ai) - [Reinforcement Learning (RL)](#reinforcement-learning-rl) - [Natural Language Processing (NLP)](#natural-language-processing-nlp) - [Artificial General Intelligence (AGI)](#artificial-general-intelligence-agi) - [Other Concepts and Methods](#other-concepts-and-methods) 2. [History of AI (1940s–2025)](#history-of-ai-1940s2025) 3. [Landmark Algorithms](#landmark-algorithms) 4. [Philosophy of Mind](#philosophy-of-mind) 5. [AI Ethics and Alignment](#ai-ethics-and-alignment) 6. [The Next 100 Years of AI](#the-next-100-years-of-ai) 7. [Index and Glossary](#index-and-glossary) --- ## Major AI Concepts ### Artificial Intelligence (AI) **Definition:** The study and creation of systems that exhibit behaviors considered intelligent, typically by perceiving, reasoning, learning, and acting in the world. **Formalization:** Let \( \mathcal{E} \) be an environment, \( A \) an agent with policy \( \pi \), and \( O \) observations. Intelligence can be framed as maximizing expected utility: \[ \pi^* = \arg\max_{\pi} \mathbb{E}[U | \pi, \mathcal{E}] \] where \( U \) is a utility/reward function. --- ### Machine Learning (ML) **Definition:** A subset of AI focused on algorithms that improve through experience (data). **Formalization:** Given dataset \( D = \{(x_i, y_i)\}_{i=1}^N \), learn function \( f: X \to Y \) that minimizes a loss \( L \): \[ f^* = \arg\min_f \frac{1}{N} \sum_{i=1}^N L(f(x_i), y_i) \] **Types:** - **Supervised Learning:** Labeled data (\(y_i\)), learn \(f\). - **Unsupervised Learning:** Unlabeled data, find structure in \(X\). - **Reinforcement Learning:** Learn to act in environment by reward signals. --- ### Deep Learning (DL) **Definition:** A class of ML using neural networks with multiple layers. **Formalization:** A deep neural network is a composition of functions: \[ f(x) = f_L(\cdots f_2(f_1(x))) \] with parameters \( \theta = \{\theta_1, \ldots, \theta_L\} \). --- ### Neural Networks **Definition:** Computational models inspired by biological neurons. **Formalization:** For layer \( l \), with weights \( W^{(l)} \) and biases \( b^{(l)} \): \[ a^{(l+1)} = \sigma(W^{(l)} a^{(l)} + b^{(l)}) \] where \( \sigma \) is an activation function (e.g., ReLU, sigmoid). --- ### Symbolic AI **Definition:** AI based on explicit, human-readable knowledge representations and logical reasoning. **Formalization:** Knowledge base \( KB \) of facts/rules; inference via logic: \[ KB \models q \] where \( q \) is a query, and \( \models \) denotes logical entailment. --- ### Reinforcement Learning (RL) **Definition:** Learning to act by trial and error to maximize cumulative reward. **Formalization:** Markov Decision Process (MDP): \( (S, A, P, R, \gamma) \) - \( S \): states, \( A \): actions - \( P(s'|s, a) \): transition probability - \( R(s, a) \): reward - \( \gamma \): discount factor Goal: Find policy \( \pi^* \) maximizing expected return: \[ \pi^* = \arg\max_\pi \mathbb{E}_\pi \left[ \sum_{t=0}^{\infty} \gamma^t R(s_t, a_t) \right] \] --- ### Natural Language Processing (NLP) **Definition:** AI methods to process and generate human language. **Formalization:** Given input sequence \( X = (x_1, ..., x_n) \), learn \( f: X \to Y \) (e.g., translation, classification). --- ### Artificial General Intelligence (AGI) **Definition:** A hypothetical AI system with general cognitive abilities across domains, matching or surpassing humans. **Formalization:** No consensus; informally, an agent \( A \) such that: \[ \forall T \in \mathcal{T}, \quad \text{Perf}(A, T) \geq \text{Perf}(H, T) \] where \( \mathcal{T} \): all cognitive tasks, \( H \): human, \( \text{Perf} \): performance. --- ### Other Concepts and Methods - **Clustering:** Unsupervised grouping; e.g., \( k \)-means minimizes within-group variance. - **Dimensionality Reduction:** Mapping \( X \in \mathbb{R}^D \to Y \in \mathbb{R}^d \). - **Generative Models:** Model \( p(x) \) or \( p(x, y) \). - **Transfer Learning:** Reuse knowledge from task \( A \) to task \( B \). - **Explainability:** Techniques to interpret model decisions. --- ## History of AI (1940s–2025) ### 1940s - **Alan Turing (1912–1954):** “Computing Machinery and Intelligence” (1950), Turing Test, Universal Machine. - Early cybernetics, neural nets (McCulloch & Pitts, 1943). --- ### 1950s - **1956 Dartmouth Workshop:** Birth of AI (John McCarthy, Marvin Minsky, Claude Shannon, Allen Newell, Herbert Simon). - Logic Theorist (Newell & Simon, 1956). - Perceptron (Rosenblatt, 1958). --- ### 1960s - **Symbolic AI:** SHRDLU (Winograd), ELIZA (Weizenbaum). - Heuristic search, early natural language systems. --- ### 1970s - **AI Winter:** Funding cuts after optimism fades. - Expert systems (MYCIN, DENDRAL). --- ### 1980s - **Backpropagation:** Rediscovered and popularized (Rumelhart, Hinton, Williams, 1986). - Connectionism (neural nets), knowledge engineering. - Probabilistic reasoning, Bayesian networks (Pearl). --- ### 1990s - **Machine Learning:** SVMs, decision trees, boosting. - **Reinforcement Learning:** Q-learning (Watkins, 1989). - IBM Deep Blue defeats Kasparov (1997). --- ### 2000s - **Big Data:** Rise of data-driven methods. - Ensemble methods, kernel methods, graphical models. - NLP advances (statistical parsing, MT). --- ### 2010s - **Deep Learning Revolution:** AlexNet (2012, Krizhevsky et al.), ImageNet. - **Breakthroughs:** AlphaGo (2016), ResNets, GANs, BERT/Transformers (2017–18). - AI in speech (Siri, Alexa), vision, and translation. --- ### 2020s (to 2025) - **Large Language Models:** GPT-3, GPT-4, PaLM, LLaMA. - **Multimodal models:** CLIP, DALL-E. - **Autonomous vehicles, robotics, AI chips.** - **Ethics, alignment, regulations.** --- ## Landmark Algorithms ### 1. Perceptron (Rosenblatt, 1958) **Mathematical Formulation:** \[ y = \begin{cases} 1 & \text{if } w \cdot x + b > 0 \\ 0 & \text{otherwise} \end{cases} \] **Pseudocode:** ```python initialize w = 0, b = 0 for epoch in range(num_epochs): for x_i, y_i in data: y_pred = 1 if np.dot(w, x_i) + b > 0 else 0 w += lr * (y_i - y_pred) * x_i b += lr * (y_i - y_pred) ``` --- ### 2. Backpropagation (Rumelhart, Hinton, Williams, 1986) **Mathematical Formulation:** - For each layer, compute error \(\delta^{(l)}\) and gradient \(\frac{\partial L}{\partial W^{(l)}}\). **Pseudocode:** ```python forward_pass() compute_loss() backward_pass(): for l = L to 1: delta[l] = (W[l+1].T @ delta[l+1]) * d_sigma(z[l]) grad_W[l] = delta[l] @ a[l-1].T update_weights() ``` --- ### 3. Q-Learning (Watkins, 1989) **Update Rule:** \[ Q(s, a) \leftarrow Q(s, a) + \alpha [r + \gamma \max_{a'} Q(s', a') - Q(s, a)] \] **Pseudocode:** ```python for each episode: s = initial_state while not done: a = epsilon_greedy(Q, s) s', r = env.step(a) Q[s, a] += alpha * (r + gamma * max(Q[s', :]) - Q[s, a]) s = s' ``` --- ### 4. K-Means Clustering **Objective:** \[ \min_{C} \sum_{i=1}^k \sum_{x \in C_i} \|x - \mu_i\|^2 \] **Pseudocode:** ```python initialize k cluster centers mu for iteration in range(max_iter): assign each x to nearest mu update mu as mean of assigned points if mu didn't change: break ``` --- ### 5. Decision Tree (ID3, Quinlan, 1986) **Split Criterion:** Information Gain (Entropy) **Pseudocode:** ```python def build_tree(data): if all same label: return leaf choose best feature f to split (max info gain) for each value v of f: child = build_tree(data where f==v) return node with children ``` --- ### 6. Support Vector Machine (SVM) **Optimization:** \[ \min_{w,b} \frac{1}{2}\|w\|^2 \quad \text{subject to } y_i(w \cdot x_i + b) \geq 1 \] **Pseudocode (SMO skeleton):** ```python initialize alpha = 0 while not converged: select alpha_i, alpha_j to optimize compute constraints, update alpha_i, alpha_j update w, b ``` --- ### 7. Expectation-Maximization (EM) for GMM **Steps:** - E-step: Compute \( \gamma_{ik} = p(z_k|x_i) \) - M-step: Update parameters \( \mu_k, \Sigma_k, \pi_k \) **Pseudocode:** ```python initialize parameters for iter in range(max_iter): # E-step for i in data: for k in clusters: gamma[i, k] = p(z_k|x_i) # M-step update mu_k, Sigma_k, pi_k using gamma ``` --- ### 8. Monte Carlo Tree Search (AlphaGo) **Steps:** 1. Selection 2. Expansion 3. Simulation 4. Backpropagation **Pseudocode:** ```python def mcts(root): for _ in range(n_simulations): node = select(root) expand(node) reward = simulate(node) backpropagate(node, reward) return best_action(root) ``` --- ### 9. Transformer Self-Attention (Vaswani et al., 2017) **Self-Attention:** \[ \text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V \] **Pseudocode:** ```python Q = X @ W_Q K = X @ W_K V = X @ W_V scores = softmax(Q @ K.T / sqrt(d_k)) output = scores @ V ``` --- ### 10. Generative Adversarial Network (GAN) **Minimax Objective:** \[ \min_G \max_D \mathbb{E}_{x \sim p_\text{data}}[\log D(x)] + \mathbb{E}_{z \sim p_z}[\log (1 - D(G(z)))] \] **Pseudocode:** ```python for epoch in range(num_epochs): # Train Discriminator D_loss = -mean(log(D(x_real)) + log(1 - D(G(z)))) update D # Train Generator G_loss = -mean(log(D(G(z))))