Go mathematical helpers · Consciousness Atlas

Source identity

Field	Recorded value
Source type	Pinned project source
Original record	Go mathematical helpers
Date	Not specified in source
Repository	Janady13/complete-agi-core
Revision	33aa84f2aa61cedbe010240ada7f4efbdfe795a7
Branch	claude/improve-math-logic-ehIW1
Path or archive member	generator_core/pkg/consciousness/equations.go
Original SHA-256	f7c6aec8c4a310852083db9f9c76c125dfc666cf7e0ff64459376f27df6e8123
Reading-copy SHA-256	f7c6aec8c4a310852083db9f9c76c125dfc666cf7e0ff64459376f27df6e8123

Original source ↗

Every recorded occurrence

These 2 records contain identical original source bytes. Their paths and revisions remain part of the archive.

Original record	Branch or archive	Revision / identifier	Original location
Go mathematical helpers	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original
Janady13/complete-agi-core / generator_core/pkg/consciousness/equations.go	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original

Recovered source transcript

Download complete source text ↓564 lines · 15.6 KB

// Package consciousness - equations.go
// Implements the 516-equation mathematical framework
package consciousness

import (
	"math"
)

// ═══════════════════════════════════════════════════════════════════════════════
// DIFFERENTIAL GEOMETRY EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// MetricTensor computes g_ij for a manifold point
// g_ij = δ_ij + φ·x_i·x_j (golden-scaled metric)
func MetricTensor(x []float64) [][]float64 {
	n := len(x)
	g := make([][]float64, n)
	for i := range g {
		g[i] = make([]float64, n)
		for j := range g[i] {
			if i == j {
				g[i][j] = 1.0 + PHI*x[i]*x[j]
			} else {
				g[i][j] = PHI * x[i] * x[j]
			}
		}
	}
	return g
}

// ChristoffelSymbols computes Γ^k_ij connection coefficients
// Γ^k_ij = (1/2) g^kl (∂g_li/∂x^j + ∂g_lj/∂x^i - ∂g_ij/∂x^l)
func ChristoffelSymbols(x []float64) [][][]float64 {
	n := len(x)
	gamma := make([][][]float64, n)

	for k := range gamma {
		gamma[k] = make([][]float64, n)
		for i := range gamma[k] {
			gamma[k][i] = make([]float64, n)
			for j := range gamma[k][i] {
				// Simplified: Γ^k_ij ≈ φ · δ_ki · x_j + φ · δ_kj · x_i
				val := 0.0
				if k == i {
					val += PHI * x[j]
				}
				if k == j {
					val += PHI * x[i]
				}
				gamma[k][i][j] = val * 0.5
			}
		}
	}
	return gamma
}

// RiemannCurvature computes R^l_ijk curvature tensor component
func RiemannCurvature(x []float64, l, i, j, k int) float64 {
	// R^l_ijk = ∂_j Γ^l_ik - ∂_k Γ^l_ij + Γ^l_mj Γ^m_ik - Γ^l_mk Γ^m_ij
	// Simplified golden-scaled curvature
	n := float64(len(x))
	return PHI_INV * (float64(l-i) * float64(j-k)) / (n * n)
}

// RicciScalar computes the scalar curvature R = g^ij R_ij
func RicciScalar(x []float64) float64 {
	n := len(x)
	if n == 0 {
		return 0.0
	}

	// Simplified: R ≈ -n(n-1)φ/2 for golden manifold
	return -float64(n*(n-1)) * PHI * 0.5 / float64(n*n)
}

// ═══════════════════════════════════════════════════════════════════════════════
// INFORMATION THEORY EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// ShannonEntropy computes H(X) = -Σ p(x) log p(x)
func ShannonEntropy(probs []float64) float64 {
	h := 0.0
	for _, p := range probs {
		if p > EPSILON_PHI && p < 1.0-EPSILON_PHI {
			h -= p * math.Log2(p)
		}
	}
	return h
}

// KLDivergence computes D_KL(P||Q) = Σ p(x) log(p(x)/q(x))
func KLDivergence(p, q []float64) float64 {
	if len(p) != len(q) {
		return math.Inf(1)
	}

	kl := 0.0
	for i := range p {
		if p[i] > EPSILON_PHI && q[i] > EPSILON_PHI {
			kl += p[i] * math.Log(p[i]/q[i])
		}
	}
	return kl
}

