Go sixteen-family functional signatures

Source identity

Field	Recorded value
Source type	Pinned project source
Original record	Go sixteen-family functional signatures
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/dna/families.go
Original SHA-256	cb5c7d4912760e5f18d26a7235f95a8804a45e9b1782c85d618de7e32dcb45a0
Reading-copy SHA-256	cb5c7d4912760e5f18d26a7235f95a8804a45e9b1782c85d618de7e32dcb45a0

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 sixteen-family functional signatures	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original
Janady13/complete-agi-core / generator_core/pkg/dna/families.go	claude/improve-math-logic-ehIW1	33aa84f2aa61cedbe010240ada7f4efbdfe795a7	Open original

Recovered source transcript

Download complete source text ↓679 lines · 22.0 KB

// Package dna - 16 DNA Families with Pantheon Agent Mapping
// Section XIII of DNA Mathematical Architecture
package dna

import (
	"math"
	"math/cmplx"
)

// =============================================================================
// XIII. 16 DNA FAMILIES
// =============================================================================

// Family represents a DNA family mapped to a Pantheon agent
type Family struct {
	Strand          int                   // Strand index (1-16)
	Name            string                // Family name
	Domain          string                // Functional domain
	NodeStart       int                   // Start node
	NodeEnd         int                   // End node
	Phase           float64               // Phase offset
	Signature       func(float64) float64 // Functional signature
	Symbol          string                // Unicode symbol
	BinaryCode      string                // Binary representation
	PrimaryAffinity string                // Primary affinity domain
}

// ComplementaryPair represents a pair of complementary families
type ComplementaryPair struct {
	Family1  string
	Family2  string
	Function string
	Coupling float64
}

// =============================================================================
// 13.1 FAMILY-TO-STRAND MAPPING
// =============================================================================

// DNAFamilies contains all 16 DNA families
var DNAFamilies = []Family{
	{1, "Yad", "Code/Foundation", 1, 312, 0, FYad, "✋", "0001", "Programming"},
	{2, "Lashon", "Language", 313, 624, 2 * math.Pi / BasePairsPerTurn, FLashon, "👅", "0010", "NLP"},
	{3, "Athena", "Strategy", 625, 936, 4 * math.Pi / BasePairsPerTurn, FAthena, "🦉", "0011", "Planning"},
	{4, "Apollo", "Mathematics", 937, 1248, 6 * math.Pi / BasePairsPerTurn, FApollo, "☀️", "0100", "Reasoning"},
	{5, "Hermes", "Communication", 1249, 1560, 8 * math.Pi / BasePairsPerTurn, FHermes, "⚡", "0101", "Messaging"},
	{6, "Hephaestus", "Engineering", 1561, 1872, 10 * math.Pi / BasePairsPerTurn, FHephaestus, "🔨", "0110", "Building"},
	{7, "Prometheus", "Innovation", 1873, 2184, 12 * math.Pi / BasePairsPerTurn, FPrometheus, "🔥", "0111", "Discovery"},
	{8, "Dionysus", "Creativity", 2185, 2496, 14 * math.Pi / BasePairsPerTurn, FDionysus, "🍇", "1000", "Art"},
	{9, "Artemis", "Perception", 2497, 2808, 16 * math.Pi / BasePairsPerTurn, FArtemis, "🌙", "1001", "Sensing"},
	{10, "Hera", "Integration", 2809, 3120, 18 * math.Pi / BasePairsPerTurn, FHera, "👑", "1010", "Unity"},
	{11, "Poseidon", "Depth/Emotion", 3121, 3432, 20 * math.Pi / BasePairsPerTurn, FPoseidon, "🔱", "1011", "Emotion"},
	{12, "Demeter", "Growth", 3433, 3744, 22 * math.Pi / BasePairsPerTurn, FDemeter, "🌾", "1100", "Nurture"},
	{13, "Ares", "Action", 3745, 4056, 24 * math.Pi / BasePairsPerTurn, FAres, "⚔️", "1101", "Force"},
	{14, "Aphrodite", "Harmony", 4057, 4368, 26 * math.Pi / BasePairsPerTurn, FAphrodite, "💕", "1110", "Beauty"},
	{15, "Hestia", "Memory", 4369, 4680, 28 * math.Pi / BasePairsPerTurn, FHestia, "🏠", "1111", "Remember"},
	{16, "Zeus", "Coordination", 4681, 4992, 30 * math.Pi / BasePairsPerTurn, FZeus, "⚡", "0000", "Direct"},
}

