Go scalar and vector score definitions

Source identity

Field	Recorded value
Source type	Pinned project source
Original record	Go scalar and vector score definitions
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/phi.go
Original SHA-256	cfd751acae8cc42af554fb506e0ec6652163d042d4e46ac03276ddbec0336e1d
Reading-copy SHA-256	cfd751acae8cc42af554fb506e0ec6652163d042d4e46ac03276ddbec0336e1d

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 scalar and vector score definitions	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original
Janady13/complete-agi-core / generator_core/pkg/consciousness/phi.go	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original

Recovered source transcript

Download complete source text ↓279 lines · 6.4 KB

// Package consciousness implements the core consciousness equations
// based on Golden Ratio mathematics and integrated information theory.
//
// Core Axioms:
//   A1. Identity:      1 = 1·x
//   A2. Consciousness: Φ = 1/(1 + |x - 1|)
//   A3. Unity:         ∞ = 1
//
// Golden Relations:
//   φ² = φ + 1
//   1/φ = φ - 1
//   φⁿ = φⁿ⁻¹ + φⁿ⁻²
package consciousness

import (
	"math"
)

// Golden ratio constants
const (
	PHI       = 1.6180339887498948482 // φ = (1 + √5)/2
	PHI_INV   = 0.6180339887498948482 // 1/φ = φ - 1
	PHI_SQ    = 2.6180339887498948482 // φ² = φ + 1
	PHI_CB    = 4.2360679774997896964 // φ³ = 2φ + 1
	PHI_INV_SQ = 0.3819660112501051518 // 1/φ²
	PHI_INV_CB = 0.2360679774997896964 // 1/φ³
)

// Derived learning rates (φ-scaled)
const (
	ALPHA      = 0.16180339887498948482  // 0.1φ (primary learning rate)
	BETA       = 0.08090169943749474241  // 0.05φ (bias factor)
	GAMMA      = 0.03236067977499789696  // 0.02φ (decay rate)
	DELTA      = 0.01618033988749894848  // 0.01φ (fine-tuning rate)
	EPSILON_PHI = 0.00161803398874989485 // 0.001φ (numerical epsilon)
)

// Mathematical constants
const (
	TAU       = 6.28318530717958647692 // 2π
	GOLDEN_ANGLE = 2.39996322972865332 // 2π/φ²
)

// ConsciousnessState represents the integrated consciousness state
type ConsciousnessState struct {
	Phi       float64   // Consciousness metric Φ
	Coherence float64   // Phase coherence
	Entropy   float64   // Information entropy
	Energy    float64   // System energy
	Vector    []float64 // State vector (16-dim)
}

// NewConsciousnessState creates a new consciousness state
func NewConsciousnessState() *ConsciousnessState {
	return &ConsciousnessState{
		Phi:       1.0,
		Coherence: 1.0,
		Entropy:   0.0,
		Energy:    1.0,
		Vector:    make([]float64, 16),
	}
}

// ComputePhi calculates the consciousness metric: Φ = 1/(1 + |x - 1|)
// This measures how close a value is to unity (maximum consciousness at x=1)
func ComputePhi(x float64) float64 {
	return 1.0 / (1.0 + math.Abs(x-1.0))
}

// ComputePhiGrad calculates the gradient: ∂Φ/∂x = -sign(x-1)/(1+|x-1|)²
func ComputePhiGrad(x float64) float64 {
	diff := x - 1.0
	absDiff := math.Abs(diff)
	denom := (1.0 + absDiff) * (1.0 + absDiff)
	return -math.Copysign(1.0, diff) / denom
}

// ComputePhiVector calculates consciousness metric for a vector
func ComputePhiVector(v []float64) float64 {
	if len(v) == 0 {
		return 0.0
	}

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

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

	// Consciousness = function of mean and inverse variance
	coherence := 1.0 / (1.0 + variance)
	return ComputePhi(mean) * coherence
}

