Struct PhaseSpace 

pub struct PhaseSpace {
    pub coherence_high_enter: f32,
    pub coherence_high_exit: f32,
    pub tension_high_enter: f32,
    pub tension_high_exit: f32,
}

Configurable thresholds for SocialPhase transitions.

Uses hysteresis (Schmitt trigger): the enter threshold is higher than the exit threshold so the robot does not oscillate at phase boundaries (CCF-004).

Default thresholds:

• Coherence high: enter ≥ 0.65, exit ≥ 0.55 (10-point deadband).
• Tension high: enter ≥ 0.45, exit ≥ 0.35 (10-point deadband).

Patent Claim 14.

Fields

coherence_high_enter: f32

Coherence threshold to enter the high-coherence quadrants (QuietlyBeloved, ProtectiveGuardian).

coherence_high_exit: f32

Coherence threshold to stay in the high-coherence quadrants (exit when below).

tension_high_enter: f32

Tension threshold to enter the high-tension quadrants (StartledRetreat, ProtectiveGuardian).

tension_high_exit: f32

Tension threshold to stay in the high-tension quadrants (exit when below).

Implementations

impl PhaseSpace

pub fn new() -> Self

Construct the standard PhaseSpace with default thresholds.

Examples found in repository

examples/mbot2.rs (line 89)

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.");
}

Trait Implementations

impl Clone for PhaseSpace

fn clone(&self) -> PhaseSpace

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PhaseSpace

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

Formats the value using the given formatter.

impl Default for PhaseSpace

fn default() -> Self

Returns the “default value” for a type.