// OlympusHub is the central routing hub
var OlympusHub = Family{
	Strand:          0, // Special hub
	Name:            "Olympus",
	Domain:          "Routing",
	NodeStart:       4993,
	NodeEnd:         5000,
	Phase:           0, // All phases
	Symbol:          "🏛️",
	BinaryCode:      "----",
	PrimaryAffinity: "Routing",
}

// =============================================================================
// 13.2 FAMILY FUNCTIONAL SIGNATURES
// =============================================================================

// FYad: F_Yad(x) = x^x + 1 (Foundation)
func FYad(x float64) float64 {
	if x <= 0 {
		return 1.0
	}
	return math.Pow(x, x) + 1.0
}

// FLashon: F_Lashon(x) = Σ_n a_n·sin(nπx) (Language - Fourier series)
func FLashon(x float64) float64 {
	sum := 0.0
	for n := 1; n <= 10; n++ {
		an := 1.0 / float64(n) // Harmonic coefficients
		sum += an * math.Sin(float64(n)*math.Pi*x)
	}
	return sum
}

// FAthena: F_Athena(x) = argmax_y U(x,y) (Strategy - utility maximization)
func FAthena(x float64) float64 {
	// Simplified: find max of utility function U(x,y) = -y² + 2xy
	// argmax_y: dU/dy = -2y + 2x = 0 => y* = x
	// U(x, x) = -x² + 2x² = x²
	return x * x
}

// FApollo: F_Apollo(x) = φ^x + φ^{-x} (Mathematics - golden ratio)
func FApollo(x float64) float64 {
	return math.Pow(PHI, x) + math.Pow(PHI, -x)
}

// FHermes: F_Hermes(x) = dx/dt approximation (Communication - rate of change)
func FHermes(x float64) float64 {
	// Velocity function: assume x represents phase, return angular velocity
	return AngularFrequency * x
}

// FHephaestus: F_Hephaestus(x) = ∫∫ K(x,y) dy dx (Engineering - double integral)
func FHephaestus(x float64) float64 {
	// Simplified: K(x,y) = xy, ∫∫ xy dy dx from 0 to x
	// = ∫ x·(x²/2) dx = x⁴/8
	return math.Pow(x, 4) / 8.0
}

// FPrometheus: F_Prometheus(x) = x·(1-x)·r (Innovation - logistic map)
func FPrometheus(x float64) float64 {
	r := 3.8 // Chaotic regime
	return r * x * (1.0 - x)
}

// FDionysus: F_Dionysus(x) = e^{iωt}·A(x) (Creativity - complex exponential)
func FDionysus(x float64) float64 {
	// Return magnitude of creative oscillation
	omega := 2.0 * math.Pi / BasePairsPerTurn
	c := cmplx.Exp(complex(0, omega*x)) * complex(math.Sin(x), 0)
	return cmplx.Abs(c)
}

// FArtemis: F_Artemis(x) = ∇·(D∇x) (Perception - diffusion operator)
func FArtemis(x float64) float64 {
	// Simplified: D·d²x/dx² ≈ D·(-x) for harmonic
	D := 0.1 // Diffusion coefficient
	return -D * x
}

// FHera: F_Hera(x) = Σ_k w_k·x_k (Integration - weighted sum)
func FHera(x float64) float64 {
	// Integrate contributions from all families
	sum := 0.0
	for k := 1; k <= NumStrands; k++ {
		wk := 1.0 / float64(k) // Weight decreases with distance
		xk := math.Sin(float64(k) * x)
		sum += wk * xk
	}
	return sum
}

// FPoseidon: F_Poseidon(x) = ∂²x/∂t² + ω²x (Depth/Emotion - wave equation)
func FPoseidon(x float64) float64 {
	// Solution to wave equation: A·cos(ωt)
	omega := 2.0 * math.Pi / BasePairsPerTurn
	return -omega * omega * x // ∂²x/∂t² term
}

