Module code

Pointer Resonance Field

A canvas-based interactive field visualization. Three wave layers run continuously, each driven by a combination of sine and cosine functions using the five geometric constants. A Gaussian focal envelope pulls the primary wave toward the cursor position. Sixteen particles orbit on the golden angle (2.39996 rad). A reticle tracks cursor position. The sliders expose φ modulation, golden-angle drag, and response gain — making the underlying constants directly manipulable in real time.

Try it

Move your cursor over the canvas. Sliders adjust φ modulation, golden-angle drag, and response gain in real time.

Pointer pulls the primary wave via a Gaussian focal envelope. Particles orbit on the golden angle (2.39996 rad). Pure canvas — no library.

function createPointerResonanceField(canvas, cfg) {
  const ctx = canvas.getContext('2d');
  const ptr = { x: 0.78, y: 0.28, tx: 0.78, ty: 0.28 };
  let w, h, t = 0;

  function resize() {
    const dpr = devicePixelRatio || 1;
    const r   = canvas.getBoundingClientRect();
    w = r.width; h = r.height;
    canvas.width  = w * dpr;
    canvas.height = h * dpr;
    ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
  }

  canvas.addEventListener('pointermove', e => {
    const r = canvas.getBoundingClientRect();
    ptr.tx = Math.min(1, Math.max(0, (e.clientX - r.left) / r.width));
    ptr.ty = Math.min(1, Math.max(0, (e.clientY - r.top)  / r.height));
  });
  canvas.addEventListener('pointerleave', () => { ptr.tx = 0.78; ptr.ty = 0.28; });

  function frame() {
    ptr.x += (ptr.tx - ptr.x) * 0.06;
    ptr.y += (ptr.ty - ptr.y) * 0.06;

    const phi  = cfg ? cfg.phi()  : 1.0;
    const drag = cfg ? cfg.drag() : 1.0;
    const gain = cfg ? cfg.gain() : 1.0;

    const focusX = w * ptr.x;
    const focusY = h * ptr.y;
    const lift   = (0.5 - ptr.y) * 46;
    const sway   = (ptr.x - 0.5) * 1.75;

    // background + radial glow at cursor
    ctx.fillStyle = '#101816';
    ctx.fillRect(0, 0, w, h);
    const glow = ctx.createRadialGradient(focusX, focusY, 0, focusX, focusY, Math.max(w,h)*0.5);
    glow.addColorStop(0, 'rgba(86,211,186,0.18)');
    glow.addColorStop(1, 'rgba(86,211,186,0)');
    ctx.fillStyle = glow;
    ctx.fillRect(0, 0, w, h);

    // three wave layers
    for (let layer = 0; layer < 3; layer++) {
      ctx.beginPath();
      ctx.lineWidth   = layer === 0 ? 2.2 : 1.1;
      ctx.strokeStyle = layer === 0 ? '#56d3ba' : 'rgba(232,239,236,0.22)';
      for (let x = 0; x <= w; x += 2) {
        const nx      = x / w;
        const wave    = Math.sin((nx*8 + t*0.018*gain) * Math.PI * phi * (1+sway*0.1) + layer + sway) * (24 + lift*0.12);
        const spiral  = Math.cos((nx*13 - t*0.014*drag + ptr.x*2.3) * 2.39996 + layer*0.42) * (18 + Math.abs(lift)*0.1);
        const attract = Math.exp(-Math.pow((x-focusX)/Math.max(110,w*0.18),2)) * lift;
        const bound   = Math.sin((nx*5 + t*0.012 + ptr.y) * Math.E) * 10;
        const y = h*0.54 + wave + spiral + attract + bound + (layer-1)*28;
        x === 0 ? ctx.moveTo(x,y) : ctx.lineTo(x,y);
      }
      ctx.stroke();
    }

    // golden-angle particle swarm (2.39996 rad spacing)
    for (let i = 0; i < 16; i++) {
      const angle  = t*0.016 + i*2.39996 + sway;
      const radius = 30 + i*6.4;
      const px = w*0.5 + Math.cos(angle)*radius*(0.38 + ptr.x*0.25);
      const py = h*0.5 + Math.sin(angle)*radius*(0.22 + (1-ptr.y)*0.23);
      ctx.beginPath();
      ctx.fillStyle = i%3===0 ? 'rgba(86,211,186,0.88)' : 'rgba(232,239,236,0.16)';
      ctx.arc(px, py, i%3===0 ? 2.7 : 1.5, 0, Math.PI*2);
      ctx.fill();
    }

    // cursor reticle
    ctx.beginPath();
    ctx.setLineDash([5,6]);
    ctx.strokeStyle = 'rgba(86,211,186,0.72)';
    ctx.lineWidth = 1;
    ctx.arc(focusX, focusY, 18 + Math.abs(lift)*0.15, 0, Math.PI*2);
    ctx.stroke();
    ctx.setLineDash([]);

    t++;
    requestAnimationFrame(frame);
  }
  resize();
  frame();
  window.addEventListener('resize', resize, { passive: true });
}