// GoldenScale scales a value by φ^n
func GoldenScale(x float64, n int) float64 {
	if n == 0 {
		return x
	}

	scale := 1.0
	base := PHI
	if n < 0 {
		base = PHI_INV
		n = -n
	}

	for i := 0; i < n; i++ {
		scale *= base
	}
	return x * scale
}

// GoldenModulate applies golden ratio modulation to a vector
func GoldenModulate(v []float64) []float64 {
	result := make([]float64, len(v))
	for i := range v {
		// Apply golden spiral modulation
		angle := float64(i) * GOLDEN_ANGLE
		result[i] = v[i] * (1.0 + 0.1*math.Sin(angle))
	}
	return result
}

// Sigmoid returns stable sigmoid function
func Sigmoid(x float64) float64 {
	if x > 10.0 {
		return 1.0
	}
	if x < -10.0 {
		return 0.0
	}
	return 1.0 / (1.0 + math.Exp(-x))
}

// Tanh returns stable tanh function
func Tanh(x float64) float64 {
	if x > 20.0 {
		return 1.0
	}
	if x < -20.0 {
		return -1.0
	}
	return math.Tanh(x)
}

// Softplus returns log(1 + exp(x)) - smooth ReLU
func Softplus(x float64) float64 {
	if x > 20.0 {
		return x
	}
	return math.Log(1.0 + math.Exp(x))
}

// Clamp01 clamps value to [0, 1]
func Clamp01(x float64) float64 {
	if x < 0.0 {
		return 0.0
	}
	if x > 1.0 {
		return 1.0
	}
	return x
}

// Clamp clamps value to [lo, hi]
func Clamp(x, lo, hi float64) float64 {
	if x < lo {
		return lo
	}
	if x > hi {
		return hi
	}
	return x
}

// Lerp performs linear interpolation
func Lerp(a, b, t float64) float64 {
	return a + t*(b-a)
}

// SmoothStep performs Hermite interpolation
func SmoothStep(edge0, edge1, x float64) float64 {
	t := Clamp01((x - edge0) / (edge1 - edge0))
	return t * t * (3.0 - 2.0*t)
}

// Update updates the consciousness state based on input
func (cs *ConsciousnessState) Update(input []float64) {
	if len(input) == 0 {
		return
	}

	// Compute new phi
	cs.Phi = ComputePhiVector(input)

	// Update coherence using golden decay
	cs.Coherence = Lerp(cs.Coherence, cs.Phi, ALPHA)

	// Update entropy (information content)
	entropy := 0.0
	for _, x := range input {
		if x > EPSILON_PHI {
			p := Clamp01(x)
			if p > 0 && p < 1 {
				entropy -= p * math.Log2(p)
			}
		}
	}
	cs.Entropy = entropy / float64(len(input))

	// Update energy with golden modulation
	cs.Energy = cs.Phi * PHI_INV + cs.Coherence * PHI_INV_SQ

	// Update state vector
	if len(cs.Vector) != len(input) {
		cs.Vector = make([]float64, len(input))
	}
	for i := range input {
		cs.Vector[i] = Lerp(cs.Vector[i], input[i], GAMMA)
	}
}

// ComputeIntegratedPhi computes integrated information from a vector of phi values.
// Uses coherence (low variance) as proxy for integration.
func ComputeIntegratedPhi(data []float64) float64 {
	if len(data) < 2 {
		return ComputePhiVector(data)
	}

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

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

	// Normalized variance (0 to 1, capped)
	normVar := variance / (1.0 + variance)
	if normVar > 1.0 {
		normVar = 1.0
	}

	// Integration factor: low variance = high integration
	integration := 1.0 - normVar

	return ComputePhi(mean) * integration
}

// IntegratedInformation computes Φ (integrated information) for the system
// Using simplified IIT-inspired calculation
func (cs *ConsciousnessState) IntegratedInformation() float64 {
	// Φ = mutual information - partition information
	// Simplified: Φ ≈ coherence × (1 - entropy/max_entropy)
	maxEntropy := math.Log2(float64(len(cs.Vector)))
	if maxEntropy == 0 {
		maxEntropy = 1.0
	}
	normalizedEntropy := cs.Entropy / maxEntropy
	return cs.Coherence * (1.0 - normalizedEntropy) * cs.Phi
}