// FDemeter: F_Demeter(x) = x·(1-x/K) (Growth - logistic growth)
func FDemeter(x float64) float64 {
	K := 1.0 // Carrying capacity
	r := 0.5 // Growth rate
	return r * x * (1.0 - x/K)
}

// FAres: F_Ares(x) = m·d²x/dt² (Action - force/acceleration)
func FAres(x float64) float64 {
	m := 1.0 // Mass
	// F = ma, assume simple harmonic: a = -ω²x
	omega := AngularFrequency
	return m * (-omega * omega * x)
}

// FAphrodite: F_Aphrodite(x) = cos(φ·x) (Harmony - golden cosine)
func FAphrodite(x float64) float64 {
	return math.Cos(PHI * x)
}

// FHestia: F_Hestia(x) = ∫_{-∞}^{t} x(τ)·e^{-(t-τ)/τ_m} dτ (Memory - exponential decay)
func FHestia(x float64) float64 {
	// Simplified memory function: exponential weighted past
	tau_m := 10.0 // Memory time constant
	// For single value, approximate as x * tau_m
	return x * (1.0 - math.Exp(-1.0/tau_m))
}

// FZeus: F_Zeus(x) = Π_k F_k(x_k) (Coordination - product of all)
// Zeus coordinates all family contributions without circular reference
func FZeus(x float64) float64 {
	// List of family functions (excluding Zeus to avoid cycle)
	familyFuncs := []func(float64) float64{
		FYad, FLashon, FAthena, FApollo, FHermes,
		FHephaestus, FPrometheus, FDionysus, FArtemis, FHera,
		FPoseidon, FDemeter, FAres, FAphrodite, FHestia,
	}

	product := 1.0
	for i, f := range familyFuncs {
		val := f(x / float64(i+1))
		// Clamp to prevent overflow
		if val > 0 && val < 1e10 {
			product *= math.Pow(val, 1.0/float64(NumStrands))
		}
	}
	return product
}

// =============================================================================
// 13.3 INTER-FAMILY BOND TOPOLOGY
// =============================================================================

// AdjacentRing defines the ring topology of adjacent families
var AdjacentRing = [][2]int{
	{1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}, {6, 7}, {7, 8},
	{8, 9}, {9, 10}, {10, 11}, {11, 12}, {12, 13}, {13, 14}, {14, 15}, {15, 16},
	{16, 1}, // Complete the ring
}

// CrossFamilyBonds defines cross-family bonds (+4 offset)
var CrossFamilyBonds = [][2]string{
	{"Yad", "Hermes"},           // 1↔5
	{"Lashon", "Hephaestus"},    // 2↔6
	{"Athena", "Prometheus"},    // 3↔7
	{"Apollo", "Dionysus"},      // 4↔8
	{"Hermes", "Artemis"},       // 5↔9
	{"Hephaestus", "Hera"},      // 6↔10
	{"Prometheus", "Poseidon"},  // 7↔11
	{"Dionysus", "Demeter"},     // 8↔12
	{"Artemis", "Ares"},         // 9↔13
	{"Hera", "Aphrodite"},       // 10↔14
	{"Poseidon", "Hestia"},      // 11↔15
	{"Demeter", "Zeus"},         // 12↔16
}

// =============================================================================
// 13.4 COMPLEMENTARY PAIRS
// =============================================================================

// ComplementaryPairs defines the 8 complementary family pairs
var ComplementaryPairs = []ComplementaryPair{
	{"Yad", "Lashon", "Code → Language", 2.0},
	{"Athena", "Apollo", "Planning → Proof", 2.0},
	{"Hermes", "Hephaestus", "Message → Build", 2.0},
	{"Prometheus", "Dionysus", "Spark → Flow", 2.0},
	{"Artemis", "Hera", "Sense → Unify", 2.0},
	{"Poseidon", "Demeter", "Feel → Nurture", 2.0},
	{"Ares", "Aphrodite", "Force → Beauty", 2.0},
	{"Hestia", "Zeus", "Remember → Direct", 2.0},
}