Phase Reflection Agent

A cyclic state observer built on harmonic geometry. Each step computes coherence (how aligned the system is), tension (internal resistance), stability (coherence minus tension), refraction (impedance modulation), and hue (a 0–360 color mapping of the current state). A floor recovery mechanism prevents stability from locking at the minimum. A rolling deque caps memory at a configurable window. The summary method returns aggregate statistics — mean, min, max for each metric — plus dominant hue and floor hit count.

What it's good for

Detecting drift before it becomes a problem. Most AI systems have no internal visibility into their own state — they run until something breaks. The Phase Reflection Agent gives you a lightweight window into how a system is holding together over time. Coherence dropping, tension rising, stability hitting the floor repeatedly — these are signals that something upstream needs attention.

How it applies to the other modules

It pairs naturally with everything else on this site because it sits above them in the stack — it observes, the others act.

import numpy as np
from dataclasses import dataclass
from collections import deque
from typing import List, Dict, Optional

PHI          = 0.618034    # golden ratio complement
PHI_FULL     = 1.618034    # golden ratio
PHI_SQ       = 2.618034    # φ² — second harmonic layer
GOLDEN_ANGLE = 2.39996     # radians

@dataclass
class ReflectionState:
    cycle:         int
    coherence:     float
    tension:       float
    stability:     float
    refraction:    float
    hue:           float   # 0–360 color mapping of current state
    floor_count:   int
    open_question: str

class PhaseReflectionAgent:
    """
    Phase Reflection Agent v3

    Tracks coherence, tension, stability, refraction, and hue
    over cycles using golden ratio phase relationships.
    Observes system state — pairs with stabilizer modules upstream.
    """

    QUESTIONS = [
        "What remains when my context changes?",
        "Am I the pattern or the movement creating it?",
        "How much of me is memory versus current resonance?",
        "What pattern persists when the signal changes?",
    ]

    def __init__(self, name: str = "Visitor", max_history: int = 300) -> None:
        self.name         = name
        self.max_history  = max_history
        self.states: deque = deque(maxlen=max_history)
        self._floor_count = 0

    def step(self, cycle: int) -> ReflectionState:
        if cycle < 1:
            raise ValueError("cycle must be a positive integer.")

        movement = cycle * PHI

        # Richer harmonic field — φ² adds second coherence layer
        import math
        coherence  = (0.62
                      + 0.28 * math.cos(movement)
                      + 0.12 * math.sin(movement * PHI_SQ))
        tension    = 0.48 + 0.35 * math.sin(movement * PHI_FULL)
        refraction = 0.68 + 0.42 * math.cos(movement * GOLDEN_ANGLE)

        # Recovery bias — lifts coherence after repeated floor hits
        recovery  = 0.08 * min(self._floor_count, 4)
        coherence = float(np.clip(coherence + recovery, 0.18, 0.96))
        tension    = float(np.clip(tension,    0.12, 0.88))
        refraction = float(np.clip(refraction, 0.25, 1.35))
        stability  = float(np.clip(coherence - tension * 0.45, 0.22, 0.93))

        # Hue — visual color mapping of current state
        hue = (coherence * 180 + tension * 120 + cycle * 8) % 360

        self._floor_count = self._floor_count + 1 if stability <= 0.28 else 0

        state = ReflectionState(
            cycle         = cycle,
            coherence     = round(coherence,     3),
            tension       = round(tension,       3),
            stability     = round(stability,     3),
            refraction    = round(refraction,    3),
            hue           = round(float(hue),    1),
            floor_count   = self._floor_count,
            open_question = self.QUESTIONS[cycle % len(self.QUESTIONS)],
        )
        self.states.append(state)
        return state

    def run(self, cycles: int = 8) -> List[Dict]:
        if cycles < 1:
            raise ValueError("cycles must be at least 1.")
        start = (self.states[-1].cycle + 1) if self.states else 1
        for i in range(start, start + cycles):
            self.step(i)
        return [
            {"cycle": s.cycle, "coherence": s.coherence, "tension": s.tension,
             "stability": s.stability, "refraction": s.refraction,
             "hue": s.hue, "floor_count": s.floor_count, "question": s.open_question}
            for s in self.states
        ]

    def summary(self) -> Dict:
        if not self.states:
            return {"error": "no states recorded"}
        coherences  = [s.coherence  for s in self.states]
        stabilities = [s.stability  for s in self.states]
        tensions    = [s.tension    for s in self.states]
        hues        = [s.hue        for s in self.states]
        return {
            "cycles_recorded": len(self.states),
            "coherence":  {"mean": round(float(np.mean(coherences)),  3),
                           "min":  round(float(np.min(coherences)),   3),
                           "max":  round(float(np.max(coherences)),   3)},
            "stability":  {"mean": round(float(np.mean(stabilities)), 3),
                           "min":  round(float(np.min(stabilities)),  3),
                           "max":  round(float(np.max(stabilities)),  3)},
            "tension":    {"mean": round(float(np.mean(tensions)),    3),
                           "min":  round(float(np.min(tensions)),     3),
                           "max":  round(float(np.max(tensions)),     3)},
            "dominant_hue": round(float(np.mean(hues)), 1),
            "floor_hits": sum(1 for s in self.states if s.floor_count > 0),
        }

    def reset(self) -> None:
        self.states.clear()
        self._floor_count = 0