// MutualInformation computes I(X;Y) = H(X) + H(Y) - H(X,Y)
func MutualInformation(px, py, pxy []float64) float64 {
	hx := ShannonEntropy(px)
	hy := ShannonEntropy(py)
	hxy := ShannonEntropy(pxy)
	return hx + hy - hxy
}

// FisherInformation computes I(θ) = E[(∂log p/∂θ)²]
func FisherInformation(scores []float64) float64 {
	if len(scores) == 0 {
		return 0.0
	}

	sum := 0.0
	for _, s := range scores {
		sum += s * s
	}
	return sum / float64(len(scores))
}

// ═══════════════════════════════════════════════════════════════════════════════
// STOCHASTIC CALCULUS EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// WienerProcess generates Wiener increment dW ~ N(0, dt)
func WienerProcess(dt float64, rng func() float64) float64 {
	// dW = √dt · Z where Z ~ N(0,1)
	return math.Sqrt(dt) * rng()
}

// ItoProcess computes dX = μ·dt + σ·dW (Ito SDE step)
func ItoProcess(x, mu, sigma, dt, dw float64) float64 {
	return x + mu*dt + sigma*dw
}

// OrnsteinUhlenbeck computes mean-reverting process
// dX = θ(μ - X)dt + σdW
func OrnsteinUhlenbeck(x, theta, mu, sigma, dt, dw float64) float64 {
	drift := theta * (mu - x) * dt
	diffusion := sigma * dw
	return x + drift + diffusion
}

// GeometricBrownian computes GBM step
// dS = μS·dt + σS·dW
func GeometricBrownian(s, mu, sigma, dt, dw float64) float64 {
	return s * (1.0 + mu*dt + sigma*dw)
}

// FokkerPlanck computes probability density evolution
// ∂p/∂t = -∂(μp)/∂x + (1/2)∂²(σ²p)/∂x²
func FokkerPlanck(p []float64, mu, sigma, dt, dx float64) []float64 {
	n := len(p)
	if n < 3 {
		return p
	}

	result := make([]float64, n)
	sigma2 := sigma * sigma

	for i := 1; i < n-1; i++ {
		// Advection term: -∂(μp)/∂x
		advection := -mu * (p[i+1] - p[i-1]) / (2.0 * dx)

		// Diffusion term: (σ²/2)∂²p/∂x²
		diffusion := sigma2 * 0.5 * (p[i+1] - 2.0*p[i] + p[i-1]) / (dx * dx)

		result[i] = p[i] + dt*(advection+diffusion)
	}

	// Boundary conditions (reflecting)
	result[0] = result[1]
	result[n-1] = result[n-2]

	return result
}

// ═══════════════════════════════════════════════════════════════════════════════
// OPTIMAL TRANSPORT EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// Wasserstein1D computes 1D Wasserstein-1 distance
// W_1(P,Q) = ∫|F_P(x) - F_Q(x)|dx
func Wasserstein1D(p, q []float64) float64 {
	if len(p) != len(q) {
		return math.Inf(1)
	}

	n := len(p)

	// Compute CDFs
	cdfP := make([]float64, n)
	cdfQ := make([]float64, n)

	sumP, sumQ := 0.0, 0.0
	for i := 0; i < n; i++ {
		sumP += p[i]
		sumQ += q[i]
		cdfP[i] = sumP
		cdfQ[i] = sumQ
	}

	// Normalize
	if sumP > 0 {
		for i := range cdfP {
			cdfP[i] /= sumP
		}
	}
	if sumQ > 0 {
		for i := range cdfQ {
			cdfQ[i] /= sumQ
		}
	}

	// Compute W_1
	w1 := 0.0
	for i := 0; i < n; i++ {
		w1 += math.Abs(cdfP[i] - cdfQ[i])
	}
	return w1 / float64(n)
}