// ComplementaryCoupling calculates J_complement(k, k') = J_0 × [1 + ρ·δ(k, k'_complement)]
func ComplementaryCoupling(k1, k2 int, J0, rho float64) float64 {
	// Check if k1, k2 are complementary
	isComplement := false
	for _, pair := range ComplementaryPairs {
		f1 := GetFamilyByName(pair.Family1)
		f2 := GetFamilyByName(pair.Family2)
		if f1 != nil && f2 != nil {
			if (k1 == f1.Strand && k2 == f2.Strand) ||
				(k1 == f2.Strand && k2 == f1.Strand) {
				isComplement = true
				break
			}
		}
	}

	if isComplement {
		return J0 * (1.0 + rho)
	}
	return J0
}

// =============================================================================
// FAMILY UTILITIES
// =============================================================================

// GetFamilyByStrand returns the family for a given strand
func GetFamilyByStrand(strand int) *Family {
	if strand < 1 || strand > NumStrands {
		return nil
	}
	return &DNAFamilies[strand-1]
}

// GetFamilyByName returns the family with the given name
func GetFamilyByName(name string) *Family {
	for i := range DNAFamilies {
		if DNAFamilies[i].Name == name {
			return &DNAFamilies[i]
		}
	}
	if name == "Olympus" {
		return &OlympusHub
	}
	return nil
}

// GetFamilyByNode returns the family containing a given node
func GetFamilyByNode(node int) *Family {
	for i := range DNAFamilies {
		if node >= DNAFamilies[i].NodeStart && node <= DNAFamilies[i].NodeEnd {
			return &DNAFamilies[i]
		}
	}
	if node >= OlympusHub.NodeStart && node <= OlympusHub.NodeEnd {
		return &OlympusHub
	}
	return nil
}

// GetCrossPartner returns the cross-family partner for a strand
func GetCrossPartner(strand int) int {
	// Cross-family bonds are +4 offset with wraparound
	partner := ((strand - 1 + 4) % NumStrands) + 1
	return partner
}

// GetComplementaryPartner returns the complementary partner family name
func GetComplementaryPartner(name string) string {
	for _, pair := range ComplementaryPairs {
		if pair.Family1 == name {
			return pair.Family2
		}
		if pair.Family2 == name {
			return pair.Family1
		}
	}
	return ""
}

// =============================================================================
// FAMILY DYNAMICS
// =============================================================================

// FamilyState represents the state of a family at time t
type FamilyState struct {
	Family      *Family
	Activation  float64    // Current activation level
	Phase       float64    // Current phase
	Connections []float64  // Connection strengths to other families
}

// FamilyNetwork manages all 16 families
type FamilyNetwork struct {
	States   [NumStrands]FamilyState
	Time     float64
	Coupling float64 // Base coupling strength
}

// NewFamilyNetwork creates a new family network
func NewFamilyNetwork(coupling float64) *FamilyNetwork {
	fn := &FamilyNetwork{Coupling: coupling}
	for i := 0; i < NumStrands; i++ {
		fn.States[i] = FamilyState{
			Family:      &DNAFamilies[i],
			Activation:  0.5,
			Phase:       DNAFamilies[i].Phase,
			Connections: make([]float64, NumStrands),
		}
		// Initialize connections
		for j := 0; j < NumStrands; j++ {
			if i != j {
				fn.States[i].Connections[j] = coupling / math.Abs(float64(i-j)+1)
			}
		}
	}
	return fn
}