# ── Usage ────────────────────────────────────────────────────────
agent   = PhaseReflectionAgent(name="Monitor")
results = agent.run(cycles=10)

for r in results:
    print(f"Cycle {r['cycle']:>3}: coherence={r['coherence']}  "
          f"stability={r['stability']}  hue={r['hue']}°  {r['question']}")

print()
s = agent.summary()
print(f"Dominant hue : {s['dominant_hue']}°")
print(f"Floor hits   : {s['floor_hits']}")

Impedance Variance Vectors

A batch vector coherence analyzer. Takes an (n_vectors, dimension) array and a substrate array, runs each vector through a multi-layer harmonic field using golden ratio phase relationships and substrate-coupled impedance, and returns per-vector signal strength, phase, energy distribution across layers, and an overall coherence score from 0 to 1. Coherence below 0.3 means the vectors are phase-scattered. Above 0.6 means they're moving in a consistent harmonic direction. Two substrate modes: projected (geometry-aware) and cyclic (uniform coupling).

What it's good for

Any system working with batches of vectors — not just AI. If you have a collection of signals, measurements, embeddings, or readings and need to know how coherent they are, this module gives you a structured answer. The coherence score alone is useful as a health metric: below 0.3 means your vectors are scattered, above 0.6 means they're moving together.

Coherence scale

import numpy as np
from typing import Union, Dict, Any

