Struct CoherenceField 

pub struct CoherenceField<V: SensorVocabulary<N>, const N: usize> { /* private fields */ }

The coherence field: a map of context → CoherenceAccumulator.

Generic over any sensor vocabulary V implementing SensorVocabulary<N>. Maintains at most [MAX_CONTEXTS] entries with LRU eviction.

Patent Claims 6–7, 13.

Implementations

impl<V: SensorVocabulary<N>, const N: usize> CoherenceField<V, N>

pub fn new() -> Self

Construct a fresh field with no accumulated coherence.

Examples found in repository

examples/mbot2.rs (line 82)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn effective_coherence(&self, instant: f32, key: &ContextKey<V, N>) -> f32

Compute effective coherence using the asymmetric gate (CCF-001).

• Unfamiliar (ctx < 0.3): min(instant, ctx) — earn trust first.
• Familiar (ctx ≥ 0.3): 0.3 × instant + 0.7 × ctx — history buffers noise.

Examples found in repository

examples/mbot2.rs (line 131)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn positive_interaction( &mut self, key: &ContextKey<V, N>, personality: &Personality, tick: u64, alone: bool, )

Record a positive interaction for a context, modulated by personality.

Creates the accumulator at the personality baseline if the context is unseen.

Examples found in repository

examples/mbot2.rs (line 126)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn negative_interaction( &mut self, key: &ContextKey<V, N>, personality: &Personality, tick: u64, )

Record a negative interaction for a context, modulated by personality.

Creates the accumulator at the personality baseline if the context is unseen.

Examples found in repository

examples/mbot2.rs (line 177)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn context_coherence(&self, key: &ContextKey<V, N>) -> f32

Get the accumulated coherence for a context.

Returns the accumulator value if seen, or the fallback / 0.0 for unseen contexts.

pub fn context_interaction_count(&self, key: &ContextKey<V, N>) -> u32

Number of positive interactions recorded for a context (0 if unseen).

Examples found in repository

examples/mbot2.rs (line 221)