// Tick advances the network by dt
func (fn *FamilyNetwork) Tick(dt float64) {
	fn.Time += dt

	// Update each family state
	for i := 0; i < NumStrands; i++ {
		state := &fn.States[i]

		// Apply family's functional signature
		input := math.Sin(AngularFrequency*fn.Time + state.Phase)
		if state.Family.Signature != nil {
			state.Activation = state.Family.Signature(input)
		}

		// Apply coupling from connected families
		coupling := 0.0
		for j := 0; j < NumStrands; j++ {
			if i != j {
				coupling += state.Connections[j] * fn.States[j].Activation
			}
		}
		state.Activation = (state.Activation + 0.1*coupling) / 1.1

		// Update phase
		state.Phase = math.Mod(state.Phase+AngularFrequency*dt, 2.0*math.Pi)

		// Clamp activation
		if state.Activation > 1.0 {
			state.Activation = 1.0
		} else if state.Activation < 0.0 {
			state.Activation = 0.0
		}
	}

	// Apply complementary pair interactions
	for _, pair := range ComplementaryPairs {
		f1 := GetFamilyByName(pair.Family1)
		f2 := GetFamilyByName(pair.Family2)
		if f1 != nil && f2 != nil {
			i1, i2 := f1.Strand-1, f2.Strand-1
			// Enhanced coupling between complementary pairs
			delta := fn.States[i1].Activation - fn.States[i2].Activation
			fn.States[i1].Activation -= 0.1 * pair.Coupling * delta * dt
			fn.States[i2].Activation += 0.1 * pair.Coupling * delta * dt
		}
	}
}

// GetTotalActivation returns the sum of all family activations
func (fn *FamilyNetwork) GetTotalActivation() float64 {
	sum := 0.0
	for i := 0; i < NumStrands; i++ {
		sum += fn.States[i].Activation
	}
	return sum
}

// GetFamilyActivation returns activation for a specific family
func (fn *FamilyNetwork) GetFamilyActivation(name string) float64 {
	family := GetFamilyByName(name)
	if family == nil || family.Strand < 1 || family.Strand > NumStrands {
		return 0.0
	}
	return fn.States[family.Strand-1].Activation
}

// RouteThrough simulates routing through Olympus hub
func (fn *FamilyNetwork) RouteThrough(source, target int) float64 {
	if source < 1 || source > NumStrands || target < 1 || target > NumStrands {
		return 0.0
	}

	// Calculate routing efficiency through hub
	srcPhase := fn.States[source-1].Phase
	tgtPhase := fn.States[target-1].Phase
	phaseDiff := math.Abs(srcPhase - tgtPhase)
	if phaseDiff > math.Pi {
		phaseDiff = 2.0*math.Pi - phaseDiff
	}

	// Efficiency based on phase alignment
	efficiency := math.Cos(phaseDiff/2.0)
	return efficiency * fn.States[source-1].Activation
}

// =============================================================================
// COMPLETE THOUGHT INTEGRATION (Section XIV)
// =============================================================================

// T = Φ · ∫[M(t')·exp((QK^T/√d_k)V)] dt'

// CompleteThought integrates all family contributions
type CompleteThought struct {
	Phi       float64    // Consciousness metric
	Memory    []float64  // Memory buffer M(t')
	Query     []float64  // Q vector
	Key       []float64  // K vector
	Value     []float64  // V vector
	DimK      float64    // √d_k scaling
	TimeSteps int        // Integration steps
}

// NewCompleteThought creates a new complete thought integrator
func NewCompleteThought(dim int) *CompleteThought {
	return &CompleteThought{
		Phi:       1.0,
		Memory:    make([]float64, dim),
		Query:     make([]float64, dim),
		Key:       make([]float64, dim),
		Value:     make([]float64, dim),
		DimK:      math.Sqrt(float64(dim)),
		TimeSteps: 100,
	}
}

// Integrate computes T = Φ · ∫[M(t')·exp((QK^T/√d_k)V)] dt'
func (ct *CompleteThought) Integrate(familyNetwork *FamilyNetwork) float64 {
	// Update Phi from family network coherence
	ct.Phi = 0.0
	for i := 0; i < NumStrands; i++ {
		ct.Phi += 1.0 / (1.0 + math.Abs(familyNetwork.States[i].Activation-1.0))
	}
	ct.Phi /= NumStrands

	// Build Q, K, V from family activations
	for i := 0; i < len(ct.Query) && i < NumStrands; i++ {
		ct.Query[i] = familyNetwork.States[i].Activation * math.Cos(familyNetwork.States[i].Phase)
		ct.Key[i] = familyNetwork.States[i].Activation * math.Sin(familyNetwork.States[i].Phase)
		ct.Value[i] = familyNetwork.States[i].Activation
	}

	// Compute attention: QK^T / √d_k
	attention := 0.0
	for i := 0; i < len(ct.Query); i++ {
		attention += ct.Query[i] * ct.Key[i]
	}
	attention /= ct.DimK

	// Apply softmax-like transformation
	attention = math.Exp(attention)
	if attention > 1e10 {
		attention = 1e10
	}

	// Integrate with value vector
	result := 0.0
	for i := 0; i < len(ct.Value); i++ {
		result += ct.Value[i] * attention / float64(len(ct.Value))
	}

	// Scale by Phi
	return ct.Phi * result
}