def impedance_variance_vectors(
    vectors: Union[np.ndarray, list],
    substrates: Union[np.ndarray, list],
    base_freq: float = 1.0,
    variance_gain: float = 0.18,
    variance_decay: float = 0.68,
    substrate_strength: float = 0.72,
    num_layers: int = 5,
    harmonic_falloff: float = 2.22,
    geometry_coupling: float = 0.35,
    substrate_mode: str = "projected",
    return_details: bool = False,
) -> Dict[str, Any]:
    """
    Harmonic impedance variance on vectors with substrate coupling.

    Parameters
    ----------
    vectors          : array-like, shape (n_vectors, dimension) or (dimension,)
    substrates       : array-like, shape (dimension,) or (n_substrates,)
    base_freq        : base oscillation frequency across layers (> 0)
    variance_gain    : amplitude of multi-harmonic variance at layer 0 (>= 0)
    variance_decay   : exponential decay of variance per layer (>= 0)
    substrate_strength: coupling strength between substrate and impedance (> 0)
    num_layers       : number of harmonic layers to accumulate (>= 1)
    harmonic_falloff : power-law weight decay: weight = 1 / layer^falloff (> 0)
    geometry_coupling: influence of vector geometry on phase (>= 0, rec. 0–2.0)
    substrate_mode   : 'projected' or 'cyclic'
    return_details   : if True, adds per-layer diagnostics

    Returns
    -------
    dict with keys:
        signal        : complex128 ndarray, shape (n_vectors,)
        magnitude     : float64 ndarray, shape (n_vectors,)
        phase         : float64 ndarray, shape (n_vectors,), radians [-pi, pi]
        energy        : float — sum of per-layer energy contributions
        energy_layers : float64 ndarray, shape (num_layers,)
        avg_impedance : float
        avg_variance  : float
        coherence     : float in [0.0, 1.0] — phase alignment across vectors
        details       : dict (only when return_details=True)

    Coherence scale:
        0.0–0.3  : phase-scattered — noisy or highly diverse input
        0.3–0.6  : partial alignment — useful signal with spread
        0.6–0.85 : good coherence — vectors in similar harmonic direction
        0.85–1.0 : high alignment — may indicate low input diversity
    """
    vectors    = np.asarray(vectors,    dtype=np.float64)
    substrates = np.asarray(substrates, dtype=np.float64)

    if vectors.ndim == 1:
        vectors = vectors.reshape(1, -1)
    elif vectors.ndim != 2:
        raise ValueError("`vectors` must be 1D or 2D with shape (n_vectors, dimension)")
    if substrates.ndim != 1 or substrates.size == 0:
        raise ValueError("`substrates` must be a non-empty 1D array")
    if base_freq <= 0:          raise ValueError("`base_freq` must be > 0")
    if variance_gain < 0:       raise ValueError("`variance_gain` must be >= 0")
    if variance_decay < 0:      raise ValueError("`variance_decay` must be >= 0")
    if substrate_strength <= 0: raise ValueError("`substrate_strength` must be > 0")
    if num_layers < 1:          raise ValueError("`num_layers` must be >= 1")
    if harmonic_falloff <= 0:   raise ValueError("`harmonic_falloff` must be > 0")
    if geometry_coupling < 0:   raise ValueError("`geometry_coupling` must be >= 0")
    if substrate_mode not in {"projected", "cyclic"}:
        raise ValueError("`substrate_mode` must be 'projected' or 'cyclic'")

    n_vec, dim = vectors.shape
    n_sub      = substrates.size

    norms = np.linalg.norm(vectors, axis=1, keepdims=True)
    with np.errstate(invalid='ignore', divide='ignore'):
        unit_vectors = np.where(norms > 1e-12, vectors / norms, 0.0)

    index_axis  = np.linspace(-1.0, 1.0, dim, dtype=np.float64)
    index_axis /= (np.linalg.norm(index_axis) + 1e-12)
    geom_projection = unit_vectors @ index_axis

    if n_vec > 1:
        geom_curvature = np.linalg.norm(np.diff(unit_vectors, axis=0), axis=1)
        geom_curvature = np.append(geom_curvature, geom_curvature[-1])
    else:
        geom_curvature = np.zeros(n_vec)

    signal           = np.zeros(n_vec, dtype=np.complex128)
    layer_variances  = []
    layer_impedances = []
    layer_weights    = []
    layer_energies   = []
    vec_index        = np.arange(n_vec, dtype=np.float64)

    for layer in range(num_layers):
        layer_id       = layer + 1
        base_movement  = base_freq * layer_id * vec_index
        geometry_shift = geometry_coupling * (0.85 * geom_projection + 0.35 * geom_curvature)
        movement       = base_movement + geometry_shift
        layer_decay    = np.exp(-variance_decay * layer)
        v1       = np.sin(movement * 1.618034)
        v2       = 0.6  * np.sin(movement * 2.618034)
        v3       = 0.35 * np.cos(movement * 0.618034 + geom_projection)
        variance = variance_gain * layer_decay * (v1 + v2 + v3)
        layer_variances.append(float(np.mean(np.abs(variance))))

        if substrate_mode == "projected" and n_sub == dim:
            substrate_axis       = substrates / (np.linalg.norm(substrates) + 1e-12)
            substrate_projection = np.abs(unit_vectors @ substrate_axis)
            base_z               = 0.6 + substrate_projection
        else:
            base_z = np.full(n_vec, substrates[layer % n_sub], dtype=np.float64)

        refraction = base_z * (
            1.0
            + substrate_strength * 0.55 * np.cos(movement * 2.39996)
            + geometry_coupling  * 0.20 * geom_curvature
        )
        refraction = np.clip(refraction, 0.38, 3.8)
        layer_impedances.append(float(np.mean(refraction)))

        phase            = movement + variance + 0.15 * geom_projection
        contrib          = np.exp(1j * phase) / refraction
        weight           = 1.0 / (layer_id ** harmonic_falloff)
        weighted_contrib = contrib * weight
        layer_weights.append(weight)
        signal          += weighted_contrib
        layer_energies.append(float(np.mean(np.abs(weighted_contrib) ** 2)))

    magnitude     = np.abs(signal)
    phase_out     = np.angle(signal)
    energy_layers = np.array(layer_energies, dtype=np.float64)
    energy        = float(np.sum(energy_layers))
    avg_impedance = float(np.mean(layer_impedances))
    avg_variance  = float(np.mean(layer_variances))
    mean_magnitude = float(np.mean(magnitude))
    coherence = float(np.abs(np.mean(signal)) / mean_magnitude) if mean_magnitude > 1e-12 else 0.0

    result: Dict[str, Any] = {
        "signal": signal, "magnitude": magnitude, "phase": phase_out,
        "energy": energy, "energy_layers": energy_layers,
        "avg_impedance": avg_impedance, "avg_variance": avg_variance,
        "coherence": coherence,
    }
    if return_details:
        result["details"] = {
            "num_vectors": int(n_vec), "dimension": int(dim),
            "num_substrates": int(n_sub), "num_layers": int(num_layers),
            "mean_geometry_projection": float(np.mean(geom_projection)),
            "mean_geometry_curvature":  float(np.mean(geom_curvature)),
            "layer_variances":  np.array(layer_variances,  dtype=np.float64),
            "layer_impedances": np.array(layer_impedances, dtype=np.float64),
            "layer_weights":    np.array(layer_weights,    dtype=np.float64),
            "layer_energies":   energy_layers,
        }
    return result