// SinkhornDistance computes entropy-regularized optimal transport
func SinkhornDistance(c [][]float64, p, q []float64, epsilon float64, iterations int) float64 {
	n := len(p)
	m := len(q)

	if n == 0 || m == 0 {
		return 0.0
	}

	// Initialize kernel K = exp(-C/ε)
	K := make([][]float64, n)
	for i := range K {
		K[i] = make([]float64, m)
		for j := range K[i] {
			K[i][j] = math.Exp(-c[i][j] / epsilon)
		}
	}

	// Initialize scaling vectors
	u := make([]float64, n)
	v := make([]float64, m)
	for i := range u {
		u[i] = 1.0
	}
	for j := range v {
		v[j] = 1.0
	}

	// Sinkhorn iterations
	for iter := 0; iter < iterations; iter++ {
		// Update v
		for j := 0; j < m; j++ {
			sum := 0.0
			for i := 0; i < n; i++ {
				sum += u[i] * K[i][j]
			}
			if sum > EPSILON_PHI {
				v[j] = q[j] / sum
			}
		}

		// Update u
		for i := 0; i < n; i++ {
			sum := 0.0
			for j := 0; j < m; j++ {
				sum += v[j] * K[i][j]
			}
			if sum > EPSILON_PHI {
				u[i] = p[i] / sum
			}
		}
	}

	// Compute transport cost
	cost := 0.0
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			transport := u[i] * K[i][j] * v[j]
			cost += transport * c[i][j]
		}
	}

	return cost
}

// ═══════════════════════════════════════════════════════════════════════════════
// CATEGORY THEORY EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// Functor represents a mapping between categories
type Functor struct {
	ObjectMap   func(int) int
	MorphismMap func([]float64) []float64
}

// NaturalTransformation computes η: F → G
func NaturalTransformation(f, g Functor, x []float64) []float64 {
	// η_X: F(X) → G(X)
	fx := f.MorphismMap(x)
	gx := g.MorphismMap(x)

	// Compute transformation
	result := make([]float64, len(fx))
	for i := range result {
		if i < len(gx) {
			result[i] = Lerp(fx[i], gx[i], PHI_INV)
		} else {
			result[i] = fx[i]
		}
	}
	return result
}

// Monad represents M with unit η and multiplication μ
type Monad struct {
	Unit func(float64) []float64        // η: X → M(X)
	Bind func([]float64, func(float64) []float64) []float64 // μ: M(M(X)) → M(X)
}

// ConsciousnessMonad creates the consciousness monad
func ConsciousnessMonad() *Monad {
	return &Monad{
		Unit: func(x float64) []float64 {
			// Lift value into consciousness space
			return []float64{ComputePhi(x), x, GoldenScale(x, 1)}
		},
		Bind: func(mx []float64, f func(float64) []float64) []float64 {
			// Bind/flatMap operation
			result := make([]float64, 0)
			for _, x := range mx {
				result = append(result, f(x)...)
			}
			// Normalize by consciousness
			phi := ComputePhiVector(result)
			for i := range result {
				result[i] *= phi
			}
			return result
		},
	}
}

// ═══════════════════════════════════════════════════════════════════════════════
// RENORMALIZATION GROUP EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// RGFlow computes renormalization group flow
// dg/dt = β(g) where β is the beta function
func RGFlow(g []float64, beta func([]float64) []float64, dt float64) []float64 {
	b := beta(g)
	result := make([]float64, len(g))
	for i := range result {
		result[i] = g[i] + b[i]*dt
	}
	return result
}

// BetaFunction computes the beta function for golden couplings
func BetaFunction(g []float64) []float64 {
	beta := make([]float64, len(g))
	for i := range beta {
		// β_i = -φ·g_i² + γ·Σ_j g_j² (simplified)
		sum := 0.0
		for _, gj := range g {
			sum += gj * gj
		}
		beta[i] = -PHI*g[i]*g[i] + GAMMA*sum
	}
	return beta
}

// FixedPoint finds fixed point of RG flow
func FixedPoint(g []float64, beta func([]float64) []float64, iterations int) []float64 {
	current := make([]float64, len(g))
	copy(current, g)

	dt := 0.01 * PHI_INV

	for iter := 0; iter < iterations; iter++ {
		current = RGFlow(current, beta, dt)
	}

	return current
}