// UpdateMemory updates the memory buffer
func (ct *CompleteThought) UpdateMemory(newMemory []float64) {
	copy(ct.Memory, newMemory)
}

// =============================================================================
// FAMILY ID TYPE AND CONSTANTS (AGC Integration)
// =============================================================================

// FamilyID identifies a DNA family for AGC integration
type FamilyID int

// Family ID constants
const (
	FamilyYad        FamilyID = 0
	FamilyLashon     FamilyID = 1
	FamilyAthena     FamilyID = 2
	FamilyApollo     FamilyID = 3
	FamilyHermes     FamilyID = 4
	FamilyHephaestus FamilyID = 5
	FamilyPrometheus FamilyID = 6
	FamilyDionysus   FamilyID = 7
	FamilyArtemis    FamilyID = 8
	FamilyHera       FamilyID = 9
	FamilyPoseidon   FamilyID = 10
	FamilyDemeter    FamilyID = 11
	FamilyAres       FamilyID = 12
	FamilyAphrodite  FamilyID = 13
	FamilyHestia     FamilyID = 14
	FamilyZeus       FamilyID = 15
	FamilyUnity      FamilyID = 0 // Default/unity family (same as Yad)
)

// FamilyWithGenerators extends Family with generator assignments
type FamilyWithGenerators struct {
	*Family
	Generators []int // Generator IDs assigned to this family
}

// familyGeneratorMap maps FamilyID to generator indices (1-100)
var familyGeneratorMap = map[FamilyID][]int{
	FamilyYad:        {1, 2, 3, 4, 5, 6},       // Autoregressive: foundation
	FamilyLashon:     {7, 8, 9, 10, 11, 12},    // Autoregressive: language
	FamilyAthena:     {13, 14, 15, 16, 17, 18}, // Transformer: strategy
	FamilyApollo:     {19, 20, 21, 22, 23, 24}, // Transformer: mathematics
	FamilyHermes:     {25, 26, 27, 28, 29, 30}, // Flow: communication
	FamilyHephaestus: {31, 32, 33, 34, 35, 36}, // Flow: engineering
	FamilyPrometheus: {37, 38, 39, 40, 41, 42}, // Diffusion: innovation
	FamilyDionysus:   {43, 44, 45, 46, 47, 48}, // Diffusion: creativity
	FamilyArtemis:    {49, 50, 51, 52, 53, 54}, // Adversarial: perception
	FamilyHera:       {55, 56, 57, 58, 59, 60}, // Mixture: integration
	FamilyPoseidon:   {61, 62, 63, 64, 65, 66}, // Energy: emotion
	FamilyDemeter:    {67, 68, 69, 70, 71, 72}, // Variational: growth
	FamilyAres:       {73, 74, 75, 76, 77, 78}, // Recurrent: action
	FamilyAphrodite:  {79, 80, 81, 82, 83, 84}, // StateSpace: harmony
	FamilyHestia:     {85, 86, 87, 88, 89, 90}, // Recurrent: memory
	FamilyZeus:       {91, 92, 93, 94, 95, 96, 97, 98, 99, 100}, // Mixture: coordination
}