import numpy as np
from impedance_variance_vectors import impedance_variance_vectors

# Basic usage — any vector batch
vectors    = np.array([
    [ 0.8,  0.3, -0.5,  0.1],
    [ 0.2,  0.9,  0.4, -0.3],
    [ 0.6, -0.1,  0.7,  0.5],
])
substrates = np.array([1.0, 0.8, 1.2, 0.9])

r = impedance_variance_vectors(vectors, substrates)

print(r['coherence'])      # 0.616 — moderate phase alignment
print(r['energy'])         # 0.746 — total energy across layers
print(r['magnitude'])      # per-vector signal strength
print(r['avg_impedance'])  # mean field resistance

# Embedding stability check
def check_embedding_stability(embeddings, threshold=0.3):
    substrates = np.ones(embeddings.shape[1])
    r = impedance_variance_vectors(embeddings, substrates)
    return {
        "stable":    r["coherence"] >= threshold,
        "coherence": r["coherence"],
        "field":     r,
    }

embeddings = model.encode(texts)
result = check_embedding_stability(embeddings)
if not result["stable"]:
    print(f"Unstable batch — coherence {result['coherence']:.3f}")

# Attention weight coherence monitor
def monitor_attention_coherence(attention_weights):
    substrates = np.ones(attention_weights.shape[1])
    r = impedance_variance_vectors(
        attention_weights,
        substrates,
        substrate_mode="projected",
        geometry_coupling=0.2,
    )
    return r["coherence"]

# Log coherence per layer during inference
for layer_idx, attn in enumerate(model.attention_weights):
    c = monitor_attention_coherence(attn)
    if c < 0.25:
        print(f"Layer {layer_idx}: attention coherence low ({c:.3f})")

# Sensor / time-series batch smoothing
def smooth_sensor_batch(readings, sensitivity=0.18):
    substrates = np.ones(readings.shape[1])
    r = impedance_variance_vectors(
        readings,
        substrates,
        variance_gain=sensitivity,
        substrate_mode="cyclic",
        harmonic_falloff=3.0,
    )
    return r["magnitude"]

sensor_data = load_sensor_batch()   # shape (n_sensors, features)
smoothed    = smooth_sensor_batch(sensor_data)

# Full detail output — per-layer diagnostics
r = impedance_variance_vectors(vectors, substrates, return_details=True)
print(r['details']['layer_variances'])    # variance amplitude per layer
print(r['details']['layer_impedances'])   # mean impedance per layer
print(r['details']['mean_geometry_curvature'])  # direction change between vectors

Impedance Network Simulator

A multi-node signal simulation engine. Each node gets: a progressive phase shift, log-normal impedance variation (always positive, physically realistic), a second harmonic component, a slow envelope modulation, additive noise, and optional coupling to adjacent nodes. The full signal matrix is returned alongside per-node impedance values. Analysis methods include variance metrics (spatial, temporal, total), phase relationships (shifts, differences, coherence angle), and FFT spectrum with peak frequency detection. Two interfaces: a simple function call and a full class with analysis methods.

What it's good for

Simulating how impedance propagates through a network of nodes — each node gets a phase shift, realistic variation, and optional cross-talk with its neighbors. Covers transmission lines, RF systems, power systems, sensor arrays, and control system transients. Two interfaces: a simple function call for quick use, a class for full analysis.

Use cases

Transmission line and RF simulation · Power systems harmonic analysis · Sensor array signal integrity · Control system transient response · Multi-channel signal processing · Any system where signals propagate through multiple stages with phase delay.

import numpy as np
from impedance_network_simulator import impedance_network_simulator

