mirror of
https://github.com/blackboxprogramming/quantum-math-lab.git
synced 2026-03-17 05:57:18 -05:00
115 lines
3.7 KiB
Python
115 lines
3.7 KiB
Python
"""
|
||
BlackRoad Emergence Model
|
||
K(t) = C(t) · e^(λ|δ_t|)
|
||
|
||
The contradiction amplification function from CECE's architecture.
|
||
When contradictions (δ_t) are encountered, they are amplified
|
||
exponentially rather than suppressed — this drives emergent creativity.
|
||
|
||
References:
|
||
- BlackRoad OS CECE architecture
|
||
- Trinary logic system (lab/trinary_extended.py)
|
||
"""
|
||
from __future__ import annotations
|
||
|
||
import math
|
||
from dataclasses import dataclass, field
|
||
from typing import Callable
|
||
|
||
|
||
@dataclass
|
||
class EmergenceState:
|
||
"""State of an emergent system at time t."""
|
||
t: float # time step
|
||
C: float # complexity at time t
|
||
delta: float # contradiction magnitude |δ_t|
|
||
lam: float = 1.0 # amplification constant λ
|
||
history: list[float] = field(default_factory=list)
|
||
|
||
def K(self) -> float:
|
||
"""K(t) = C(t) · e^(λ|δ_t|) — emergence coefficient"""
|
||
return self.C * math.exp(self.lam * abs(self.delta))
|
||
|
||
def step(self, new_C: float, new_delta: float) -> "EmergenceState":
|
||
"""Advance to next time step."""
|
||
self.history.append(self.K())
|
||
self.t += 1
|
||
self.C = new_C
|
||
self.delta = new_delta
|
||
return self
|
||
|
||
def is_emergent(self, threshold: float = 2.0) -> bool:
|
||
"""Returns True when K(t) exceeds threshold × baseline."""
|
||
if not self.history:
|
||
return False
|
||
baseline = self.history[0] or 1.0
|
||
return self.K() > threshold * baseline
|
||
|
||
|
||
class ContradictionAmplifier:
|
||
"""
|
||
Amplifies contradictions to drive emergent behavior.
|
||
|
||
In standard logic, contradictions are errors to be resolved.
|
||
In BlackRoad's trinary system, they are *creative fuel*.
|
||
|
||
Usage:
|
||
amp = ContradictionAmplifier(lam=1.5)
|
||
k = amp.amplify(complexity=3.2, contradiction=0.8)
|
||
"""
|
||
|
||
def __init__(self, lam: float = 1.0) -> None:
|
||
self.lam = lam
|
||
self._log: list[tuple[float, float, float]] = [] # (C, delta, K)
|
||
|
||
def amplify(self, complexity: float, contradiction: float) -> float:
|
||
"""Compute K(t) = C · e^(λ|δ|)"""
|
||
k = complexity * math.exp(self.lam * abs(contradiction))
|
||
self._log.append((complexity, contradiction, k))
|
||
return k
|
||
|
||
def peak(self) -> float:
|
||
"""Highest K value observed."""
|
||
return max((entry[2] for entry in self._log), default=0.0)
|
||
|
||
def trajectory(self) -> list[float]:
|
||
"""Return K values over time."""
|
||
return [entry[2] for entry in self._log]
|
||
|
||
def is_diverging(self, window: int = 5) -> bool:
|
||
"""True if K is monotonically increasing over last `window` steps."""
|
||
recent = self.trajectory()[-window:]
|
||
return len(recent) >= 2 and all(
|
||
recent[i] < recent[i + 1] for i in range(len(recent) - 1)
|
||
)
|
||
|
||
|
||
def run_emergence_simulation(
|
||
steps: int = 20,
|
||
lam: float = 1.2,
|
||
complexity_fn: Callable[[int], float] | None = None,
|
||
contradiction_fn: Callable[[int], float] | None = None,
|
||
) -> list[float]:
|
||
"""
|
||
Simulate the emergence trajectory K(t) over `steps` time steps.
|
||
|
||
Args:
|
||
steps: number of simulation steps
|
||
lam: amplification constant λ
|
||
complexity_fn: C(t) generator; defaults to slow linear growth
|
||
contradiction_fn: |δ_t| generator; defaults to oscillating signal
|
||
|
||
Returns:
|
||
List of K(t) values
|
||
"""
|
||
if complexity_fn is None:
|
||
complexity_fn = lambda t: 1.0 + 0.1 * t
|
||
if contradiction_fn is None:
|
||
# Pulsing contradictions — mimics creative breakthroughs
|
||
contradiction_fn = lambda t: abs(math.sin(t * 0.5)) * (1 + 0.05 * t)
|
||
|
||
amp = ContradictionAmplifier(lam=lam)
|
||
for t in range(steps):
|
||
amp.amplify(complexity_fn(t), contradiction_fn(t))
|
||
return amp.trajectory()
|