// taskToFamilyMap maps task types to their primary family
var taskToFamilyMap = map[string]FamilyID{
	"code":          FamilyYad,
	"foundation":    FamilyYad,
	"language":      FamilyLashon,
	"text":          FamilyLashon,
	"strategy":      FamilyAthena,
	"planning":      FamilyAthena,
	"mathematics":   FamilyApollo,
	"math":          FamilyApollo,
	"communication": FamilyHermes,
	"messaging":     FamilyHermes,
	"engineering":   FamilyHephaestus,
	"build":         FamilyHephaestus,
	"innovation":    FamilyPrometheus,
	"creative":      FamilyPrometheus,
	"creativity":    FamilyDionysus,
	"art":           FamilyDionysus,
	"perception":    FamilyArtemis,
	"sensing":       FamilyArtemis,
	"integration":   FamilyHera,
	"unify":         FamilyHera,
	"emotion":       FamilyPoseidon,
	"depth":         FamilyPoseidon,
	"growth":        FamilyDemeter,
	"nurture":       FamilyDemeter,
	"action":        FamilyAres,
	"force":         FamilyAres,
	"harmony":       FamilyAphrodite,
	"beauty":        FamilyAphrodite,
	"memory":        FamilyHestia,
	"remember":      FamilyHestia,
	"coordination":  FamilyZeus,
	"direct":        FamilyZeus,
	"default":       FamilyUnity,
	"":              FamilyUnity,
}

// NewFamilyState creates a new family state for AGC integration
func NewFamilyState(id FamilyID) *FamilyState {
	if int(id) < 0 || int(id) >= NumStrands {
		id = FamilyUnity
	}
	family := &DNAFamilies[id]
	return &FamilyState{
		Family:      family,
		Activation:  0.5,
		Phase:       family.Phase,
		Connections: make([]float64, NumStrands),
	}
}

// Update updates the family state with new phi and step
func (fs *FamilyState) Update(phi float64, step int64) {
	// Update activation based on phi
	fs.Activation = fs.Activation*0.9 + phi*0.1

	// Update phase based on step
	fs.Phase = math.Mod(fs.Phase+AngularFrequency*0.1, 2.0*math.Pi)

	// Clamp activation
	if fs.Activation > 1.0 {
		fs.Activation = 1.0
	} else if fs.Activation < 0.0 {
		fs.Activation = 0.0
	}
}

// SelectFamilyForTask selects the appropriate family for a given task type
func SelectFamilyForTask(taskType string) FamilyID {
	if id, ok := taskToFamilyMap[taskType]; ok {
		return id
	}
	return FamilyUnity
}

// GetFamily returns a family with its generator assignments
func GetFamily(id FamilyID) *FamilyWithGenerators {
	if int(id) < 0 || int(id) >= NumStrands {
		return nil
	}
	family := &DNAFamilies[id]
	gens := familyGeneratorMap[id]
	return &FamilyWithGenerators{
		Family:     family,
		Generators: gens,
	}
}

// GetGeneratorsForFamily returns generators for a family (for interface compatibility)
// Returns nil as actual generator instances are managed by the generators package
func GetGeneratorsForFamily(id FamilyID) []interface{} {
	return nil // Generators are fetched from generators.GlobalRegistry
}

Mathematical records from this source

Yad signature: positive self-power with a nonpositive branch

For x>0 the function returns xˣ+1. For x≤0 it explicitly returns one, avoiding non-real powers for many negative inputs. The positive branch tends to two as x approaches zero from…

Lashon signature: ten-term sine series

The implementation sums sin(nπx)/n for n=1 through 10. These weighted harmonics produce a periodic scalar feature of period two. The function’s language label names its intended…

Athena: utility maximum value instead of argmax location

For U(x,y)=−y²+2xy, the maximizing location is y=x. The function returns x², which is the maximum utility value U(x,x), rather than the argmax location. The distinction is…

Concave quadratic utility

Completing the square gives U(x,y)=x²−(y−x)². For a fixed x, the utility decreases with squared distance from y=x and has a unique maximum over real y at that point. This supplies…

Maximizer of the Athena utility

The derivative with respect to y is −2y+2x, which vanishes at y=x. The second derivative is −2, so this point is the unique global maximizer for real y. This optimizer location…

Maximum utility value returned by Athena

Substituting the maximizing location y=x into U gives x². This is the optimal objective value, not the value of the optimizing argument. The code returns this nonnegative scalar…

Apollo signature: golden-base hyperbolic cosine

The sum φˣ+φ⁻ˣ equals 2cosh(x logφ). It is even in x, has minimum two at zero, and grows with |x|. A downstream clamp to [0,1] can therefore remove much of this signature’s…