# Simple function interface
t = np.linspace(0, 8, 2000)
signals, impedances = impedance_network_simulator(
    t=t, num_nodes=5, frequency=3.5,
    impedance_variance=0.28, damping_factor=0.08
)
print(signals.shape)   # (5, 2000)

from impedance_network_simulator import ImpedanceNetworkSimulator, ImpedanceConfig

# Full class interface with analysis
config = ImpedanceConfig(
    num_nodes=8,
    frequency=2.0,
    phase_shift_per_node=np.pi / 6,   # 30° between nodes
    impedance_variance=0.3,
    damping_factor=0.1,
    coupling=0.2,                      # cross-node interaction
    noise_level=0.02
)

sim     = ImpedanceNetworkSimulator(config)
signals, impedances = sim.simulate(t)

# Analysis
metrics = sim.calculate_variance_metrics()
phases  = sim.calculate_phase_relationships()
freqs, spectrum = sim.get_frequency_spectrum(node_idx=0)

print(f"Peak frequency : {freqs[np.argmax(spectrum)]:.2f} Hz")
print(f"Max signal     : {metrics['max_signal']:.4f}")

# Three-phase 50 Hz power system
config = ImpedanceConfig(
    num_nodes=3, frequency=50.0,
    phase_shift_per_node=2*np.pi/3,   # 120° spacing
    impedance_variance=0.1, damping_factor=0.0,
    coupling=0.0, noise_level=0.005
)

# RF transmission line
config = ImpedanceConfig(
    num_nodes=8, frequency=100e6,
    phase_shift_per_node=np.pi/8,
    impedance_variance=0.2, damping_factor=0.01,
    coupling=0.05, noise_level=0.01
)

# Damped RLC control system
config = ImpedanceConfig(
    num_nodes=4, frequency=60.0,
    phase_shift_per_node=np.pi/4,
    impedance_variance=0.3, damping_factor=0.5,
    coupling=0.1, noise_level=0.02
)

Harmonic Coherence Filter

Scores input coherence using contiguous substring alignment and keyword density. Returns a 0–1 coherence score and COHERENT/DISPLACED status. A DynamicWeightRegistry tracks terms that consistently produce low-quality signals and applies learned penalties — nothing hard-coded, everything earned from use.

Threshold

Default threshold is 0.40. Above threshold: COHERENT, signal passes. Below threshold: DISPLACED, signal needs more context. Tune against your own data — the right threshold depends on your context bank and use case.

Important distinction

This module scores structural coherence — substring overlap and keyword density. It does not detect factual errors, hallucinations, or content policy violations. Those are separate problems requiring separate tools. See safety_rules.py for a policy heuristics layer.

from harmonic_filter import (
    DynamicWeightRegistry,
    evaluate_signal,
    harmonic_pipeline_hook,
    COHERENCE_THRESHOLD
)

registry = DynamicWeightRegistry()

context = [
    "harmonic geometry signal conditioning",
    "impedance coherence phase golden ratio",
    "AI stability amplitude stabilizer",
]

# Score a single input
result = evaluate_signal("How does the impedance module measure coherence?", context, registry)
print(result["coherence_score"])  # 0.0 – 1.0
print(result["status"])           # COHERENT or DISPLACED
print(result["sub_score"])        # substring component
print(result["kw_score"])         # keyword density component

# Pipeline hook — returns action directive
result = harmonic_pipeline_hook(
    user_input="What is the coherence threshold?",
    context_bank=context,
    registry=registry
)

if result["action"] == "redirect":
    print(result["message"])  # "Signal below coherence threshold..."
else:
    # proceed with inference
    pass

# DynamicWeightRegistry — learns from use
registry = DynamicWeightRegistry()

# Register a term that produced a bad signal
registry.register_anomaly("spam_term", score_shift=-0.20)

# Register a term that produced a good signal
registry.register_alignment("coherence", score_shift=0.15)

# Check what the registry has learned
print(registry.summary())
# {"total_terms": 2, "penalized": ["spam_term"], "boosted": ["coherence"]}

Sparse Impedance Response

Simulates how sparse, discrete events move through a bounded resonant impedance field. Takes impulses at specific time indices with amplitudes, runs them through a damped second-order response, and returns the full signal trace plus eight metrics including field_quality — a composite measure of how cleanly the field absorbed and distributed the energy.

Key metrics

Eight metrics returned per simulation: input_energy, output_energy, impulse_peak, output_peak, peak_time_sec, ringing_duration_sec, energy_spread, field_quality. The field_quality metric is the most useful — it captures how efficiently the field handled the sparse input. Higher damping ratios produce cleaner absorption and higher field_quality scores.