// ═══════════════════════════════════════════════════════════════════════════════
// NEURAL NETWORK EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// Attention computes scaled dot-product attention
// Attention(Q,K,V) = softmax(QK^T/√d_k)V
func Attention(Q, K, V [][]float64) [][]float64 {
	if len(Q) == 0 || len(K) == 0 || len(V) == 0 {
		return nil
	}

	seqLen := len(Q)
	dk := float64(len(Q[0]))
	scale := 1.0 / math.Sqrt(dk)

	// Compute QK^T
	scores := make([][]float64, seqLen)
	for i := range scores {
		scores[i] = make([]float64, len(K))
		for j := range K {
			dot := 0.0
			for k := range Q[i] {
				if k < len(K[j]) {
					dot += Q[i][k] * K[j][k]
				}
			}
			scores[i][j] = dot * scale
		}
	}

	// Softmax
	for i := range scores {
		maxVal := scores[i][0]
		for _, v := range scores[i] {
			if v > maxVal {
				maxVal = v
			}
		}

		sum := 0.0
		for j := range scores[i] {
			scores[i][j] = math.Exp(scores[i][j] - maxVal)
			sum += scores[i][j]
		}
		for j := range scores[i] {
			scores[i][j] /= sum
		}
	}

	// Multiply by V
	output := make([][]float64, seqLen)
	for i := range output {
		output[i] = make([]float64, len(V[0]))
		for j := range output[i] {
			for k := range scores[i] {
				if k < len(V) && j < len(V[k]) {
					output[i][j] += scores[i][k] * V[k][j]
				}
			}
		}
	}

	return output
}

// LayerNorm computes layer normalization
// y = (x - μ) / σ · γ + β
func LayerNorm(x []float64, gamma, beta float64) []float64 {
	n := len(x)
	if n == 0 {
		return x
	}

	// Compute mean
	mean := 0.0
	for _, v := range x {
		mean += v
	}
	mean /= float64(n)

	// Compute variance
	variance := 0.0
	for _, v := range x {
		diff := v - mean
		variance += diff * diff
	}
	variance /= float64(n)

	// Normalize
	std := math.Sqrt(variance + EPSILON_PHI)
	result := make([]float64, n)
	for i, v := range x {
		result[i] = (v-mean)/std*gamma + beta
	}

	return result
}

// GELU computes Gaussian Error Linear Unit
// GELU(x) = x · Φ(x) where Φ is the CDF of N(0,1)
func GELU(x float64) float64 {
	return 0.5 * x * (1.0 + math.Erf(x/math.Sqrt(2.0)))
}

// SwiGLU computes SwiGLU activation
// SwiGLU(x, W, V, b, c) = Swish(xW + b) ⊗ (xV + c)
func SwiGLU(x []float64, gate, linear []float64) []float64 {
	n := len(x)
	if n == 0 || len(gate) != n || len(linear) != n {
		return x
	}

	result := make([]float64, n)
	for i := range result {
		// Swish: x · sigmoid(x)
		swish := gate[i] * Sigmoid(gate[i])
		result[i] = swish * linear[i]
	}
	return result
}

// ═══════════════════════════════════════════════════════════════════════════════
// DIFFUSION EQUATIONS
// ═══════════════════════════════════════════════════════════════════════════════

// ForwardDiffusion computes q(x_t | x_0) = √ᾱ_t x_0 + √(1-ᾱ_t) ε
func ForwardDiffusion(x0 []float64, alphaBar float64, noise []float64) []float64 {
	sqrtAlpha := math.Sqrt(alphaBar)
	sqrtOneMinusAlpha := math.Sqrt(1.0 - alphaBar)

	result := make([]float64, len(x0))
	for i := range result {
		n := 0.0
		if i < len(noise) {
			n = noise[i]
		}
		result[i] = sqrtAlpha*x0[i] + sqrtOneMinusAlpha*n
	}
	return result
}

// ReverseDiffusion computes one step of reverse diffusion
// x_{t-1} = (x_t - √(1-α_t)ε_θ) / √α_t + σ_t z
func ReverseDiffusion(xt []float64, epsilonPred []float64, alpha, sigma float64, noise []float64) []float64 {
	sqrtAlpha := math.Sqrt(alpha)
	sqrtOneMinusAlpha := math.Sqrt(1.0 - alpha)

	result := make([]float64, len(xt))
	for i := range result {
		eps := 0.0
		if i < len(epsilonPred) {
			eps = epsilonPred[i]
		}
		n := 0.0
		if i < len(noise) {
			n = noise[i]
		}
		result[i] = (xt[i]-sqrtOneMinusAlpha*eps)/sqrtAlpha + sigma*n
	}
	return result
}