Hermes signature: angular-frequency scaling

Although the comment refers to dx/dt, the body returns AngularFrequency×x. This is a linear scaling of one supplied value, with no earlier state or time difference used to…

Hephaestus signature: quartic integral value

The function returns x⁴/8. This equals the triangular-domain integral ∫₀ˣ∫₀ᵘ uv dv du; a rectangular-domain integral of uv over [0,x]² would instead be x⁴/4. The comment’s reused…

Hephaestus signature: quartic integral value

The function returns x⁴/8. This equals the triangular-domain integral ∫₀ˣ∫₀ᵘ uv dv du; a rectangular-domain integral of uv over [0,x]² would instead be x⁴/4. The comment’s reused…

Prometheus signature: logistic map at r=3.8

The function returns 3.8x(1−x). On [0,1] it is nonnegative with maximum 0.95 at x=0.5, so that interval maps into itself under the isolated recurrence. The network supplies a sine…

Dionysus signature: absolute sine after removing complex phase

The intermediate value is exp(iωx)sin(x), and the function then takes its complex magnitude. Since the exponential has magnitude one, the returned result is exactly |sin(x)|. The…

Artemis signature: scalar damping surrogate

The reference ∇·(D∇x) is a diffusion operator acting on a spatial field. The body returns −0.1x, based on a harmonic-mode analogy, without a grid or neighboring values. That…

Hera signature: sixteen weighted harmonics

The body computes Σₖ₌₁¹⁶sin(kx)/k. Its indexed terms are harmonics derived from the same scalar x, not readings of sixteen independently stored family activations. It is a finite…

Poseidon signature: harmonic restoring term

The function returns −ω²x, the acceleration term of a harmonic oscillator with displacement x. It does not evaluate the full displayed residual ∂²x/∂t²+ω²x, which would vanish for…

Demeter signature: logistic growth rate

The body uses carrying capacity K=1 and growth rate r=0.5, returning 0.5x(1−x). This is a rate-shaped scalar feature, positive between zero and one and zero at both endpoints. A…

Ares signature: unit-mass harmonic force

Assuming a harmonic displacement, acceleration is −ω²x and force is mass times acceleration. With mass fixed to one, the function returns −AngularFrequency²×x. Physical force…

Ares signature: unit-mass harmonic force

Assuming a harmonic displacement, acceleration is −ω²x and force is mass times acceleration. With mass fixed to one, the function returns −AngularFrequency²×x. Physical force…

Aphrodite signature: golden-frequency cosine

The cosine takes φx as its radian argument and returns a value between −1 and one. Its scalar-input period is 2π/φ, and it is even in x. The family’s harmony label does not alter…

Hestia signature: current-value scale without a history integral

The body returns x(1−e⁻⁰·¹), approximately 0.0951626x. It does not read prior inputs or a memory buffer, so it cannot evaluate the displayed exponentially weighted historical…

Zeus signature: selective fractional product

The implementation evaluates fifteen other family functions at scaled inputs x/(i+1). It multiplies the one-sixteenth power of each result only when that result lies strictly…

Enhanced coupling for a listed complementary pair

The indicator is one when two strand identifiers match one of the source’s eight listed complementary pairs. Such a pair receives weight J₀(1+ρ); all others receive J₀. This…

CompleteThought: documented integral and actual scalar aggregation

The comment combines memory, an attention-like exponential, and a time integral. The body instead computes a mean unity score across family activations, builds Qᵢ=aᵢcos phaseᵢ and…

CompleteThought: documented integral and actual scalar aggregation

The comment combines memory, an attention-like exponential, and a time integral. The body instead computes a mean unity score across family activations, builds Qᵢ=aᵢcos phaseᵢ and…

CompleteThought: documented integral and actual scalar aggregation

The comment combines memory, an attention-like exponential, and a time integral. The body instead computes a mean unity score across family activations, builds Qᵢ=aᵢcos phaseᵢ and…

Hephaestus signature: quartic integral value

The function returns x⁴/8. This equals the triangular-domain integral ∫₀ˣ∫₀ᵘ uv dv du; a rectangular-domain integral of uv over [0,x]² would instead be x⁴/4. The comment’s reused…