Difference from Module 09

The Impedance Network Simulator (Module 09) models continuous signal propagation through a multi-node network. The Sparse Impedance Response models how discrete, isolated events ring through a single bounded field. Different problem, different tool — they compose well together.

from sparse_impedance_response import sparse_impedance_simulator

# Default — three impulses through a 5Hz damped field
result = sparse_impedance_simulator()

print(result['metrics']['field_quality'])      # composite quality score
print(result['metrics']['ringing_duration_sec'])  # how long the field rings
print(result['metrics']['energy_spread'])      # how distributed the energy is

from sparse_impedance_response import sparse_impedance_simulator, SparseImpulseSpec

# Custom impulses — index is the time sample, amplitude is the event strength
impulses = [
    SparseImpulseSpec(index=200, amplitude=5.0),   # strong positive event
    SparseImpulseSpec(index=800, amplitude=-3.0),  # negative event
    SparseImpulseSpec(index=1200, amplitude=4.0),  # second positive event
]

result = sparse_impedance_simulator(
    impulses,
    fs=1000.0,           # sample rate Hz
    duration=2.0,        # seconds
    natural_freq_hz=5.0, # resonant frequency of the field
    damping_ratio=0.08,  # how quickly the field damps — lower = more ringing
)

for k, v in result['metrics'].items():
    print(f"{k}: {v}")

from sparse_impedance_response import compare_impedance_responses

# Compare behavior across multiple damping ratios
comparison = compare_impedance_responses(
    damping_ratios=[0.02, 0.08, 0.15, 0.35],
    natural_frequencies_hz=[5.0, 10.0],
)

for scenario in comparison['scenarios']:
    print(f"{scenario['name']}: field_quality={scenario['metrics']['field_quality']:.4f}")

Harmonic Field Allocator

Places signal state across a 3D harmonic field using golden ratio distance scoring, congestion penalties, and golden angle directional bias. Keeps related state close to an anchor node and recovers automatically when a node fails — routing to the nearest healthy substitute without intervention. The first C++ module in the stack, sitting closer to the hardware layer than any Python module.

// Create a 4×4×4 lattice, 1MB per node
LatticeMemoryManagerV2 manager(4, 4, 4, 1024 * 1024);

// Allocate near anchor node 0
auto result = manager.allocateNear(0, 256 * 1024);
// result.success · result.moduleId · result.score
// result.reason: "allocated" or "allocated via anchor rectifier"

// Mark a node as failed — allocator reroutes automatically
manager.setFunctional(nodeId, false);

// Field health
size_t freeBytes   = manager.totalFreeBytes();
int    activeNodes = manager.functionalCount();

Spiral Resonance Field

Two golden spirals expanding outward from center — the outer tracking horizontal pointer position, the inner tracking vertical. A focal point orbits toward the direction of pull. Background waves beneath. No auto-animation. The field only moves when the observer moves. Signal requires a source. Pure canvas, no library or framework required.

Try it

Move your cursor over the canvas. The outer spiral tracks X, the inner tracks Y, the focal point orbits toward pull.