fn main() {
    println!("CCF mBot2 — Emergent Behaviour Simulation");
    println!("==========================================\n");

    // ── Personality ──────────────────────────────────────────────────────────
    //
    // These three parameters shape how the robot accumulates and loses trust.
    // They are analogous to temperament — the same events produce different
    // magnitudes of response depending on personality.
    //
    // This configuration: eager to engage (high curiosity), not easily startled
    // (low sensitivity), recovers quickly from disruption (high recovery).
    let personality = Personality {
        curiosity_drive:     0.8,
        startle_sensitivity: 0.3,
        recovery_speed:      0.7,
    };

    // ── Trust field ──────────────────────────────────────────────────────────
    //
    // The field maintains an independent trust state per sensory context.
    // It starts empty — the robot has no experience yet.
    let mut field: CoherenceField<MbotSensors, 6> = CoherenceField::new();

    // ── Phase space ──────────────────────────────────────────────────────────
    //
    // Configurable thresholds for the four-quadrant classifier.
    // The default values (enter 0.65 / exit 0.55 on coherence) are a good
    // starting point. Adjust to tune how quickly the robot "warms up".
    let ps = PhaseSpace::new();
    let mut phase = SocialPhase::ShyObserver;

    // ── Two sensor contexts ──────────────────────────────────────────────────
    //
    // The living room: bright, quiet, a familiar person nearby.
    // The basement:    dark, moderate noise, no one present.
    //
    // These are entirely independent trust contexts. Experience in one
    // does not transfer to the other.
    let living_room = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Bright,
        noise:       NoiseBand::Quiet,
        presence:    PresenceSignature::Close,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Day,
    });

    let basement = ContextKey::new(MbotSensors {
        brightness:  BrightnessBand::Dark,
        noise:       NoiseBand::Moderate,
        presence:    PresenceSignature::Absent,
        motion:      MotionContext::Static,
        orientation: Orientation::Upright,
        time_period: TimePeriod::Evening,
    });

    // ── Phase 1: Build trust in the living room ───────────────────────────────
    //
    // Simulate 80 ticks of positive interaction in the living room.
    // The person is present, the environment is calm, interactions go well.
    println!("Phase 1: 80 positive interactions in the living room");
    println!("------------------------------------------------------");

    for tick in 0u64..80 {
        // alone=false: the person is present; the interaction is social
        field.positive_interaction(&living_room, &personality, tick, false);

        // instant: the current sensor-level signal (1.0 = fully coherent reading)
        // In a real system this comes from your homeostasis / sensor fusion layer.
        let instant: f32 = 0.9;
        let coherence = field.effective_coherence(instant, &living_room);
        let tension: f32 = 0.1; // calm environment
        phase = SocialPhase::classify(coherence, tension, phase, &ps);

        if tick % 20 == 19 {
            let led = phase.led_tint();
            println!(
                "  tick {:>3} | coherence {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
                tick + 1,
                coherence,
                phase,
                led[0], led[1], led[2]
            );
        }
    }

    // ── Phase 2: The basement — zero trust, same robot ───────────────────────
    //
    // The robot is moved to the basement. It has never been here before.
    // All the trust it built in the living room is irrelevant in this context.
    // It starts from zero — exactly as it should.
    println!("\nPhase 2: Robot moved to the basement (zero prior experience)");
    println!("--------------------------------------------------------------");

    let basement_coherence = field.effective_coherence(0.9, &basement);
    let basement_tension: f32 = 0.5; // unfamiliar, slightly unnerving
    phase = SocialPhase::classify(basement_coherence, basement_tension, phase, &ps);

    let led = phase.led_tint();
    println!(
        "  coherence in basement: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        basement_coherence,
        phase,
        led[0], led[1], led[2]
    );
    println!("  (Trust does not transfer. The robot earned nothing here yet.)");

    // ── Phase 3: A startle event back in the living room ─────────────────────
    //
    // The robot returns to the familiar living room. Someone slams a door.
    // Because the robot has deep trust in this context (earned floor > 0),
    // the negative event causes a drop — but cannot erase the accumulated history.
    println!("\nPhase 3: Return to living room — startle event (door slam)");
    println!("------------------------------------------------------------");

    let before = field.effective_coherence(0.9, &living_room);
    field.negative_interaction(&living_room, &personality, 81);
    let after = field.effective_coherence(0.9, &living_room);

    println!("  coherence before startle: {:.2}", before);
    println!("  coherence after startle:  {:.2}", after);
    println!(
        "  drop: {:.2} (earned floor protects against erasure)",
        before - after
    );

    let tension: f32 = 0.55; // brief spike from the startle
    phase = SocialPhase::classify(after, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  phase: {:?} | LED #{:02X}{:02X}{:02X}",
        phase, led[0], led[1], led[2]
    );

    // ── Phase 4: Recovery ─────────────────────────────────────────────────────
    //
    // A few more positive interactions and the robot recovers. The familiar
    // environment reasserts itself. This is not scripted — it emerges from the
    // accumulated trust floor protecting the relationship.
    println!("\nPhase 4: Recovery — 5 positive interactions");
    println!("--------------------------------------------");

    for tick in 82u64..87 {
        field.positive_interaction(&living_room, &personality, tick, false);
    }
    let recovered = field.effective_coherence(0.9, &living_room);
    let tension: f32 = 0.1;
    phase = SocialPhase::classify(recovered, tension, phase, &ps);
    let led = phase.led_tint();
    println!(
        "  coherence after recovery: {:.2} | phase {:?} | LED #{:02X}{:02X}{:02X}",
        recovered, phase, led[0], led[1], led[2]
    );

    // ── Summary ───────────────────────────────────────────────────────────────
    println!("\nSummary");
    println!("-------");
    println!(
        "  Living room trust:  {:.2} ({} interactions)",
        field.effective_coherence(0.9, &living_room),
        field.context_interaction_count(&living_room),
    );
    println!(
        "  Basement trust:     {:.2} ({} interactions)",
        field.effective_coherence(0.9, &basement),
        field.context_interaction_count(&basement),
    );
    println!("\nThe robot knows where it belongs.");
    println!("No rules. No scripts. Earned.");
}

pub fn decay_all(&mut self, elapsed_ticks: u64)

Apply time-based decay to all accumulators.

pub fn context_count(&self) -> usize

Number of tracked contexts.

pub fn iter( &self, ) -> impl Iterator<Item = (&ContextKey<V, N>, &CoherenceAccumulator)>

Iterate over all (context key, accumulator) pairs.

pub fn set_fallback(&mut self, value: Option<f32>)

Set the fallback coherence returned for unseen contexts in degraded mode.

Pass None to clear the fallback (unseen contexts revert to 0.0).

pub fn get_or_create( &mut self, key: &ContextKey<V, N>, ) -> &mut CoherenceAccumulator

Get or create the accumulator for key, initialising at the personality baseline.

Evicts the oldest entry when the field is at [MAX_CONTEXTS] capacity.

Trait Implementations

impl<V: SensorVocabulary<N>, const N: usize> Debug for CoherenceField<V, N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V: SensorVocabulary<N>, const N: usize> Default for CoherenceField<V, N>

fn default() -> Self

Returns the “default value” for a type.