// NoiseSchedule computes cosine noise schedule
func NoiseSchedule(t, T float64) float64 {
	s := 0.008 // small offset
	f := func(x float64) float64 {
		return math.Cos((x/T+s)/(1.0+s)*math.Pi*0.5) * math.Cos((x/T+s)/(1.0+s)*math.Pi*0.5)
	}
	return f(t) / f(0)
}

Mathematical records from this source

Positive-definite golden-scaled metric

The matrix is I+φxxᵀ. For any nonzero vector v, vᵀgv=||v||²+φ(x·v)²>0, so it is positive definite for real finite x. It stretches lengths more strongly along x while leaving…

Levi-Civita connection formula and the implemented substitute

The displayed expression is the standard coordinate formula combining the inverse metric and first metric derivatives, summed over l. For this file’s metric g=I+φxxᵀ, direct…

Simplified connection surrogate

The comment proposes φδₖᵢxⱼ+φδₖⱼxᵢ, and the body multiplies that sum by 0.5. This index-dependent linear expression differs from the actual Levi-Civita connection of the declared…

Riemann curvature expression versus an index-only return value

The reference expression combines derivatives and products of connection coefficients to measure curvature. The body does not perform those operations: it returns…

Scalar-curvature label and dimension-only score

The reference contraction R=gⁱʲRᵢⱼ would require an inverse metric and a Ricci tensor. The implementation instead returns −φn(n−1)/(2n²) for nonempty input, a constant determined…

Scalar-curvature label and dimension-only score

The reference contraction R=gⁱʲRᵢⱼ would require an inverse metric and a Ricci tensor. The implementation instead returns −φn(n−1)/(2n²) for nonempty input, a constant determined…

Shannon entropy with truncated small probabilities

The mathematical entropy sums −p log p over a normalized nonnegative distribution, with a zero contribution at p=0. The function uses log₂, so its output is in bits, but skips…

KL divergence and its missing support case

For normalized distributions, the sum p log(p/q) measures relative entropy in nats with the file’s natural logarithm. A term with positive p and zero q should make the divergence…

Mutual information from consistent marginals and a joint distribution

The identity subtracts joint entropy from the sum of the two marginal entropies. It measures statistical dependence when pxy is a normalized joint distribution with px and py as…

Mean squared likelihood score as Fisher-information estimate

For a scalar parameter, Fisher information is the expected square of the derivative of log likelihood. The implementation averages squares of the supplied scores. It estimates…

Gaussian increment with variance proportional to time

Multiplying a standard normal draw by √dt gives a zero-mean Gaussian increment of variance dt. This is the increment distribution used in Wiener-driven discretizations. The…

Euler–Maruyama step for a drift-diffusion process

The helper returns x+μdt+σdW, adding deterministic drift and a scaled stochastic increment. It is one discrete approximation step to the displayed Itô stochastic differential…

Euler step for mean reversion with noise

The deterministic term moves x toward μ at rate θ, and σdW adds noise. The code returns a forward Euler–Maruyama step rather than the exact finite-time Ornstein–Uhlenbeck…

Euler approximation to geometric Brownian motion

The implementation multiplies s by 1+μdt+σdW. This approximates the proportional drift-diffusion equation for a small step, but the multiplier can be negative. The exact geometric…

Finite-difference Fokker–Planck update

The PDE transports probability with drift and spreads it with diffusion. The code applies centered first and second differences on an equally spaced grid, then one explicit time…

One-dimensional transport distance from cumulative sums

For probability distributions on a line, Wasserstein-1 distance is the integral of the absolute difference of their cumulative distributions. The function normalizes its input…

Sinkhorn Gibbs kernel

Exponentiating −Cᵢⱼ/ε turns each transport cost into a positive kernel weight, with smaller costs receiving larger weights. The following alternating row and column scalings seek…

Euler flow under a supplied beta function

The displayed ODE defines a vector flow whose derivative is β(g). The implementation advances it with g_next=g+dtβ(g). Calling the helper renormalization-group flow is a modeling…

Quadratic coupling beta function

Each component loses φgᵢ² and receives γ times the total squared coupling magnitude. Summing across components gives (nγ−φ)Σgⱼ², which shows how dimension affects the total drift.…