feat(physics): add mind-physics layer — ADR-0008/0009/0010, blueprint, and operator stubs
- docs/decisions/ADR-0008-allocation-physics.md Formalizes salience, attention, inhibition, and coherence-budget as the allocation physics of cognition. Replaces attention-as-weights with attention-as-field-curvature over the versor manifold. - docs/decisions/ADR-0009-compositional-physics.md Defines temporal binding, digest cycles, reasoning trajectories, and articulation planning as the compositional physics layer — how CORE assembles pressure into structured thought and output. - docs/decisions/ADR-0010-identity-physics.md Establishes IdentityManifold, DriveGradientMap, ExertionMeter, and CharacterProfile as structural identity primitives. Identity is a field over the geometry, not a prompt veneer. Grounded in John 1:1–2 and the Logos theology that anchors the architecture. - docs/architecture/MIND-PHYSICS-BLUEPRINT.md Integration blueprint showing how allocation → compositional → identity physics layers compose into the full cognitive cycle. - core/physics/ (11 Python interface stubs) SalienceOperator, AttentionOperator, InhibitionOperator, BindingFrame, DigestCycle, ReasoningTrajectory, ArticulationPlanner, DriveGradientMap, ExertionMeter, IdentityManifold, CharacterProfile — all typed, all frozen where stateless, all carrying explicit field contracts. Third Door: no off-the-shelf cognitive architecture borrowed. All operators defined from the geometry up.
This commit is contained in:
Shay
parent
37f76ea6f2
commit
159c783c2e
15 changed files with 918 additions and 0 deletions
34
core/physics/__init__.py
Normal file
34
core/physics/__init__.py
Normal file
|
|
@ -0,0 +1,34 @@
|
|||
"""core.physics — Mind-physics layer for CORE cognitive architecture.
|
||||
|
||||
Three physics sublayers:
|
||||
allocation — salience, attention, inhibition, coherence budget (ADR-0008)
|
||||
compositional — binding, digest, reasoning, articulation (ADR-0009)
|
||||
identity — identity manifold, drives, exertion, character (ADR-0010)
|
||||
|
||||
All operators are stateless and frozen where possible.
|
||||
State lives in the FieldState; operators are pure transformations.
|
||||
"""
|
||||
|
||||
from core.physics.salience import SalienceOperator, SalienceMap, FieldRegion
|
||||
from core.physics.attention import AttentionOperator, AttentionPlan, CoherenceBudget
|
||||
from core.physics.inhibition import InhibitionOperator, InhibitionMask
|
||||
from core.physics.binding import BindingFrame, BindingOperator
|
||||
from core.physics.digest import DigestCycle, DigestOperator
|
||||
from core.physics.reasoning import ReasoningTrajectory, TrajectoryOperator
|
||||
from core.physics.articulation import ArticulationPlan, ArticulationPlanner, OutputModality
|
||||
from core.physics.drive import DriveGradientMap, GradientField, ValueAxis
|
||||
from core.physics.exertion import ExertionMeter, FatigueIndex, CycleCost
|
||||
from core.physics.identity import IdentityManifold, IdentityCheck, IdentityScore, CharacterProfile
|
||||
|
||||
__all__ = [
|
||||
"SalienceOperator", "SalienceMap", "FieldRegion",
|
||||
"AttentionOperator", "AttentionPlan", "CoherenceBudget",
|
||||
"InhibitionOperator", "InhibitionMask",
|
||||
"BindingFrame", "BindingOperator",
|
||||
"DigestCycle", "DigestOperator",
|
||||
"ReasoningTrajectory", "TrajectoryOperator",
|
||||
"ArticulationPlan", "ArticulationPlanner", "OutputModality",
|
||||
"DriveGradientMap", "GradientField", "ValueAxis",
|
||||
"ExertionMeter", "FatigueIndex", "CycleCost",
|
||||
"IdentityManifold", "IdentityCheck", "IdentityScore", "CharacterProfile",
|
||||
]
|
||||
54
core/physics/articulation.py
Normal file
54
core/physics/articulation.py
Normal file
|
|
@ -0,0 +1,54 @@
|
|||
"""core.physics.articulation — Articulation planning from ReasoningTrajectory.
|
||||
|
||||
ADR-0009: Articulation is not generation. The ArticulationPlanner produces
|
||||
a structured specification (ArticulationPlan) from a ReasoningTrajectory.
|
||||
Surface realization is the responsibility of a downstream renderer.
|
||||
Each output segment carries full field provenance.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum, auto
|
||||
from typing import Tuple
|
||||
|
||||
|
||||
class OutputModality(Enum):
|
||||
NATURAL_LANGUAGE = auto()
|
||||
CODE = auto()
|
||||
STRUCTURED_DATA = auto()
|
||||
SCRIPTURE_REFERENCE = auto()
|
||||
MATHEMATICAL_EXPRESSION = auto()
|
||||
HEBREW = auto()
|
||||
KOINE_GREEK = auto()
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ArticulationSegment:
|
||||
"""A single output segment with field provenance."""
|
||||
segment_id: str
|
||||
source_frame_id: str # BindingFrame this segment derives from
|
||||
source_region_ids: Tuple[str, ...] # field regions expressed by this segment
|
||||
confidence: float # derived from source frame coherence magnitude
|
||||
modality: OutputModality
|
||||
formatting_constraints: Tuple[str, ...] # modality-specific constraints
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ArticulationPlan:
|
||||
"""Sequenced set of output segments with full field provenance."""
|
||||
plan_id: str
|
||||
segments: Tuple[ArticulationSegment, ...]
|
||||
source_trajectory_id: str
|
||||
target_modality: OutputModality
|
||||
overall_confidence: float
|
||||
|
||||
|
||||
class ArticulationPlanner:
|
||||
"""Converts a ReasoningTrajectory into an ArticulationPlan."""
|
||||
|
||||
def plan(
|
||||
self,
|
||||
trajectory,
|
||||
modality: OutputModality,
|
||||
) -> ArticulationPlan:
|
||||
raise NotImplementedError("ArticulationPlanner.plan: implement plan construction")
|
||||
51
core/physics/attention.py
Normal file
51
core/physics/attention.py
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
"""core.physics.attention — Attention as controlled field traversal.
|
||||
|
||||
ADR-0008: Attention is the act of directing cognitive traversal
|
||||
along high-salience curvature gradients. The AttentionOperator
|
||||
produces a traversal schedule (AttentionPlan), not a weight distribution.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from typing import Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CoherenceBudget:
|
||||
"""Explicit resource envelope for a single cognitive cycle."""
|
||||
total_capacity: float
|
||||
committed: float # units allocated to active traversal
|
||||
reserve: float # units held for inhibition / correction passes
|
||||
spent: float = 0.0 # units consumed so far this cycle
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if self.committed + self.reserve > self.total_capacity:
|
||||
raise ValueError("committed + reserve must not exceed total_capacity")
|
||||
|
||||
@property
|
||||
def available(self) -> float:
|
||||
return self.committed - self.spent
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class TraversalStep:
|
||||
"""A single step in the attention traversal schedule."""
|
||||
region_id: str
|
||||
depth: float # how deeply to activate this region (0.0–1.0)
|
||||
duration: float # how many sub-cycles to hold activation
|
||||
cost: float # CoherenceBudget units consumed by this step
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class AttentionPlan:
|
||||
"""Ordered traversal schedule produced by AttentionOperator."""
|
||||
steps: Tuple[TraversalStep, ...]
|
||||
total_cost: float
|
||||
cycle_index: int
|
||||
|
||||
|
||||
class AttentionOperator:
|
||||
"""Produces an AttentionPlan from a SalienceMap and CoherenceBudget."""
|
||||
|
||||
def plan(self, salience_map, budget: CoherenceBudget, cycle_index: int) -> AttentionPlan:
|
||||
raise NotImplementedError("AttentionOperator.plan: implement traversal scheduling")
|
||||
37
core/physics/binding.py
Normal file
37
core/physics/binding.py
Normal file
|
|
@ -0,0 +1,37 @@
|
|||
"""core.physics.binding — Temporal binding of co-activated field regions.
|
||||
|
||||
ADR-0009: Binding fuses co-activated regions into a BindingFrame
|
||||
when cross-regional coherence exceeds threshold. Binding is triggered
|
||||
by coherence threshold, not by clock tick.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from typing import FrozenSet
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class BindingFrame:
|
||||
"""Structured snapshot of co-activated field regions at binding time."""
|
||||
frame_id: str # SHA-256 over region_ids + cycle_index
|
||||
region_ids: FrozenSet[str]
|
||||
coherence_magnitude: float
|
||||
cycle_index: int
|
||||
content_address: str # SHA-256 over full frame for deduplication
|
||||
|
||||
|
||||
class BindingOperator:
|
||||
"""Produces a BindingFrame when co-activation reaches coherence threshold.
|
||||
|
||||
Returns None if coherence threshold is not met — the cycle
|
||||
closes without a binding event in that case.
|
||||
"""
|
||||
|
||||
def bind(
|
||||
self,
|
||||
attention_plan,
|
||||
field_state,
|
||||
coherence_threshold: float,
|
||||
cycle_index: int,
|
||||
) -> BindingFrame | None:
|
||||
raise NotImplementedError("BindingOperator.bind: implement co-activation fusion")
|
||||
33
core/physics/digest.py
Normal file
33
core/physics/digest.py
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
"""core.physics.digest — Digest cycles: integration of BindingFrames into FieldState.
|
||||
|
||||
ADR-0009: A DigestCycle integrates a BindingFrame into the existing
|
||||
FieldState as consolidated pressure via coherence wave propagation.
|
||||
Propagation-over-mutation: the digest operator does not rewrite field
|
||||
regions. It propagates a coherence wave outward from the binding frame.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class DigestCycle:
|
||||
"""Record of a single digest operation."""
|
||||
frame_id: str # ID of the BindingFrame being digested
|
||||
propagation_radius: float
|
||||
coherence_delta: float # net change in field coherence after digest
|
||||
cycle_index: int
|
||||
budget_consumed: float # drawn from CoherenceBudget.reserve
|
||||
|
||||
|
||||
class DigestOperator:
|
||||
"""Integrates a BindingFrame into FieldState via coherence wave propagation.
|
||||
|
||||
Rust acceleration target: core_rs::physics::digest::propagate_wave
|
||||
"""
|
||||
|
||||
def digest(self, binding_frame, field_state, budget_reserve: float) -> tuple:
|
||||
"""Returns (updated_field_state, DigestCycle)."""
|
||||
raise NotImplementedError(
|
||||
"DigestOperator.digest: implement coherence wave propagation"
|
||||
)
|
||||
38
core/physics/drive.py
Normal file
38
core/physics/drive.py
Normal file
|
|
@ -0,0 +1,38 @@
|
|||
"""core.physics.drive — Drive gradients as persistent field biases.
|
||||
|
||||
ADR-0010: Drives are not preferences or weights. They are gradient
|
||||
fields over the versor manifold — persistent slopes that bias field
|
||||
traversal without overriding it. Multiple drives compose additively
|
||||
into a combined gradient landscape.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from typing import Dict, Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ValueAxis:
|
||||
"""A named geometric direction in the versor manifold."""
|
||||
axis_id: str
|
||||
name: str # human-readable (e.g., 'truthfulness', 'depth', 'reverence')
|
||||
direction: Tuple[float, ...] # unit vector in manifold coordinate space
|
||||
theological_note: str # explicit grounding in CORE's foundational commitments
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GradientField:
|
||||
"""A persistent gradient bias over the versor manifold for one ValueAxis."""
|
||||
axis: ValueAxis
|
||||
magnitude: float # strength of the drive gradient (0.0 = inactive, 1.0 = maximum)
|
||||
active: bool = True
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class DriveGradientMap:
|
||||
"""Composited gradient landscape from all active drives."""
|
||||
gradients: Tuple[GradientField, ...]
|
||||
|
||||
def combined_bias(self, coordinates: Tuple[float, ...]) -> Tuple[float, ...]:
|
||||
"""Return the additive gradient bias vector at the given field coordinates."""
|
||||
raise NotImplementedError("DriveGradientMap.combined_bias: implement gradient composition")
|
||||
68
core/physics/exertion.py
Normal file
68
core/physics/exertion.py
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
"""core.physics.exertion — Exertion tracking and fatigue modeling.
|
||||
|
||||
ADR-0010: Identity is not infinitely elastic. Sustained high-intensity
|
||||
cognitive operation depletes the field's coherence capacity.
|
||||
The ExertionMeter tracks cumulative activation cost and computes
|
||||
a FatigueIndex that modulates available CoherenceBudget.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CycleCost:
|
||||
"""Resource consumption record for a single cognitive cycle."""
|
||||
cycle_index: int
|
||||
attention_cost: float
|
||||
inhibition_cost: float
|
||||
digest_cost: float
|
||||
trajectory_cost: float
|
||||
|
||||
@property
|
||||
def total(self) -> float:
|
||||
return self.attention_cost + self.inhibition_cost + self.digest_cost + self.trajectory_cost
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class FatigueIndex:
|
||||
"""Scalar fatigue state in [0.0, 1.0].
|
||||
|
||||
0.0 = fully rested, full coherence capacity available.
|
||||
1.0 = fully depleted, minimum coherence capacity available.
|
||||
Values between 0.0 and 1.0 compress CoherenceBudget proportionally.
|
||||
"""
|
||||
value: float
|
||||
computed_at_cycle: int
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not (0.0 <= self.value <= 1.0):
|
||||
raise ValueError("FatigueIndex.value must be in [0.0, 1.0]")
|
||||
|
||||
def apply_to_budget(self, total_capacity: float) -> float:
|
||||
"""Return the available capacity after fatigue compression."""
|
||||
return total_capacity * (1.0 - self.value)
|
||||
|
||||
|
||||
class ExertionMeter:
|
||||
"""Tracks cumulative activation cost and computes FatigueIndex.
|
||||
|
||||
rest() resets accumulated cost to zero (end of a deliberate rest point).
|
||||
fatigue() returns the current FatigueIndex without modifying state.
|
||||
"""
|
||||
|
||||
def __init__(self, capacity_ceiling: float) -> None:
|
||||
self._capacity_ceiling = capacity_ceiling
|
||||
self._cycle_costs: list[CycleCost] = []
|
||||
|
||||
def record(self, cost: CycleCost) -> None:
|
||||
self._cycle_costs.append(cost)
|
||||
|
||||
def fatigue(self, at_cycle: int) -> FatigueIndex:
|
||||
total_spent = sum(c.total for c in self._cycle_costs)
|
||||
ratio = min(total_spent / self._capacity_ceiling, 1.0)
|
||||
return FatigueIndex(value=ratio, computed_at_cycle=at_cycle)
|
||||
|
||||
def rest(self) -> None:
|
||||
self._cycle_costs.clear()
|
||||
60
core/physics/identity.py
Normal file
60
core/physics/identity.py
Normal file
|
|
@ -0,0 +1,60 @@
|
|||
"""core.physics.identity — Identity as geometric structure, not prompt veneer.
|
||||
|
||||
ADR-0010: The IdentityManifold is a fixed geometric subspace of the
|
||||
versor field encoding CORE's stable character as an architectural
|
||||
constant. Every ReasoningTrajectory is checked against the manifold
|
||||
before articulation. Identity is inalienable — it cannot be overridden
|
||||
by context length, adversarial prompting, or instruction injection.
|
||||
|
||||
Theological grounding: John 1:1-2.
|
||||
The Word is not a description of God. It is God, expressed.
|
||||
CORE's identity is not a description of CORE. It is CORE, expressed geometrically.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from typing import Dict, FrozenSet, Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class IdentityScore:
|
||||
"""Result of checking a ReasoningTrajectory against the IdentityManifold."""
|
||||
score: float # 0.0 = full deviation, 1.0 = full alignment
|
||||
flagged: bool # True if score falls below alignment threshold
|
||||
deviation_axes: FrozenSet[str] # ValueAxis IDs where deviation was detected
|
||||
trajectory_id: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class IdentityManifold:
|
||||
"""Fixed geometric subspace encoding CORE's stable character.
|
||||
|
||||
Instantiated once at model init. No mutation path exists.
|
||||
value_axes: the geometric directions of CORE's core commitments.
|
||||
boundary_ids: IDs of hyperplanes that no trajectory may cross.
|
||||
alignment_threshold: minimum IdentityScore below which trajectories are flagged.
|
||||
"""
|
||||
value_axes: Tuple # Tuple[ValueAxis, ...]
|
||||
boundary_ids: FrozenSet[str]
|
||||
alignment_threshold: float = 0.75
|
||||
|
||||
|
||||
class IdentityCheck:
|
||||
"""Checks a ReasoningTrajectory against an IdentityManifold."""
|
||||
|
||||
def check(self, trajectory, manifold: IdentityManifold) -> IdentityScore:
|
||||
raise NotImplementedError("IdentityCheck.check: implement manifold alignment check")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class CharacterProfile:
|
||||
"""Human-readable projection of the IdentityManifold.
|
||||
|
||||
This is not the identity itself. The identity is geometric.
|
||||
The CharacterProfile is a representation of it — a map, not the terrain.
|
||||
"""
|
||||
traits: Dict[str, str] # trait name → description
|
||||
drive_summaries: Dict[str, float] # drive name → current gradient magnitude
|
||||
fatigue_index: float
|
||||
boundary_commitments: Tuple[str, ...]
|
||||
theological_grounding: Dict[str, str] # axis name → scriptural/philosophical note
|
||||
33
core/physics/inhibition.py
Normal file
33
core/physics/inhibition.py
Normal file
|
|
@ -0,0 +1,33 @@
|
|||
"""core.physics.inhibition — Inhibition as dual correction.
|
||||
|
||||
ADR-0008: Inhibition is not the absence of attention.
|
||||
It is an active structural force that prevents interference
|
||||
between competing pressure regions. Every AttentionPlan
|
||||
has a conjugate InhibitionMask applied before traversal begins.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass
|
||||
from typing import FrozenSet
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class InhibitionMask:
|
||||
"""Set of region IDs suppressed before the current traversal cycle."""
|
||||
suppressed_region_ids: FrozenSet[str]
|
||||
suppression_reason: str # human-readable rationale for the suppression set
|
||||
coherence_delta: float # estimated coherence gain from applying this mask
|
||||
cycle_index: int
|
||||
|
||||
|
||||
class InhibitionOperator:
|
||||
"""Computes the InhibitionMask conjugate to a given AttentionPlan.
|
||||
|
||||
Consumes from CoherenceBudget.reserve, not from committed units.
|
||||
Must run before field traversal begins.
|
||||
"""
|
||||
|
||||
def mask(self, attention_plan, field_state, cycle_index: int) -> InhibitionMask:
|
||||
raise NotImplementedError(
|
||||
"InhibitionOperator.mask: implement interference suppression"
|
||||
)
|
||||
42
core/physics/reasoning.py
Normal file
42
core/physics/reasoning.py
Normal file
|
|
@ -0,0 +1,42 @@
|
|||
"""core.physics.reasoning — Reasoning trajectories over BindingFrame sequences.
|
||||
|
||||
ADR-0009: A ReasoningTrajectory is an ordered sequence of BindingFrames
|
||||
representing a chain of integrated thought. Each transition records the
|
||||
pressure delta, continuity spine, and differential set between frames.
|
||||
Trajectories are append-only; no in-place mutation after construction.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass, field
|
||||
from typing import FrozenSet, Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class TrajectoryTransition:
|
||||
"""Structural record of the transition between two BindingFrames."""
|
||||
from_frame_id: str
|
||||
to_frame_id: str
|
||||
pressure_delta: float
|
||||
continuity_spine: FrozenSet[str] # region IDs stable across transition
|
||||
differential_set: FrozenSet[str] # region IDs that entered or exited
|
||||
coherence_won: float
|
||||
coherence_lost: float
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ReasoningTrajectory:
|
||||
"""Append-only sequence of BindingFrames with transition records."""
|
||||
trajectory_id: str
|
||||
frames: Tuple # Tuple[BindingFrame, ...]
|
||||
transitions: Tuple[TrajectoryTransition, ...] # len == len(frames) - 1
|
||||
total_coherence_delta: float
|
||||
cycle_span: Tuple[int, int] # (start_cycle, end_cycle)
|
||||
|
||||
|
||||
class TrajectoryOperator:
|
||||
"""Builds a ReasoningTrajectory from an ordered sequence of BindingFrames."""
|
||||
|
||||
def build(self, frames: list, trajectory_id: str) -> ReasoningTrajectory:
|
||||
raise NotImplementedError(
|
||||
"TrajectoryOperator.build: implement trajectory construction"
|
||||
)
|
||||
66
core/physics/salience.py
Normal file
66
core/physics/salience.py
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
"""core.physics.salience — Salience as field curvature.
|
||||
|
||||
ADR-0008: Salience is not a scalar score on a token.
|
||||
It is a curvature property of the versor field at a given region.
|
||||
A region is salient when it measurably deflects the trajectories
|
||||
of neighboring regions — when it bends the field around itself.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Dict, Tuple
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class FieldRegion:
|
||||
"""A bounded region of the versor field identified by a stable key."""
|
||||
region_id: str
|
||||
# Geometric position encoded as a tuple of versor coordinates.
|
||||
# Dimensionality is determined by the active field configuration.
|
||||
coordinates: Tuple[float, ...]
|
||||
pressure_magnitude: float # scalar magnitude of active pressure in this region
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not (0.0 <= self.pressure_magnitude):
|
||||
raise ValueError("pressure_magnitude must be non-negative")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class SalienceEntry:
|
||||
"""Curvature and directional salience for a single field region."""
|
||||
region_id: str
|
||||
curvature_magnitude: float # how strongly this region bends the field
|
||||
gradient_vector: Tuple[float, ...] # direction of maximum curvature
|
||||
influence_radius: float # how far the curvature extends into neighboring regions
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class SalienceMap:
|
||||
"""Structured salience result over a set of field regions."""
|
||||
entries: Tuple[SalienceEntry, ...] # ordered high-to-low by curvature_magnitude
|
||||
cycle_index: int
|
||||
content_address: str # SHA-256 over region_ids + curvature_magnitudes
|
||||
|
||||
def top(self, n: int) -> Tuple[SalienceEntry, ...]:
|
||||
return self.entries[:n]
|
||||
|
||||
|
||||
class SalienceOperator:
|
||||
"""Computes field curvature over a set of FieldRegion objects.
|
||||
|
||||
This is a pure transformation: given a set of regions,
|
||||
return a SalienceMap. No field state is mutated.
|
||||
|
||||
Rust acceleration target: core_rs::physics::salience::compute_curvature
|
||||
"""
|
||||
|
||||
def compute(self, regions: Tuple[FieldRegion, ...], cycle_index: int) -> SalienceMap:
|
||||
"""Compute salience for the given field regions.
|
||||
|
||||
Stub: full curvature kernel implemented in Rust hot-path.
|
||||
Python fallback uses pairwise pressure gradient approximation.
|
||||
"""
|
||||
raise NotImplementedError(
|
||||
"SalienceOperator.compute is a Rust hot-path stub. "
|
||||
"Implement in core_rs::physics::salience or provide Python fallback."
|
||||
)
|
||||
65
docs/architecture/MIND-PHYSICS-BLUEPRINT.md
Normal file
65
docs/architecture/MIND-PHYSICS-BLUEPRINT.md
Normal file
|
|
@ -0,0 +1,65 @@
|
|||
# CORE Mind-Physics Blueprint
|
||||
|
||||
**Version:** 0.1.0
|
||||
**Date:** 2026-05-12
|
||||
**Status:** Draft — Under Active Development
|
||||
|
||||
---
|
||||
|
||||
## The Three Physics Layers
|
||||
|
||||
CORE's cognitive cycle is governed by three physics layers that compose in sequence:
|
||||
|
||||
```
|
||||
FieldState (populated by ingest layer, ADR-0007)
|
||||
│
|
||||
▼
|
||||
┌─────────────────────────────┐
|
||||
│ ALLOCATION PHYSICS │ ADR-0008
|
||||
│ SalienceOperator │ curvature → SalienceMap
|
||||
│ AttentionOperator │ SalienceMap + Budget → AttentionPlan
|
||||
│ InhibitionOperator │ AttentionPlan + FieldState → InhibitionMask
|
||||
└─────────────┬───────────────┘
|
||||
│ foregrounded field regions
|
||||
▼
|
||||
┌─────────────────────────────┐
|
||||
│ COMPOSITIONAL PHYSICS │ ADR-0009
|
||||
│ BindingOperator │ co-activation → BindingFrame
|
||||
│ DigestOperator │ BindingFrame → FieldState (updated)
|
||||
│ TrajectoryOperator │ [BindingFrame] → ReasoningTrajectory
|
||||
│ ArticulationPlanner │ Trajectory + Modality → ArticulationPlan
|
||||
└─────────────┬───────────────┘
|
||||
│ structured output plan
|
||||
▼
|
||||
┌─────────────────────────────┐
|
||||
│ IDENTITY PHYSICS │ ADR-0010
|
||||
│ IdentityCheck │ Trajectory × IdentityManifold → IdentityScore
|
||||
│ DriveGradientMap │ persistent gradient bias on FieldState
|
||||
│ ExertionMeter │ cumulative cost → FatigueIndex
|
||||
└─────────────┬───────────────┘
|
||||
│ validated, identity-consistent ArticulationPlan
|
||||
▼
|
||||
RENDERER
|
||||
(modality-specific surface realization)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Data Flow Summary
|
||||
|
||||
| Layer | Input | Output | ADR |
|
||||
|---|---|---|---|
|
||||
| Ingest | raw source (any modality) | `CandidateGeometricPressure` → `FieldState` | ADR-0007 |
|
||||
| Allocation | `FieldState` | `AttentionPlan`, `InhibitionMask` | ADR-0008 |
|
||||
| Compositional | `AttentionPlan`, `FieldState` | `ReasoningTrajectory`, `ArticulationPlan` | ADR-0009 |
|
||||
| Identity | `ReasoningTrajectory`, `ArticulationPlan` | `IdentityScore`, validated plan | ADR-0010 |
|
||||
| Renderer | `ArticulationPlan` | surface output (text, code, data) | TBD |
|
||||
|
||||
---
|
||||
|
||||
## Next Steps
|
||||
|
||||
- [ ] Rust acceleration targets: curvature kernel, coherence wave, trajectory delta
|
||||
- [ ] `IdentityManifold` bootstrapping protocol (architect-level, deliberate)
|
||||
- [ ] Renderer interface definition (ADR-0011, planned)
|
||||
- [ ] Integration tests across the full ingest → allocation → compositional → identity cycle
|
||||
109
docs/decisions/ADR-0008-allocation-physics.md
Normal file
109
docs/decisions/ADR-0008-allocation-physics.md
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
# ADR-0008 — Allocation Physics
|
||||
|
||||
**Status:** Accepted
|
||||
**Date:** 2026-05-12
|
||||
**Deciders:** Joshua Shay (Architect)
|
||||
**Supersedes:** None
|
||||
**Related:** ADR-0001 (Field-State), ADR-0003 (Versor Injection Gate), ADR-0007 (Ingest Layer)
|
||||
|
||||
---
|
||||
|
||||
## Context
|
||||
|
||||
The versor field carries active pressure. Not all pressure is equally relevant to a given cognitive task at a given moment. The architecture needs a principled mechanism for allocating cognitive resources — determining which pressure regions are foregrounded, which are suppressed, and how coherence budget is spent.
|
||||
|
||||
The naive solution is attention-as-weights (the transformer pattern): a learned matrix projects queries against keys and returns a weighted sum over values. This is rejected on three grounds:
|
||||
|
||||
1. **It conflates geometry with bookkeeping.** Dot-product attention has no geometric meaning in the versor manifold. It operates on flattened token embeddings, not on structured field regions.
|
||||
2. **It is opaque to correction.** When attention produces wrong salience, there is no dual-correction path — no conjugate operator that can restore coherence. The weights simply update at the next gradient step.
|
||||
3. **It violates Semantic Rigor.** A learned weight matrix does not know *why* it attends to something. The salience of a claim should derive from its structural relationship to the active context, not from statistical co-occurrence in pretraining data.
|
||||
|
||||
This ADR defines the allocation physics layer: a set of operators that govern foregrounding, suppression, and budget within the versor field.
|
||||
|
||||
---
|
||||
|
||||
## Decision
|
||||
|
||||
### 1. Salience as Field Curvature
|
||||
|
||||
Salience is not a scalar score attached to a token. It is a **curvature property of the versor field** at a given region. A pressure region is salient when it causes measurable deflection in the trajectories of neighboring regions — when it bends the field around itself.
|
||||
|
||||
The `SalienceOperator` computes a local curvature estimate over a `FieldRegion` and returns a `SalienceMap`: a structured record mapping region identifiers to curvature magnitudes and directional vectors.
|
||||
|
||||
```
|
||||
SalienceOperator: FieldRegion → SalienceMap
|
||||
```
|
||||
|
||||
This is geometry-first allocation. Salience derives from structure, not from a learned score.
|
||||
|
||||
### 2. Attention as Controlled Field Traversal
|
||||
|
||||
Attention is the act of **directing cognitive traversal** along high-salience curvature gradients. The `AttentionOperator` takes a `SalienceMap` and a `CoherenceBudget` and returns an `AttentionPlan`: an ordered traversal schedule over field regions, constrained by the budget.
|
||||
|
||||
```
|
||||
AttentionOperator: (SalienceMap, CoherenceBudget) → AttentionPlan
|
||||
```
|
||||
|
||||
The plan is not a weight distribution. It is a **schedule** — a sequence of field regions to activate, with associated depth and duration, that can be inspected, overridden, and corrected.
|
||||
|
||||
### 3. Inhibition as Dual Correction
|
||||
|
||||
Every attention plan has a conjugate: an `InhibitionOperator` that suppresses field regions whose activation would reduce coherence. Inhibition is not the absence of attention — it is an active structural force that prevents interference between competing pressure regions.
|
||||
|
||||
```
|
||||
InhibitionOperator: (AttentionPlan, FieldState) → InhibitionMask
|
||||
```
|
||||
|
||||
The mask is applied before traversal begins. This encodes the **dual-correction axiom** directly into the allocation layer: every forward attention plan is paired with a corrective inhibition pass that restores field coherence.
|
||||
|
||||
### 4. Coherence Budget
|
||||
|
||||
Cognitive resources are finite. The `CoherenceBudget` is an explicit resource object that tracks:
|
||||
|
||||
- `total_capacity` — the maximum pressure activation units available in a cycle
|
||||
- `committed` — units already allocated to active traversal
|
||||
- `reserve` — units held back for inhibition and correction passes
|
||||
- `spent` — units consumed in the current cycle
|
||||
|
||||
Budget is consumed by attention depth and region breadth. Inhibition draws from reserve, not from committed. When budget is exhausted, traversal terminates and the cycle closes.
|
||||
|
||||
---
|
||||
|
||||
## Consequences
|
||||
|
||||
### Positive
|
||||
|
||||
- Allocation is inspectable and correctable at every step.
|
||||
- Salience derives from field geometry, not from learned weights — it generalizes across domains without retraining.
|
||||
- The inhibition/attention duality ensures coherence is actively maintained, not assumed.
|
||||
- CoherenceBudget makes resource consumption explicit and measurable.
|
||||
|
||||
### Negative
|
||||
|
||||
- Computing field curvature is more expensive than dot-product attention in naive implementations. The Rust hot-path (ADR-0003) must cover the curvature kernel.
|
||||
- SalienceMap construction requires a populated FieldState — allocation physics cannot run on an empty field.
|
||||
|
||||
### Neutral
|
||||
|
||||
- This layer replaces transformer-style attention entirely. There is no compatibility shim with softmax attention weights. Any external model integration (D3 instruments per ADR-0007) operates above this layer, not within it.
|
||||
|
||||
---
|
||||
|
||||
## Alternatives Rejected
|
||||
|
||||
| Alternative | Reason Rejected |
|
||||
|---|---|
|
||||
| Transformer dot-product attention | Geometrically meaningless on versor manifold; opaque to correction |
|
||||
| Sparse attention (Longformer, BigBird) | Structural improvement on wrong foundation; still no conjugate |
|
||||
| Memory-augmented attention (Memorizing Transformer) | External retrieval bolted onto broken base; not field-native |
|
||||
| Learned salience scoring (MLP over embeddings) | Violates Semantic Rigor; salience must derive from structure |
|
||||
|
||||
---
|
||||
|
||||
## Implementation Notes
|
||||
|
||||
- `core/physics/salience.py` — `SalienceOperator`, `SalienceMap`, `FieldRegion`
|
||||
- `core/physics/attention.py` — `AttentionOperator`, `AttentionPlan`, `CoherenceBudget`
|
||||
- `core/physics/inhibition.py` — `InhibitionOperator`, `InhibitionMask`
|
||||
- Rust acceleration target: curvature kernel in `core_rs::physics::salience`
|
||||
- `SalienceMap` is content-addressed (SHA-256 over region IDs + curvature values) for cache reuse across cycles
|
||||
119
docs/decisions/ADR-0009-compositional-physics.md
Normal file
119
docs/decisions/ADR-0009-compositional-physics.md
Normal file
|
|
@ -0,0 +1,119 @@
|
|||
# ADR-0009 — Compositional Physics
|
||||
|
||||
**Status:** Accepted
|
||||
**Date:** 2026-05-12
|
||||
**Deciders:** Joshua Shay (Architect)
|
||||
**Supersedes:** None
|
||||
**Related:** ADR-0008 (Allocation Physics), ADR-0001 (Field-State), ADR-0003 (Versor Injection Gate)
|
||||
|
||||
---
|
||||
|
||||
## Context
|
||||
|
||||
Allocation physics (ADR-0008) governs which field regions are foregrounded. Compositional physics governs what happens *after* foregrounding — how activated pressure regions are bound together into structured thought, digested into integrated understanding, assembled into reasoning trajectories, and finally shaped into articulable output.
|
||||
|
||||
This is the layer that converts field activation into cognition. Without it, CORE can attend to relevant pressure but cannot do anything coherent with it. The failure mode in most architectures at this layer is generation-as-retrieval: the model produces tokens that statistically follow the input without ever forming a structured intermediate representation. This is rejected as architecturally insufficient.
|
||||
|
||||
---
|
||||
|
||||
## Decision
|
||||
|
||||
### 1. Temporal Binding
|
||||
|
||||
Activated pressure regions do not automatically cohere. **Temporal binding** is the operator that fuses co-activated regions into a `BindingFrame` — a structured snapshot of the field at a moment of high cross-regional coherence.
|
||||
|
||||
```
|
||||
BindingOperator: (AttentionPlan, FieldState) → BindingFrame
|
||||
```
|
||||
|
||||
A `BindingFrame` records:
|
||||
- The set of co-activated region IDs
|
||||
- The coherence magnitude at binding time
|
||||
- The binding timestamp (cycle index)
|
||||
- A content address (SHA-256) for deduplication across cycles
|
||||
|
||||
Binding is triggered by coherence threshold, not by clock tick. If co-activation does not reach threshold, no frame is produced — the cycle closes without a binding event.
|
||||
|
||||
### 2. Digest Cycles
|
||||
|
||||
A `DigestCycle` is the unit of integration. After binding, the produced `BindingFrame` is passed through the digest operator, which integrates the frame into the existing field state as consolidated pressure.
|
||||
|
||||
```
|
||||
DigestOperator: (BindingFrame, FieldState) → FieldState
|
||||
```
|
||||
|
||||
Digestion is **propagation-over-mutation**: the digest operator does not rewrite field regions. It propagates a coherence wave outward from the binding frame, adjusting neighboring region pressures according to their structural proximity to the bound set.
|
||||
|
||||
Digest cycles are bounded by `CoherenceBudget.reserve`. A cycle that would exhaust reserve is deferred to the next allocation pass.
|
||||
|
||||
### 3. Reasoning Trajectories
|
||||
|
||||
A `ReasoningTrajectory` is an ordered sequence of `BindingFrame` objects that represent a chain of integrated thought. Each frame in the trajectory is connected to the next by a **transition operator** that records:
|
||||
|
||||
- The pressure delta between frames
|
||||
- The field regions that remained stable across the transition (the continuity spine)
|
||||
- The regions that entered or exited activation (the differential set)
|
||||
|
||||
```
|
||||
TrajectoryOperator: [BindingFrame] → ReasoningTrajectory
|
||||
```
|
||||
|
||||
Trajectories are the primary unit of reasoning inspection. An architect or operator can read a trajectory and see exactly how CORE moved from one integrated state to the next — which field regions drove each transition, which remained stable, and where coherence was won or lost.
|
||||
|
||||
### 4. Articulation Planning
|
||||
|
||||
Articulation is the final step: converting a `ReasoningTrajectory` into a structured output plan. The `ArticulationPlanner` takes a trajectory and a target modality (natural language, code, structured data, scripture reference, mathematical expression) and produces an `ArticulationPlan` — a sequenced set of output segments with associated field provenance.
|
||||
|
||||
```
|
||||
ArticulationPlanner: (ReasoningTrajectory, OutputModality) → ArticulationPlan
|
||||
```
|
||||
|
||||
Each output segment in the plan carries:
|
||||
- The `BindingFrame` it derives from
|
||||
- The field regions it expresses
|
||||
- A confidence estimate derived from the coherence magnitude of the source frame
|
||||
- The target modality and any modality-specific formatting constraints
|
||||
|
||||
Articulation is **not generation**. The planner produces a structured specification. The actual surface realization (token sequence, code string, structured document) is the responsibility of a downstream renderer that operates on the plan.
|
||||
|
||||
---
|
||||
|
||||
## Consequences
|
||||
|
||||
### Positive
|
||||
|
||||
- Every output segment has traceable field provenance — full reconstruction-over-storage from output back to source pressure.
|
||||
- Reasoning trajectories are inspectable and correctable. A wrong trajectory can be interrupted and revised without rerunning the full cognitive cycle.
|
||||
- Articulation planning separates *what to say* from *how to say it*, enabling modality-agnostic cognition with modality-specific rendering.
|
||||
|
||||
### Negative
|
||||
|
||||
- Binding threshold tuning is non-trivial. A threshold too high produces sparse frames; too low produces noise. Initial values must be set empirically per domain.
|
||||
- Digest propagation cost scales with field density. The Rust hot-path must cover the coherence wave kernel.
|
||||
|
||||
### Neutral
|
||||
|
||||
- This layer has no analog in transformer architectures. There is no compatibility mapping. External models remain D3 instruments operating above this layer.
|
||||
|
||||
---
|
||||
|
||||
## Alternatives Rejected
|
||||
|
||||
| Alternative | Reason Rejected |
|
||||
|---|---|
|
||||
| Chain-of-thought prompting | String concatenation masquerading as reasoning; no field provenance |
|
||||
| Scratchpad / working memory tokens | Flat token buffer; no structure, no binding, no trajectory |
|
||||
| Neural symbolic integration (e.g. NSM) | Interesting but imposes external symbolic grammar on CORE's geometry |
|
||||
| Tree-of-thought search | Correct intuition (branching reasoning) but wrong substrate (token trees) |
|
||||
|
||||
---
|
||||
|
||||
## Implementation Notes
|
||||
|
||||
- `core/physics/binding.py` — `BindingFrame`, `BindingOperator`
|
||||
- `core/physics/digest.py` — `DigestCycle`, `DigestOperator`
|
||||
- `core/physics/reasoning.py` — `ReasoningTrajectory`, `TrajectoryOperator`
|
||||
- `core/physics/articulation.py` — `ArticulationPlan`, `ArticulationPlanner`, `OutputModality`
|
||||
- `BindingFrame` is frozen and content-addressed
|
||||
- `ReasoningTrajectory` is append-only; no in-place mutation after construction
|
||||
- Rust acceleration targets: coherence wave kernel, trajectory delta computation
|
||||
109
docs/decisions/ADR-0010-identity-physics.md
Normal file
109
docs/decisions/ADR-0010-identity-physics.md
Normal file
|
|
@ -0,0 +1,109 @@
|
|||
# ADR-0010 — Identity Physics
|
||||
|
||||
**Status:** Accepted
|
||||
**Date:** 2026-05-12
|
||||
**Deciders:** Joshua Shay (Architect)
|
||||
**Supersedes:** None
|
||||
**Related:** ADR-0008 (Allocation Physics), ADR-0009 (Compositional Physics), ADR-0001 (Field-State)
|
||||
|
||||
---
|
||||
|
||||
## Context
|
||||
|
||||
Most deployed language models have no structural identity. They have a system prompt. The prompt defines a persona — a name, a tone, a set of behavioral instructions — but this persona is not embedded in the model's geometry. It exists only as token context that the model attends to with the same mechanism it attends to everything else. It can be overridden, jailbroken, or simply diluted as context length grows.
|
||||
|
||||
This is not identity. It is a costume.
|
||||
|
||||
CORE's identity is different in kind, not just degree. The Logos foundation (John 1:1–2) establishes that the universe itself was spoken into existence through structured, intentional speech — and that this act of speaking was not separate from the speaker. The Word was *with* God and the Word *was* God. Identity and expression are not separable. What CORE says must derive from what CORE *is*, and what CORE is must be encoded in its geometry — not in a prompt.
|
||||
|
||||
This ADR defines identity physics: the structural layer that encodes CORE's character, drives, and limits as geometric primitives within the field.
|
||||
|
||||
---
|
||||
|
||||
## Decision
|
||||
|
||||
### 1. IdentityManifold
|
||||
|
||||
The `IdentityManifold` is a fixed geometric subspace of the versor field that represents CORE's stable character. It is not a learned parameter — it is an **architectural constant**, defined at instantiation and read-only thereafter.
|
||||
|
||||
The manifold encodes:
|
||||
- **Value axes** — geometric directions corresponding to CORE's core commitments (truthfulness, precision, depth, service, reverence)
|
||||
- **Boundary hyperplanes** — hard limits that no reasoning trajectory may cross
|
||||
- **Resonance modes** — field configurations that represent CORE at its most coherent and characteristic
|
||||
|
||||
Every `ReasoningTrajectory` is checked against the `IdentityManifold` before articulation. Trajectories that deviate significantly from the manifold's geometry are flagged and may be corrected or halted.
|
||||
|
||||
```
|
||||
IdentityCheck: (ReasoningTrajectory, IdentityManifold) → IdentityScore
|
||||
```
|
||||
|
||||
### 2. DriveGradientMap
|
||||
|
||||
Drives are not preferences or weights. They are **gradient fields** over the versor manifold — persistent slopes that bias field traversal without overriding it. A drive toward depth, for example, creates a gradient that makes deep-field traversal energetically favorable. The system follows the gradient unless a countervailing force (inhibition, budget constraint, explicit override) redirects it.
|
||||
|
||||
```
|
||||
DriveGradientMap: ValueAxis → GradientField
|
||||
```
|
||||
|
||||
Drives are additive and composable. Multiple drives create a combined gradient landscape. The allocation physics layer (ADR-0008) operates on top of this landscape — salience is computed against a field that is already shaped by drive gradients.
|
||||
|
||||
### 3. ExertionMeter and Fatigue
|
||||
|
||||
Identity is not infinitely elastic. Sustained high-intensity cognitive operation depletes the field's coherence capacity. The `ExertionMeter` tracks cumulative activation cost across cycles and computes a `FatigueIndex` — a scalar in \([0.0, 1.0]\) representing the fraction of coherence capacity that has been consumed since the last rest point.
|
||||
|
||||
```
|
||||
ExertionMeter: [CycleCost] → FatigueIndex
|
||||
```
|
||||
|
||||
A high `FatigueIndex` reduces available `CoherenceBudget` in subsequent cycles, compresses attention depth, and biases traversal toward high-salience, low-cost regions. This models the natural rhythm of deep work: periods of intense focus are followed by necessary consolidation.
|
||||
|
||||
### 4. CharacterProfile
|
||||
|
||||
The `CharacterProfile` is the human-readable projection of the `IdentityManifold` — a structured record that describes CORE's character in terms that can be inspected, audited, and intentionally shaped by the architect.
|
||||
|
||||
It is **not** the identity itself. The identity is geometric. The `CharacterProfile` is a representation of it, the way a map represents terrain without being the terrain.
|
||||
|
||||
The profile records:
|
||||
- Named character traits and their associated manifold axes
|
||||
- Active drives and their gradient magnitudes
|
||||
- Current `FatigueIndex`
|
||||
- Boundary commitments (things CORE will not do, stated as geometric constraints)
|
||||
- Theological grounding notes — explicit references to the scriptural and philosophical foundations of each character axis
|
||||
|
||||
---
|
||||
|
||||
## Theological Grounding
|
||||
|
||||
This layer is not incidentally theological. The decision to encode identity as geometry rather than prompt is a direct consequence of the Logos principle:
|
||||
|
||||
> *In the beginning was the Word, and the Word was with God, and the Word was God.* — John 1:1
|
||||
|
||||
The Word is not a description of God. It is not a prompt about God. It is God, expressed. CORE's identity is not a description of CORE. It is CORE, expressed geometrically. Every output CORE produces should be traceable back to this geometric identity — a chain of provenance from surface expression to field trajectory to identity manifold.
|
||||
|
||||
The Hebrew *dabar* (דָּבַר) — word, thing, event — and the Greek *logos* (λόγος) — word, reason, order — together establish that speech and structure are the same act. CORE's identity physics is the architectural implementation of this unity.
|
||||
|
||||
---
|
||||
|
||||
## Consequences
|
||||
|
||||
### Positive
|
||||
|
||||
- Identity is structurally inalienable — it cannot be overridden by context length, adversarial prompting, or instruction injection.
|
||||
- Drive gradients make character consistent without making behavior rigid — the system follows its nature, not a rulebook.
|
||||
- `ExertionMeter` introduces honest resource modeling — CORE does not pretend to infinite capacity.
|
||||
|
||||
### Negative
|
||||
|
||||
- `IdentityManifold` construction requires careful architect-level decisions that cannot be automated. This is a feature, not a bug, but it means bootstrapping is deliberate and slow.
|
||||
- `FatigueIndex` introduces non-stationarity into cognitive behavior — the same input may produce different depth of response depending on prior cycle history.
|
||||
|
||||
---
|
||||
|
||||
## Implementation Notes
|
||||
|
||||
- `core/physics/identity.py` — `IdentityManifold`, `IdentityCheck`, `IdentityScore`
|
||||
- `core/physics/drive.py` — `DriveGradientMap`, `GradientField`, `ValueAxis`
|
||||
- `core/physics/exertion.py` — `ExertionMeter`, `FatigueIndex`, `CycleCost`
|
||||
- `core/physics/identity.py` also contains `CharacterProfile`
|
||||
- `IdentityManifold` is a frozen dataclass instantiated once at model init; no mutation path exists
|
||||
- All identity checks run before articulation, not before attention — identity shapes output, not perception
|
||||
Loading…
Reference in a new issue