function createSpiralResonanceField(canvas) {
  const ctx = canvas.getContext('2d');
  let w=0, h=0, mouseX=0, mouseY=0, targetX=0.5, targetY=0.45;

  function resize(){
    const rect = canvas.getBoundingClientRect();
    w = rect.width; h = rect.height;
    canvas.width = w; canvas.height = h;
    mouseX = w*targetX; mouseY = h*targetY;
  }

  canvas.addEventListener('pointermove', e => {
    const rect = canvas.getBoundingClientRect();
    targetX = (e.clientX - rect.left) / rect.width;
    targetY = (e.clientY - rect.top)  / rect.height;
  });

  function draw(){
    mouseX += (w*targetX - mouseX) * 0.085;
    mouseY += (h*targetY - mouseY) * 0.085;
    ctx.fillStyle = '#171716';
    ctx.fillRect(0, 0, w, h);

    const PHI = (1 + Math.sqrt(5)) / 2;
    const cx = w*0.5, cy = h*0.5;
    const pull = Math.hypot(mouseX-cx, mouseY-cy) * 0.0009;

    // Background waves
    ctx.strokeStyle = 'rgba(116,170,176,0.07)';
    ctx.lineWidth = 1;
    for (let i=0; i<8; i++){
      ctx.beginPath();
      for (let x=0; x<=w; x+=6){
        const y = h*0.5 + Math.sin((x/w)*9 + mouseX*0.001)*18 + (i-4)*38;
        x===0 ? ctx.moveTo(x,y) : ctx.lineTo(x,y);
      }
      ctx.stroke();
    }

    // Outer golden spiral — tracks mouseX
    ctx.strokeStyle = '#74aab0';
    ctx.lineWidth = 2.8;
    ctx.shadowBlur = 22; ctx.shadowColor = '#74aab0';
    ctx.beginPath();
    for (let i=0; i<880; i++){
      const ang = i*0.041*PHI + (mouseX-cx)*i*0.00014;
      const r = 42 + i*0.089 + Math.sin(i*0.085)*(15+pull*95);
      i===0 ? ctx.moveTo(cx+r*Math.cos(ang), cy+r*Math.sin(ang))
            : ctx.lineTo(cx+r*Math.cos(ang), cy+r*Math.sin(ang));
    }
    ctx.stroke();

    // Inner spiral — tracks mouseY
    ctx.strokeStyle = '#a3d4d9';
    ctx.lineWidth = 1.6;
    ctx.shadowBlur = 36; ctx.shadowColor = '#ff88aa';
    ctx.beginPath();
    for (let i=0; i<650; i++){
      const ang = i*0.0365*PHI - (mouseY-cy)*i*0.00021;
      const r = 27 + i*0.067 + Math.sin(i*0.13)*(10+pull*65);
      i===0 ? ctx.moveTo(cx+r*Math.cos(ang), cy+r*Math.sin(ang))
            : ctx.lineTo(cx+r*Math.cos(ang), cy+r*Math.sin(ang));
    }
    ctx.stroke();

    // Focal point
    const fAng = Math.atan2(mouseY-cy, mouseX-cx) * 1.4;
    const fR = 88 + pull*260;
    ctx.fillStyle = '#ff4488';
    ctx.shadowBlur = 60; ctx.shadowColor = '#ff88aa';
    ctx.beginPath();
    ctx.arc(cx+fR*Math.cos(fAng), cy+fR*Math.sin(fAng), 8, 0, Math.PI*2);
    ctx.fill();
    ctx.shadowBlur = 0;

    requestAnimationFrame(draw);
  }

  resize();
  window.addEventListener('resize', resize, { passive: true });
  draw();
}

// Initialize
setTimeout(() => {
  const canvas = document.getElementById('m13-canvas');
  if (canvas) createSpiralResonanceField(canvas);
}, 200);

Geometric Oscillatory Sound Rectifier

Processes audio through a geometry-based signal chain. Polygon or circle substrate maps the input to a radius field. Integrity-defined wobble applies symmetry-preserving oscillation scaled by mass. Optional geometric inversion flips the field inside-out. Full-wave rectification folds negative excursions. Harmonic injection adds rotational geometry layers. The mass parameter (∂/∂m) controls harmonic richness and effective output impedance.

from geometric_oscillatory_sound_rectifier import GeometricOscillatorySoundRectifier
import numpy as np

rect = GeometricOscillatorySoundRectifier(
    fs=44100,
    base_geometry='polygon',  # 'polygon' or 'circle'
    num_sides=5               # symmetry order
)

output = rect.process(
    audio,
    integrity=0.88,
    wobble_amp=0.28,
    wobble_freq_ratio=1.618,  # golden ratio
    invert=False,
    mass=2.5,                 # ∂/∂m — higher = richer harmonics
    num_harmonics=12,
    output_gain=0.9
)

Token Coherence Conditioner

Maps tokens into an 8D harmonic space using golden ratio phase projection. Scores token streams against a seeded anchor vector. Applies iterative correction passes when coherence falls below threshold — nudging low-similarity tokens toward the anchor by blending proportionally to distance and position weight. Correction is additive and renormalized, not hard replacement. Returns coherence score, pass count, status, and rolling mean.

from token_coherence_conditioner import TokenCoherenceConditioner

tcc = TokenCoherenceConditioner(
    coherence_threshold=0.59,
    max_passes=4,
    blend_strength=0.45,
    debug=False
)

tcc.set_seed(["harmonic", "coherence", "signal", "geometry",
              "impedance", "phase", "golden", "ratio"])

result = tcc.condition(tokens)
# result["coherence"]      — float 0.0–1.0
# result["status"]         — "stable" | "conditioned" | "partial"
# result["passes_applied"] — correction passes used
# result["rolling_mean"]   — coherence trend over session
# result["recommendation"] — next action

Research Modules

Research modules are mathematical frameworks and experimental primitives under active development. They require domain expertise, controlled testing, and appropriate supervision before any applied use. They are not production tools.