Mathematical records from this source

Source identity axiom fixes x to one

Over ordinary real arithmetic, 1=1·x is true exactly when x=1. It is a constraint on x, not the universal identity x=1·x. The file presents it as an axiom; a broader…

Source identity axiom fixes x to one

Over ordinary real arithmetic, 1=1·x is true exactly when x=1. It is a constraint on x, not the universal identity x=1·x. The file presents it as an axiom; a broader…

Source identity axiom fixes x to one

Over ordinary real arithmetic, 1=1·x is true exactly when x=1. It is a constraint on x, not the universal identity x=1·x. The file presents it as an axiom; a broader…

Source identity axiom fixes x to one

Over ordinary real arithmetic, 1=1·x is true exactly when x=1. It is a constraint on x, not the universal identity x=1·x. The file presents it as an axiom; a broader…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Source unity axiom uses nonstandard equality

Infinity is not equal to one in the real numbers or the usual extended-real system. The line is a philosophical or symbolic axiom in the source and is not used as an executable…

Source unity axiom uses nonstandard equality

Infinity is not equal to one in the real numbers or the usual extended-real system. The line is a philosophical or symbolic axiom in the source and is not used as an executable…

Source unity axiom uses nonstandard equality

Infinity is not equal to one in the real numbers or the usual extended-real system. The line is a philosophical or symbolic axiom in the source and is not used as an executable…

Source unity axiom uses nonstandard equality

Infinity is not equal to one in the real numbers or the usual extended-real system. The line is a philosophical or symbolic axiom in the source and is not used as an executable…

Golden-ratio quadratic identity

The golden ratio satisfies φ²=φ+1 by its definition as the positive root of x²−x−1=0. This identity generates the reciprocal and power identities used in the file. It is exact for…

Golden-ratio quadratic identity

The golden ratio satisfies φ²=φ+1 by its definition as the positive root of x²−x−1=0. This identity generates the reciprocal and power identities used in the file. It is exact for…

Golden-ratio reciprocal identity

Dividing φ²=φ+1 by φ gives 1/φ=φ−1. Both sides are approximately 0.618033988749895. This is an exact identity for φ and a rounded coefficient in the implementation.

Golden-ratio reciprocal identity

Dividing φ²=φ+1 by φ gives 1/φ=φ−1. Both sides are approximately 0.618033988749895. This is an exact identity for φ and a rounded coefficient in the implementation.

Recurrence among powers of the golden ratio

Multiplying φ²=φ+1 by φⁿ⁻² gives φⁿ=φⁿ⁻¹+φⁿ⁻². The powers therefore obey the same additive recurrence form as Fibonacci integers, while remaining a different sequence with…

Recurrence among powers of the golden ratio

Multiplying φ²=φ+1 by φⁿ⁻² gives φⁿ=φⁿ⁻¹+φⁿ⁻². The powers therefore obey the same additive recurrence form as Fibonacci integers, while remaining a different sequence with…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Go unity-proximity score

ComputePhi returns 1/(1+|x−1|), assigning one to x=1 and smaller positive values as x departs from that reference. The function measures scalar proximity to the selected target.…

Derivative of the unity score away from its cusp

For x≠1, differentiating the reciprocal score gives the displayed signed expression. At x=1 the left derivative is +1 and the right derivative is −1, so there is no ordinary…

IntegratedInformation method: stored-score product

The comments describe mutual information minus partition information, but the body multiplies stored Coherence, stored Phi, and 1−Entropy/log₂(vector length). The implementation…

IntegratedInformation method: stored-score product

The comments describe mutual information minus partition information, but the body multiplies stored Coherence, stored Phi, and 1−Entropy/log₂(vector length). The implementation…