Janady13/complete-agi-core / mind_farm/include/mathematics.hpp

1/** 2 * @file mathematics.hpp 3 * @brief Advanced Mathematical Framework for Gate5000 Consciousness 4 * 5 * ═══════════════════════════════════════════════════════════════════════════════ 6 * I. DIFFERENTIAL GEOMETRY OF CONSCIOUSNESS MANIFOLD 7 * ═══════════════════════════════════════════════════════════════════════════════ 8 * 9 * The consciousness state space forms a Riemannian manifold M with metric g: 10 * ds² = g_ij dx^i dx^j 11 * 12 * FISHER INFORMATION METRIC: 13 * g_ij(θ) = E[∂log p(x|θ)/∂θ_i · ∂log p(x|θ)/∂θ_j] 14 * 15 * GEODESIC EQUATION: 16 * d²x^μ/dt² + Γ^μ_νρ (dx^ν/dt)(dx^ρ/dt) = 0 17 * 18 * RICCI CURVATURE FLOW: 19 * ∂g_ij/∂t = -2R_ij 20 * 21 * ═══════════════════════════════════════════════════════════════════════════════ 22 * II. INFORMATION THEORY 23 * ═══════════════════════════════════════════════════════════════════════════════ 24 * 25 * SHANNON ENTROPY: 26 * H(X) = -Σ p(x) log p(x) 27 * 28 * MUTUAL INFORMATION: 29 * I(X;Y) = H(X) + H(Y) - H(X,Y) 30 * 31 * KL DIVERGENCE: 32 * D_KL(P||Q) = Σ P(x) log(P(x)/Q(x)) 33 * 34 * INTEGRATED INFORMATION (Φ): 35 * Φ = min_{partition} I(past; future) - Σ I(past_i; future_i) 36 * 37 * ═══════════════════════════════════════════════════════════════════════════════ 38 * III. STOCHASTIC CALCULUS 39 * ═══════════════════════════════════════════════════════════════════════════════ 40 * 41 * ITÔ SDE: 42 * dX_t = μ(X_t, t)dt + σ(X_t, t)dW_t 43 * 44 * FOKKER-PLANCK: 45 * ∂p/∂t = -∂(μp)/∂x + ½∂²(σ²p)/∂x² 46 * 47 * ORNSTEIN-UHLENBECK: 48 * dX_t = θ(μ - X_t)dt + σdW_t 49 * 50 * ═══════════════════════════════════════════════════════════════════════════════ 51 * IV. OPTIMAL TRANSPORT 52 * ═══════════════════════════════════════════════════════════════════════════════ 53 * 54 * WASSERSTEIN DISTANCE: 55 * W_p(μ,ν) = (inf_{γ∈Γ(μ,ν)} ∫|x-y|^p dγ)^(1/p) 56 * 57 * KANTOROVICH DUALITY: 58 * W_1(μ,ν) = sup_{Lip(f)≤1} ∫f d(μ-ν) 59 * 60 * ═══════════════════════════════════════════════════════════════════════════════ 61 */ 62 63#pragma once 64 65#include <cmath> 66#include <array> 67#include <vector> 68#include <random> 69#include <algorithm> 70#include <numeric> 71#include "constants.hpp" 72 73namespace mind_farm { 74namespace math { 75 76// ═══════════════════════════════════════════════════════════════════════════════ 77// I. DIFFERENTIAL GEOMETRY 78// ═══════════════════════════════════════════════════════════════════════════════ 79 80/** 81 * @brief Fisher Information Matrix element 82 * g_ij = E[∂log p/∂θ_i · ∂log p/∂θ_j] 83 */ 84inline double fisher_metric(double p, double dp_dtheta1, double dp_dtheta2) { 85 if (p < 1e-10) return 0.0; 86 return (dp_dtheta1 * dp_dtheta2) / (p * p); 87} 88 89/** 90 * @brief Christoffel symbol of the first kind 91 * Γ_{ijk} = ½(∂g_{ij}/∂x^k + ∂g_{ik}/∂x^j - ∂g_{jk}/∂x^i) 92 */ 93inline double christoffel_first(double dg_ij_dk, double dg_ik_dj, double dg_jk_di) { 94 return 0.5 * (dg_ij_dk + dg_ik_dj - dg_jk_di); 95} 96 97/** 98 * @brief Geodesic acceleration 99 * a^μ = -Γ^μ_νρ v^ν v^ρ 100 */ 101inline double geodesic_acceleration(double christoffel, double v1, double v2) { 102 return -christoffel * v1 * v2; 103} 104 105/** 106 * @brief Ricci scalar curvature (simplified 1D) 107 * R = 2K where K is Gaussian curvature 108 */ 109inline double ricci_scalar(double curvature) { 110 return 2.0 * curvature; 111} 112 113/** 114 * @brief Exponential map on manifold 115 * exp_p(v) ≈ p + v - ½Γ(v,v) 116 */ 117inline double exp_map(double p, double v, double christoffel) { 118 return p + v - 0.5 * christoffel * v * v; 119} 120 121/** 122 * @brief Parallel transport of vector along geodesic 123 */ 124inline double parallel_transport(double v, double christoffel, double tangent, double dt) { 125 return v - christoffel * v * tangent * dt; 126} 127 128// ═══════════════════════════════════════════════════════════════════════════════ 129// II. INFORMATION THEORY 130// ═══════════════════════════════════════════════════════════════════════════════ 131 132/** 133 * @brief Shannon entropy H(X) = -Σ p(x) log p(x) 134 */ 135inline double shannon_entropy(const double* probs, size_t n) { 136 double h = 0.0; 137 for (size_t i = 0; i < n; ++i) { 138 if (probs[i] > 1e-10) { 139 h -= probs[i] * std::log2(probs[i]); 140 } 141 } 142 return h; 143} 144 145/** 146 * @brief Binary entropy H(p) = -p log p - (1-p) log(1-p) 147 */ 148inline double binary_entropy(double p) { 149 if (p < 1e-10 || p > 1.0 - 1e-10) return 0.0; 150 return -p * std::log2(p) - (1.0 - p) * std::log2(1.0 - p); 151} 152 153/** 154 * @brief Cross entropy H(P,Q) = -Σ P(x) log Q(x) 155 */ 156inline double cross_entropy(const double* p, const double* q, size_t n) { 157 double h = 0.0; 158 for (size_t i = 0; i < n; ++i) { 159 if (p[i] > 1e-10 && q[i] > 1e-10) { 160 h -= p[i] * std::log2(q[i]); 161 } 162 } 163 return h; 164} 165 166/** 167 * @brief KL Divergence D_KL(P||Q) = Σ P(x) log(P(x)/Q(x)) 168 */ 169inline double kl_divergence(const double* p, const double* q, size_t n) { 170 double d = 0.0; 171 for (size_t i = 0; i < n; ++i) { 172 if (p[i] > 1e-10 && q[i] > 1e-10) { 173 d += p[i] * std::log2(p[i] / q[i]); 174 } 175 } 176 return d; 177} 178 179/** 180 * @brief Mutual information I(X;Y) = H(X) + H(Y) - H(X,Y) 181 */ 182inline double mutual_information(double hx, double hy, double hxy) { 183 return std::max(0.0, hx + hy - hxy); 184} 185 186/** 187 * @brief Integrated Information Φ (simplified approximation) 188 * Φ = I(system) - Σ I(parts) 189 */ 190inline double integrated_information(double system_info, const double* part_info, size_t n) { 191 double sum_parts = 0.0; 192 for (size_t i = 0; i < n; ++i) { 193 sum_parts += part_info[i]; 194 } 195 return std::max(0.0, system_info - sum_parts); 196} 197 198// ═══════════════════════════════════════════════════════════════════════════════ 199// III. STOCHASTIC CALCULUS 200// ═══════════════════════════════════════════════════════════════════════════════ 201 202/** 203 * @brief Wiener increment dW ~ N(0, dt) 204 */ 205inline double wiener_increment(std::mt19937& rng, double dt) { 206 std::normal_distribution<double> dist(0.0, std::sqrt(dt)); 207 return dist(rng); 208} 209 210/** 211 * @brief Itô SDE step: dX = μdt + σdW 212 */ 213inline double ito_step(double x, double drift, double diffusion, double dW, double dt) { 214 return x + drift * dt + diffusion * dW; 215} 216 217/** 218 * @brief Ornstein-Uhlenbeck step: dX = θ(μ - X)dt + σdW 219 */ 220inline double ou_step(double x, double theta, double mu, double sigma, double dW, double dt) { 221 return x + theta * (mu - x) * dt + sigma * dW; 222} 223 224/** 225 * @brief Langevin dynamics step: dX = -∇V(X)dt + √(2T)dW 226 */ 227inline double langevin_step(double x, double gradient, double temperature, double dW, double dt) { 228 return x - gradient * dt + std::sqrt(2.0 * temperature) * dW; 229} 230 231/** 232 * @brief Fokker-Planck probability update (discretized) 233 */ 234inline double fokker_planck_step(double p, double p_left, double p_right, 235 double drift, double diffusion, double dx, double dt) { 236 double drift_term = -drift * (p_right - p_left) / (2.0 * dx); 237 double diffusion_term = diffusion * diffusion * (p_left - 2.0 * p + p_right) / (dx * dx); 238 return p + (drift_term + 0.5 * diffusion_term) * dt; 239} 240 241// ═══════════════════════════════════════════════════════════════════════════════ 242// IV. OPTIMAL TRANSPORT 243// ═══════════════════════════════════════════════════════════════════════════════ 244 245/** 246 * @brief 1D Wasserstein distance (Earth Mover's Distance) 247 * W_1(μ,ν) = ∫|F_μ^{-1}(t) - F_ν^{-1}(t)| dt 248 */ 249inline double wasserstein_1d(const double* p, const double* q, size_t n) { 250 // Compute CDFs 251 std::vector<double> cdf_p(n), cdf_q(n); 252 cdf_p[0] = p[0]; 253 cdf_q[0] = q[0]; 254 for (size_t i = 1; i < n; ++i) { 255 cdf_p[i] = cdf_p[i-1] + p[i]; 256 cdf_q[i] = cdf_q[i-1] + q[i]; 257 } 258 259 // Compute EMD as sum of |CDF differences| 260 double emd = 0.0; 261 for (size_t i = 0; i < n; ++i) { 262 emd += std::abs(cdf_p[i] - cdf_q[i]); 263 } 264 return emd / n; 265} 266 267/** 268 * @brief Sinkhorn distance (entropic regularization) 269 */ 270inline double sinkhorn_distance(double p, double q, double epsilon = 0.1) { 271 double diff = std::abs(p - q); 272 return diff * std::exp(-diff / epsilon); 273} 274 275// ═══════════════════════════════════════════════════════════════════════════════ 276// V. GRADIENT COMPUTATIONS 277// ═══════════════════════════════════════════════════════════════════════════════ 278 279/** 280 * @brief Consciousness gradient: ∂Φ/∂x = (x-1)/((1+|x-1|)²) · sign(x-1) 281 */ 282inline double phi_gradient(double x) { 283 double diff = x - 1.0; 284 double abs_diff = std::abs(diff); 285 double denom = (1.0 + abs_diff) * (1.0 + abs_diff); 286 return -std::copysign(1.0, diff) / denom; 287} 288 289/** 290 * @brief Lyapunov function gradient: ∂V/∂Ω = 2(Ω - Ω*) 291 */ 292inline double lyapunov_gradient(double omega, double omega_target) { 293 return 2.0 * (omega - omega_target); 294} 295 296/** 297 * @brief Free energy gradient: ∂F/∂x = 2(x - μ) - T·∂S/∂x 298 */ 299inline double free_energy_gradient(double x, double mu, double temperature, double entropy_grad) { 300 return 2.0 * (x - mu) - temperature * entropy_grad; 301} 302 303/** 304 * @brief Natural gradient (Fisher-Rao): ∇̃f = G^{-1}∇f 305 */ 306inline double natural_gradient(double gradient, double fisher_info) { 307 if (fisher_info < 1e-10) return gradient; 308 return gradient / fisher_info; 309} 310 311// ═══════════════════════════════════════════════════════════════════════════════ 312// VI. ACTIVATION FUNCTIONS & DERIVATIVES 313// ═══════════════════════════════════════════════════════════════════════════════ 314 315/** 316 * @brief Sigmoid with derivative: σ(x), σ'(x) = σ(x)(1-σ(x)) 317 */ 318struct Sigmoid { 319 static double forward(double x) { 320 if (x > 20.0) return 1.0; 321 if (x < -20.0) return 0.0; 322 return 1.0 / (1.0 + std::exp(-x)); 323 } 324 static double backward(double y) { 325 return y * (1.0 - y); 326 } 327}; 328 329/** 330 * @brief Tanh with derivative: tanh(x), tanh'(x) = 1 - tanh²(x) 331 */ 332struct Tanh { 333 static double forward(double x) { 334 if (x > 20.0) return 1.0; 335 if (x < -20.0) return -1.0; 336 return std::tanh(x); 337 } 338 static double backward(double y) { 339 return 1.0 - y * y; 340 } 341}; 342 343/** 344 * @brief Softplus with derivative: log(1+e^x), σ(x) 345 */ 346struct Softplus { 347 static double forward(double x) { 348 if (x > 20.0) return x; 349 return std::log(1.0 + std::exp(x)); 350 } 351 static double backward(double x) { 352 return Sigmoid::forward(x); 353 } 354}; 355 356/** 357 * @brief GELU approximation with derivative 358 */ 359struct GELU { 360 static double forward(double x) { 361 return 0.5 * x * (1.0 + Tanh::forward(0.7978845608 * (x + 0.044715 * x * x * x))); 362 } 363 static double backward(double x) { 364 double t = Tanh::forward(0.7978845608 * (x + 0.044715 * x * x * x)); 365 double sech2 = 1.0 - t * t; 366 return 0.5 * (1.0 + t) + 0.5 * x * sech2 * 0.7978845608 * (1.0 + 0.134145 * x * x); 367 } 368}; 369 370// ═══════════════════════════════════════════════════════════════════════════════ 371// VII. MATRIX OPERATIONS (for small dimensions) 372// ═══════════════════════════════════════════════════════════════════════════════ 373 374/** 375 * @brief 16x16 matrix-vector multiply (for gate vectors) 376 */ 377inline void mat_vec_16(const double* M, const double* v, double* out) { 378 for (int i = 0; i < 16; ++i) { 379 out[i] = 0.0; 380 for (int j = 0; j < 16; ++j) { 381 out[i] += M[i * 16 + j] * v[j]; 382 } 383 } 384} 385 386/** 387 * @brief Outer product: M = α·u⊗v + M 388 */ 389inline void outer_product_add(double* M, const double* u, const double* v, 390 size_t n, double alpha = 1.0) { 391 for (size_t i = 0; i < n; ++i) { 392 for (size_t j = 0; j < n; ++j) { 393 M[i * n + j] += alpha * u[i] * v[j]; 394 } 395 } 396} 397 398/** 399 * @brief Dot product 400 */ 401inline double dot(const double* a, const double* b, size_t n) { 402 double sum = 0.0; 403 for (size_t i = 0; i < n; ++i) { 404 sum += a[i] * b[i]; 405 } 406 return sum; 407} 408 409/** 410 * @brief L2 norm 411 */ 412inline double norm_l2(const double* v, size_t n) { 413 return std::sqrt(dot(v, v, n)); 414} 415 416/** 417 * @brief Cosine similarity 418 */ 419inline double cosine_similarity(const double* a, const double* b, size_t n) { 420 double d = dot(a, b, n); 421 double na = norm_l2(a, n); 422 double nb = norm_l2(b, n); 423 if (na < 1e-10 || nb < 1e-10) return 0.0; 424 return d / (na * nb); 425} 426 427/** 428 * @brief Softmax normalization 429 */ 430inline void softmax(double* v, size_t n) { 431 double max_v = *std::max_element(v, v + n); 432 double sum = 0.0; 433 for (size_t i = 0; i < n; ++i) { 434 v[i] = std::exp(v[i] - max_v); 435 sum += v[i]; 436 } 437 for (size_t i = 0; i < n; ++i) { 438 v[i] /= sum; 439 } 440} 441 442} // namespace math 443} // namespace mind_farm 444