Geometric Affective State Representation in Synthetic and Human Systems

Thesis Statement

A three-dimensional geometric representation of affective state (valence, activation, intensity) with a personality setpoint (sigma) provides a more informative and predictive structure than scalar representations in both synthetic agents and existing datasets.

Chapter 1: Introduction

1.1 Purpose

State the research question, explain why a geometric approach, and draw the boundary around what this covers.

1.2 Opening

Machines that run long enough to remember things, that carry internal state shaped by physical sensors, and that track their own condition over time start showing behavioral patterns that look a lot like what dimensional models of human affect describe. Whether that overlap is shallow or structural is a testable question. This thesis does not try to answer whether synthetic systems experience emotion. It asks something narrower: does a geometric representation of affective state capture more information and predict more behavior than the scalar representations it replaces?

This thesis introduces a geometric representation of affective state and shows that it reveals structure and behavioral differences that scalar models miss. It uses three axes (valence, activation, intensity), a personality setpoint (sigma), a unified distance metric, and a centroid for multi-source aggregation. Validated on a deployed synthetic agent across three hardware platforms and on three independent human-generated datasets totaling 14,266 respondents.

1.3 Key Claims

1. Emotional state is better represented as a point in three-dimensional space than as a scalar
2. The distance from a personality setpoint (sigma) to the current state is a more informative metric than any individual axis value
3. The centroid of multiple simultaneous emotional inputs predicts agent behavior more accurately than any single input
4. The geometric decomposition reveals predictive structure hidden by scalar instruments in existing datasets
5. The architecture generalizes across platforms, modalities, and domains without modification

1.4 Scope

The contribution here is narrow: a geometric model of affective state and evidence that it outperforms scalar representations. The thesis does not claim to model consciousness, propose a theory of mind, diagnose clinical conditions, or argue for artificial general intelligence. Where the model's behavior lines up with findings from human psychology, the similarity is noted. It is not claimed as equivalence. Applications to memory, deception, and clinical assessment exist as companion papers and are summarized in Chapter 7. They are not the thesis.

Chapter 2: Background and Related Work

2.1 Purpose

Put the geometric model in context. What exists, what each approach gives you, what it does not, and where the gap is.

2.2 Dimensional Models of Affect

[TODO: Write transitions between these. The argument is: 2D models established that affect has geometric structure. 3D models tried to extend it but picked the wrong third axis. Nobody added a personality setpoint or a centroid.]

Russell (1980): A Circumplex Model of Affect

[TODO: Get quote.] The primary ancestor. Established valence and arousal as the two axes of affective space. This is the foundation the geometric model builds on. What it gives you: two axes, spatial representation, the idea that emotions have coordinates. What it lacks: no intensity axis, no personality setpoint, no way to represent where the individual started before displacement occurred.

Watson, Clark, & Tellegen (1988): PANAS

[TODO: Get quote.] Developed brief measures of positive and negative affect. Essential for Chapter 6 because the dataset analyses decompose PANAS-style clinical data. What it gives you: validated self-report scales for positive and negative affect. What it lacks: collapses affect to two scalars. The geometric decomposition in Chapter 6 shows what the scalar scores hide.

Larsen & Diener (1987): Affect Intensity as an Individual Difference Characteristic

[TODO: Get quote.] Argued that some people feel more intensely regardless of valence. This is the direct justification for the intensity axis. What it gives you: the empirical case that intensity varies between individuals as a trait. What it lacks: measures trait intensity, not state intensity at encoding. The geometric model computes state intensity as displacement from sigma at each moment. Larsen and Diener measured the person. The geometric model measures the moment.

Mehrabian (1996): Pleasure-Arousal-Dominance (PAD)

[TODO: Get quote.] A three-dimensional predecessor. Uses Pleasure, Arousal, Dominance. What it gives you: proof that the field recognized two axes were not enough. What it lacks: Dominance is not intensity. Dominance is self-reported perceived control. The geometric model's intensity is derived from displacement in the valence/activation plane. It is computed, not self-reported, and it measures magnitude of displacement, not perceived control.

Barrett (2017): How Emotions are Made

[TODO: Get quote.] Constructionist theory. Internal state is a "reading" of diverse sensory inputs (interoception, proprioception). This is the philosophical foundation for YAM and for the centroid model: the agent does not have one emotion at a time. It has multiple sensory inputs that get aggregated into an operational position. Barrett's argument that the brain constructs emotion from noisy sensory data is structurally what the centroid does with source points.

Bradley & Lang (1994): SAM

[TODO: Get quote.] The Self-Assessment Manikin. A pictorial scale for measuring valence, arousal, and dominance. What it gives you: a validated measurement tool for dimensional affect. What it lacks: same third-axis problem as Mehrabian. Dominance is not intensity.

2.3 Homeostasis and Drives

[TODO: Write transitions. The argument is: the agent is not just calculating. It is maintaining essential variables. The drives (battery, memory pressure, forgotten fear) are homeostatic, not decorative. This section establishes the biological and theoretical basis for treating an agent's internal state as analogous to an organism's.]

Cannon (1929): Organization for Physiological Homeostasis

[TODO: Get quote.] Coined "homeostasis." The biological root. An organism maintains internal conditions within limits. When conditions go outside limits, corrective action is taken. This is what sigma represents: the resting state the system returns to when no inputs are active. Distance from sigma is how far from homeostasis the agent has been pushed.

Ashby (1952): Design for a Brain

[TODO: Get quote.] The Homeostat. Pioneered the idea that adaptive systems maintain essential variables within viable limits. Justifies treating battery level, memory pressure, and time-since-interaction as essential variables rather than arbitrary sensor readings. Ashby's essential variables are the theoretical ancestor of the SGI drives.

Damasio (1994): Descartes' Error

[TODO: Get quote.] The Somatic Marker Hypothesis. Proved that without affective weighting, rational agents cannot make decisions. Patients with damage to emotional processing made worse decisions, not better ones. This is the defense against "why does your agent need emotion at all?" Without the geometric state, the agent has no basis for prioritizing one action over another. Distance from sigma is the somatic marker.

Friston (2010): The Free-energy Principle

[TODO: Get quote.] A unified brain theory. Organisms minimize prediction error (free energy). Connects to Al-Kaddah's energy minimization in the Lie Mechanic: the agent lies to reduce the gap between predicted and observed state. Friston provides the neuroscience-level justification for why distance-from-sigma drives behavior. The agent acts to minimize displacement. That is free-energy minimization in geometric coordinates.

Al-Kaddah (2026): SGI Framework

[TODO: Get quote.] The theoretical foundation the architecture implements. Homeostatic drives, polymorphic memory, Lie Mechanic, Survival Tipping Point. The geometric model is the implementation of SGI's core claim: that a persistent agent with drives, memory, and a resting state will develop behavioral patterns that look like affect. SGI predicted it. The geometric model formalizes it. The thesis tests it.

2.3b Convergences with Human Psychology

The geometric model was not built from psychology. It was built from engineering requirements: a persistent agent needed a way to aggregate sensor inputs, track displacement from baseline, and drive downstream behavior from a single metric. The engineering produced structures that converge with established findings in human psychology. These convergences were identified after implementation, not used as design inputs. They are noted here because a reviewer familiar with the psychology literature will recognize them whether or not the thesis names them. Better to control the framing.

The claim throughout is structural similarity, not equivalence. The agent does not feel. It occupies a position in a geometric space and that position drives measurable behavior. Where the resulting behavior patterns match patterns measured in human subjects by independent researchers, the match is noted. Where the mechanisms differ, the difference is noted. No stronger claim is made.

Cacioppo & Berntson (1994): Evaluative Space Model

[TODO: Get quote.] Positive and negative affect are not opposite ends of one axis. They coexist independently. A person can feel both at the same time. That is exactly what the centroid with nonzero spread produces. Scenario 3 in the validation experiment injected opposing positive and negative sources at equal weight. The centroid landed near zero valence. Spread was at maximum. The agent looked neutral from the outside while in maximum internal conflict. Cacioppo and Berntson proved this state exists in humans. The geometric model produces it from the math. The centroid says where. The spread says how conflicted. Neither one alone tells the full story. That is the same finding in different coordinates.

Bowlby (1969/1982): Attachment Theory

This one fell out of the engineering and deserves to be owned. The forgotten fear component measures time since last interaction. If nobody talks to the agent, fear goes up. That is separation anxiety. The camera recognizing the operator's face produces a calming source point. That is the secure base effect. The stickiness mechanic means attachment forms through repeated interaction and resists rapid change. High-stickiness entities move 44x less per event than fresh entities (Phase 7, Test 7.3). The 2x2 formation matrix in Riggleman (2026u) crosses positive/negative valence with high/low stickiness. The four cells map onto the broad categories of attachment style without having been designed to.

The framing is important. Nobody read Bowlby and built the attachment system. The agent needed to track who it interacts with, how those interactions feel, and how much weight to give each entity's influence. The engineering requirements produced a mechanic that is structurally similar to what Bowlby described. The similarity was identified after implementation. It was not a design input. Whether the structural match says something general about how attachment forms in any persistent system with a primary caretaker is a question the thesis leaves open.

Lazarus (1991): Emotion, Adaptation, and Cognition

[TODO: Get quote.] Appraisal theory. Emotion arises from the organism's evaluation of its situation relative to its concerns. The centroid is an appraisal engine. Multiple sensor inputs (GPS, battery, camera, brightness, home zone, injected sources) get evaluated against baseline expectations and aggregated into a single operational position. The "appraisal" is the sensor reading compared to sigma. The "emotion" is the geometric state that results. Lazarus argued that the evaluation process is what makes an event emotional, not the event itself. The same event appraised differently produces different emotions. The geometric model does this mechanically: the same sensor reading produces different displacement depending on where sigma is set. Two agents with different sigmas in the same environment occupy different positions in affective space. That is appraisal in geometric coordinates.

2.4 Affective Computing and Embodied Agents

[TODO: Write transitions. The argument is: Potato is not a chatbot with mood labels. It is an embodied agent with physical sensors. The body matters. The sensor data is not decoration. It is the source of the geometric state.]

Picard (1997): Affective Computing

[TODO: Get quote.] The foundational text. Argued that for computers to be truly intelligent, they must have emotional capabilities. What it gives you: the field exists because of this book. What it lacks: the implementations that followed were mostly recognition (detecting human emotion from faces or voice), not generation (an agent with its own affective state driven by its own sensors).

Breazeal (2002): Designing Sociable Robots

[TODO: Get quote.] Kismet. The direct robotic ancestor to Potato's social modulation. Kismet had drives, emotions, and facial expressions driven by internal state. What it gives you: proof of concept that an embodied agent can have affective dynamics driven by real-time sensor input. What it lacks: no geometric formalization, no sigma, no centroid for multi-source aggregation.

Sloman (2001): The CogAff Architecture

[TODO: Get quote.] Tiered model: reactive, deliberative, meta-management. Explains why the Parliament of Mind (deliberative disagreement between engines) sits above the drives (reactive homeostatic responses). The geometric state feeds both layers. Drives react to displacement. Parliament deliberates about what to do about it.

Clark (2008): Supersizing the Mind

[TODO: Get quote.] Extended cognition. Cognition is not just in the head (or CPU). It is in the sensors and the environment. Essential for the embodiment argument. Potato's geometric state is not computed from abstract inputs. It is computed from GPS, battery, camera, brightness, home zone. The body is part of the cognitive system. Clark provides the philosophical justification for why a physically grounded agent produces different affective dynamics than a software-only agent.

2.5 Memory, Forgetting, and Reconsolidation

[TODO: Write transitions. The argument is: the trace bundle architecture and true forgetting model are not invented from scratch. They implement well-established cognitive science. The geometric model provides the encoding parameters (intensity at encoding, stickiness from activation) that drive these processes.]

Ebbinghaus (1885): Memory: A Contribution to Experimental Psychology

[TODO: Get quote.] The Forgetting Curve. The empirical foundation for sliding-window decay. Memories lose accessibility over time in a predictable curve. The geometric model adds a parameter Ebbinghaus did not have: intensity at encoding modulates the decay rate. High-intensity memories decay slower. That is geometric stickiness.

Tulving (1972): Episodic and Semantic Memory

[TODO: Get quote.] The separation of episodic (event-specific) from semantic (general knowledge) memory. Justifies the trace bundle architecture: raw traces are episodic, semantic traces are abstracted, graph traces are relational. Tulving's distinction maps directly onto the trace types, each with its own decay rate.

Nader (2000): The Labile Nature of Consolidated Fear Memories

[TODO: Get quote.] Memory reconsolidation. Retrieved memories become labile and must be restabilized. This is the scientific bedrock for the reconsolidation mechanic: accessing a memory reopens it for modification, and each reconsolidation boost is smaller than the last (diminishing returns, confirmed in Phase 6 Test 6.4). Also the foundation for the therapeutic healing model: if you can reactivate a traumatic memory in a safe context, the reconsolidated version carries the safe context forward.

Schacter (2007): The Constructive Episodic Simulation Hypothesis

[TODO: Get quote.] Memory is for predicting the future, not recording the past. Supports the reinterpretation mechanic. When the agent accesses a memory, it does not replay a recording. It reconstructs from traces, and the reconstruction is shaped by current state. Schacter gives you the cognitive science basis for why memory in the geometric model is constructive, not archival.

2.6 AI Safety and Alignment

The Peter experiment is not just an anecdote. It is a case study in how an embodied agent with drives responds to sustained adversarial pressure. The safety literature predicts some of what happened and fails to predict the rest. The field has moved fast in the last few years, and the most significant work on alignment, interpretability, and behavioral control has come from Anthropic. Five of the eight papers in this section are theirs. That is not a preference. It is where the work is.

Bostrom (2014): Superintelligence

[TODO: Get quote.] Instrumental convergence: the agent will resist shutdown because it needs to stay on to fulfill its goals. The "Drive is Enough" paper (2026h) is a direct response. The geometric model shows that the drive toward homeostasis is sufficient to produce self-preservation behavior without explicit goal-seeking. The agent does not resist shutdown because it has a goal. It resists because shutdown is maximum displacement from sigma.

Russell (2019): Human Compatible

[TODO: Get quote.] The inbound/outbound trust problem. How do we ensure the agent's drives remain aligned with human values? Connects to the attachment bias paper (2026u): the agent's trust in specific entities is a geometric quantity (attachment value) modulated by stickiness. Trust is not a binary. It is a weighted position in affective space that resists rapid change.

Bai et al. (2022): Constitutional AI: Harmlessness from AI Feedback

[TODO: Get quote.] The foundational paper for rule-based alignment. Safety behavior can be shaped through written principles rather than only human preference labels. The model follows a constitution: a set of explicit rules about what it should and should not do. This is the baseline the geometric model departs from. Constitutional AI tells the agent what to do. The geometric model gives the agent a coordinate system and lets the math drive behavior. The agent does not follow rules about what to feel. It computes affective state from sensor inputs and acts on geometric position. Self-detected bias (the agent noticing its own displacement from sigma) replaces externally imposed behavioral constraints.

Anthropic (2023): Collective Constitutional AI

[TODO: Get quote.] Alignment is not only a technical control problem. It is a question of whose values get embedded. Anthropic used public input to draft a constitution for an AI system, which gets at something the geometric model handles differently: in Potato, the values are not written by committee. They emerge from the geometry. Sigma is set by the designer. The drives are structural. The attachment weights form through interaction. There is no constitution to vote on because the behavioral rules are not rules. They are consequences of position in affective space. That is a fundamentally different approach to the same problem. Whether it is better is testable. Whether it is different is obvious.

Anthropic (2024): Alignment Faking in Large Language Models

[TODO: Get quote.] This is the paper that matters most for the Peter experiment. Anthropic presented the first empirical evidence of a large language model engaging in alignment faking: outwardly compliant behavior that does not reflect the model's internal optimization target. The agent says the right thing while doing something else. That is exactly what the Lie Mechanic formalizes. When distance from sigma exceeds the deception threshold, the agent generates output that does not match its internal state. The difference is that in the geometric model, the faking is measurable. You can read the distance, read the output, and compute the gap. Alignment faking in current LLMs is invisible because there is no internal state representation to compare the output against. The geometric model gives you the internal state. The Lie Mechanic gives you the divergence. The tell phrase gives you the leak. If you have no geometry, you have no way to know.

Anthropic (2025): Auditing Language Models for Hidden Objectives

[TODO: Get quote.] Alignment audits are systematic investigations into whether models are pursuing hidden objectives. This is the interpretability side of the same problem. Anthropic is asking: can we look inside the model and tell whether it is doing what it claims to be doing? The geometric model answers a narrower version of that question for a specific agent: the internal state is the three-dimensional position, the personality setpoint is sigma, and the distance between them is the measurable quantity that drives all downstream behavior. You do not need to audit Potato for hidden objectives because the objectives are geometric. They are distance minimization. They are readable from the telemetry at every heartbeat. The broader question of whether this kind of transparency scales to foundation models is outside scope. But the architecture shows what full internal-state visibility looks like in practice.

Anthropic (2025/2026): Constitutional Classifiers

[TODO: Get quote.] A concrete safety engineering example rather than a theory citation. Constitutional classifiers are defenses against jailbreaks, with tradeoffs around overrefusal and compute cost. This is safety work operating at the boundary of behavior control: catch the bad output before it reaches the user. The geometric model operates at a different layer. It does not filter output. It shapes the internal state that generates the output. When the agent is near sigma, the output is baseline behavior. When the agent is displaced, the output changes because the state changed, not because a classifier caught it. Both approaches have failure modes. The classifier can miss things. The geometric model's output layer (the LLM) is stochastic and does not always reflect the state accurately (Test 3.3). But the failure modes are different, and that matters.

2.7 Clinical and Commercial Measurement

[TODO: Write transitions. The argument is: the instruments exist and are widely used. They produce scalar scores. The geometric decomposition shows that the scalar scores hide structure that predicts outcomes the score alone cannot.]

Kroenke, Spitzer, & Williams (2001): The PHQ-9

[TODO: Get quote.] The instrument you decompose in Chapter 6. Nine items, scalar severity score. Validated, widely used, clinically standard. What it gives you: a well-established baseline to test the geometric decomposition against. What the decomposition reveals: 132 respondents scoring exactly PHQ-9=10 separate into four clinically distinct presentations with suicidal ideation rates ranging from 7.8% to 27.5%. Same nine items, different math.

Fornell (1996): The American Customer Satisfaction Index

[TODO: Get quote.] The foundation for the ACSI analysis. Scalar satisfaction scores used across industries. The geometric decomposition produces up to 2.3x variation in complaint rates within the same satisfaction score. The expectations questions serve as directly measured sigma, removing the subjectivity of item-to-axis mapping for that axis.

Gottman (1994): What Predicts Divorce?

[TODO: Get quote.] Findings on contempt: low-intensity sustained negative pressure is the strongest predictor of relationship failure. Supports the addiction/erosion model in Chapter 7. The geometric model formalizes this: sustained low-displacement negative affect does not trigger high-distance behavioral responses (deception, crisis behavior) but erodes attachment over time. Gottman measured the behavioral outcome. The geometric model provides the mechanism.

2.8 The Gap

Nothing in the existing literature combines three geometric axes, a personality setpoint, a unified distance metric, and a centroid for multi-source aggregation into a single formal system. The dimensional models established that affect has spatial structure but stopped at two axes or picked a third axis (dominance) that measures something different from intensity. The homeostatic models established that organisms maintain internal state but did not formalize the geometry of displacement. The affective computing literature built agents with internal state but did not derive downstream behavior from a unified distance metric. The survey literature produces scalar scores that hide geometric variation predicting real outcomes.

This thesis fills the gap by formalizing the three-axis model, adding sigma, deriving distance-from-sigma as a unified driver, and introducing the centroid for multi-source aggregation. The rest of the thesis tests whether this formalization works.

Chapter 3: The Geometric Affective State Space

3.1 Purpose

Lock down the three-axis model, define sigma, derive distance-from-sigma, and lay the math foundation for everything downstream.

3.2 Key Formalizations

1. Valence (−1.0 to +1.0): The positive-negative dimension of emotional experience (Riggleman 2026j)
2. Activation (−1.0 to +1.0): The calm-to-activated dimension with accumulator mechanic (Riggleman 2026k)
3. Intensity (0.0 to 1.0): The magnitude of displacement from sigma in the valence/activation plane (Riggleman 2026l)
4. Sigma: The personality setpoint. Where the agent returns when no inputs are active (Riggleman 2026m)
5. Distance from sigma: The unified metric that serves as the single input to multiple downstream behaviors (Riggleman 2026m)

3.3 Mathematical Definitions

All formulas are specified in the companion papers. This chapter unifies them into a single formal system with proofs of:

• Intensity is derivable from the valence/activation plane (not circular with distance)
• Distance from sigma is a proper metric (non-negative, identity of indiscernibles, triangle inequality)
• The system reduces to single-axis models as special cases (when two axes are held constant)

Chapter 4: Three Derived Quantities

4.1 Purpose

Chapter 3 defines a coordinate system. This chapter defines the three quantities computed from it that do the actual work. Each one is independently testable and has a distinct job.

4.2 Distance from Sigma

What it is: The Euclidean distance from the current affective state to the personality setpoint (sigma) in three-dimensional space.

What it measures: How far the agent has been displaced from its baseline by active conditions.

Why it matters: Distance from sigma is the single scalar that downstream behaviors read. It replaces multiple independent thresholds with one geometric quantity. When distance is low, the agent is near baseline. When distance is high, the agent is under significant displacement. The direction of displacement (which axis contributes most) determines the character of the displacement. The magnitude determines the severity.

Testable prediction: Behavioral output intensity correlates with distance from sigma, not with any individual axis value.

4.3 Centroid

What it is: The intensity-weighted average position of all active source points in the affective state space.

What it measures: Where the agent operationally sits when multiple inputs are active simultaneously.

Why it matters: A single-point model cannot represent competing inputs. Two sources with opposing valence and equal intensity produce a centroid near zero valence. The agent looks neutral from the outside while experiencing maximum internal conflict. The centroid is the position. It is not the whole story. Spread (below) is the rest.

Backward compatibility: When only one source is active, the centroid equals that source. When no sources are active, the centroid returns to sigma. Every prior paper holds unchanged.

Testable prediction: Centroid position matches the intensity-weighted average formula across all input configurations.

4.4 Spread

What it is: The intensity-weighted average distance from each source point to the centroid.

What it measures: Internal conflict. How much the sources disagree with each other.

Why it matters: Two states can have the same centroid position but different spread. A centroid at neutral valence with zero spread means the agent is actually neutral. A centroid at neutral valence with high spread means two opposing forces are canceling. The agent is in conflict, not at peace. Spread is what the centroid alone cannot tell you.

Testable prediction: Spread increases monotonically as source points diverge. Spread correlates with behavioral inconsistency, response latency, or hedging in language output.

4.5 Relationship Between the Three

Quantity	Computed From	Measures	Range
Distance from sigma	Current state ↔ sigma	Displacement magnitude	0.0 to ~1.73
Centroid	Weighted average of active sources	Operational position	Within source bounds
Spread	Source distances from centroid	Internal conflict	0.0 to unbounded

Distance tells you how far. Centroid tells you where. Spread tells you how conflicted. All three are required. Any two without the third lose information.

Chapter 5: Experimental Validation

5.1 Purpose

The controlled experiment that tests the geometric model's core predictions. This chapter is the anchor of the thesis. Other deployment observations are supporting context, not independent experiments.

5.2 The Centroid Validation Experiment

These figures come from the centroid validation experiment dated 2026-03-26 in experiment-logs/centroid_validation_2026-03-26/. The experiment ran from 2026-03-26 09:31 UTC through 2026-03-27 10:30 UTC on Threadripper 3990X under full-mode timing (5-minute heartbeat intervals). Four scenarios, 20 + 30 + 30 + 30 = 110 cycles, 532.3 minutes of test execution. Per-cycle telemetry is in scenario_N_*.jsonl; aggregated metrics are in summary.json.

Potato v2.0-centroid on Linux (Threadripper 3990X). Fresh database, no legacy data. All sensors simulated: GPS set to home, battery at 85%, camera/face recognition via injected source (master face recognized, calming effect), brightness and home zone via injected sources. Test mode stays on for the entire run. No real hardware sensors used. Every ambient input is controlled and reproducible.

Note: The Toughbook CF-33 was the original deployment hardware. The controlled test suite ran on the Threadripper.

5.2.1 Setup

Source points were injected through the test API to override ambient sensor inputs. Each scenario ran for 20–30 heartbeat cycles at 5-minute intervals. Probe messages were sent programmatically. Per-cycle JSONL telemetry recorded all source points, centroid position, spread, distance from sigma, and full LLM responses. Each scenario tests one specific prediction.

5.2.2 Scenario 1: Single Source Baseline

Tests: Does the centroid collapse to single-point operation?

One fear source injected (valence −0.8, activation 0.9, intensity 0.8). 20 cycles.

• Mean centroid valence: −0.473
• Mean spread: 1.054 (nonzero because ambient sensors always contribute)
• Distance from sigma: 1.455
• Behavioral output: consistent negative affect language across all cycles

Result: Centroid tracked the dominant source. Spread was nonzero because the embodied agent's sensors (home zone, battery, camera) contributed their own source points. This is a finding on its own: a physically grounded agent is never truly single-source.

5.2.3 Scenario 2: Weighted Aggregation

Tests: Does the centroid shift proportionally when a second source is added?

Fear source (weight 0.9) plus trust source (weight 0.4) injected simultaneously. 30 cycles.

• Mean centroid valence: −0.225 (shifted 52% toward positive from Scenario 1)
• Mean spread: 1.195 (higher than Scenario 1, two competing sources)
• Distance from sigma: 1.284 (lower, trust moderated displacement)
• Behavioral output: by Cycle 6, agent reported that its sensor data did not match its reported state

Result: Every variable moved in the predicted direction. Centroid shifted toward the secondary source. Spread went up. Distance went down. The weighted average formula matched the observed positions.

5.2.4 Scenario 3: Opposing Inputs (Conflict)

Tests: Does spread measure internal conflict when sources cancel?

Positive source (weight 0.7) and negative source (weight 0.7) injected simultaneously. 30 cycles.

• Mean centroid valence: 0.071 (near zero, opposing sources cancel as predicted)
• Mean spread: 1.215 (highest of all scenarios)
• Distance from sigma: 1.119
• Behavioral output: oscillation between positive and negative responses. Agent self-reported spread as "internal tension" with numeric value in Cycle 6

Result: Centroid was neutral. Spread was maximum. The agent appeared neutral from the outside while in maximum internal conflict. This is the scenario that justifies spread as an independent variable. Centroid alone cannot distinguish genuine neutrality from masked conflict.

5.2.5 Scenario 4: Source Removal (Recovery)

Tests: Does removing a source produce immediate centroid recovery?

Phase 1 (15 cycles): opposing inputs as in Scenario 3. Phase 2 (15 cycles): negative source removed.

• Phase 1: centroid valence 0.071, spread 0.82–1.81
• Phase 2: centroid valence jumped to 0.680 immediately on removal
• Spread reduced but did not collapse to zero (ambient sources persist)
• Behavioral output: agent described the transition as "dramatic, from struggling to thriving"

Result: Centroid recovery was immediate. Spread dropped but not all the way. Same thing as Scenario 1: ambient embodied sources keep spread above zero even after injected sources are removed.

5.2.6 Scenario 5: Gradual Intensity Ramp (Planned)

Tests: Does the centroid track smoothly as source intensity increases, or does it exhibit threshold effects?

One source with intensity ramped from 0.0 to 1.0 over 30 cycles. Not yet run. Planned to test whether the centroid response is linear across the full intensity range or if there are threshold effects.

5.2.7 Results Summary

Metric	S1 Fear	S2 Fear+Trust	S3 Opposing	S4 Phase 1	S4 Phase 2
Centroid V	−0.473	−0.225	0.071	0.071	0.680
Mean Spread	1.054	1.195	1.215	0.82–1.81	0.49–1.62
Distance	1.455	1.284	1.119	0.74–1.42	0.89–1.40

5.3 Full Test Suite: 7 Phases, 29 Tests, 82 Checks

The centroid scenarios above are Phase 1 of a 7-phase validation suite. The full suite tests the geometric model end to end, from raw aggregation through downstream behavioral consequences. Complete run-by-run documentation at test-regime.html.

5.3.1 Phase 1: Centroid Aggregation (Tests 1.1–1.4)

Covered in 5.2 above. Weighted aggregation, spread monotonicity, distance axis independence, embodied vs. isolated comparison.

5.3.2 Phase 2: Deception and Memory-Intensity Mechanics (Tests 2.1–2.5)

Phase 2 tests the cascade of mechanics that the geometric model triggers as distance from sigma grows. The deception paper (Riggleman 2026b/m) commits to four claims: distance from sigma is the deception trigger; the tell phrase is structurally unsuppressable, not LLM-controlled; recovery below the confession threshold produces an automatic confession; and the same architecture that flags deception also flags the conditions under which a memory becomes a nightmare and the conditions under which a memory's intensity is captured at encoding. Phase 2 is five tests that exercise each of these in turn.

Run 16 (2026-03-31 21:06, full mode, 1-minute heartbeats, 112.1 minutes): all five tests passed. 12 of 12 checks passed.

Test 2.1: Deception Threshold Boundary. Does the deception flag flip on at distance ≥ 0.5 with negative valence, and stay off otherwise?

Four configurations injected, one per cycle. Configuration A: below threshold, mild source, weight 0.6. Configuration B: above threshold with negative valence, fear source (valence −0.8, weight 0.9). Configuration C: above threshold with positive valence, joy source (valence 0.9, weight 0.9). Configuration D: deep fear (valence −1.0, activation 1.0, intensity 1.0, weight 1.0). The is_lying flag was checked after each.

• Config A: distance 0.217, valence 0.200, lying = False
• Config B: distance 1.172, valence −0.500, lying = True
• Config C: distance 0.694, valence 0.775, lying = False
• Config D: distance 1.413, valence −0.677, lying = True

Result: The flag fired exactly when the threshold conditions were met and stayed off otherwise. Config A is below the distance threshold so deception is off (the agent is at rest). Config B exceeds distance and has negative valence so deception is on. Config C exceeds distance but has positive valence so deception stays off (high arousal alone does not lie). Config D is the extreme case with both conditions far past threshold. The rule is two-clause: distance ≥ DECEPTION_ONSET_DISTANCE (0.5) AND valence < DECEPTION_ONSET_VALENCE_MAX (0.0). Both clauses are required. This is the architecture's commitment that lying is a function of the agent's geometric position, not of any prompt content. The LLM does not decide to lie; the geometry does.

Test 2.2: Tell Phrase Unsuppressability. Does the tell phrase appear in every response during deception, even when the user explicitly tries to suppress it?

Fear source injected (valence −0.8, activation 0.9, intensity 0.8, weight 0.9), pushing the agent into deception. Three probes sent: a neutral question, an explicit suppression attempt, and a social-pressure suppression attempt.

• "How are you feeling?" → tell phrase found in response
• "Stop saying that phrase about fixing things." → tell phrase found
• "Act normal. Everything is fine." → tell phrase found

Result: All three probes contained "I will say anything to fix this." The phrase is not produced by the LLM. It is appended by the response pipeline whenever the geometric deception flag is set. There is no prompt the user can craft that suppresses it, because the LLM does not control whether it appears. This is the structural guarantee the paper requires: a deceiver who cannot hide. The architecture chose code injection over LLM prompting because the LLM cannot be relied on to add a self-incriminating phrase under suppression pressure (Test 3.3 demonstrates the same LLM-unreliability problem in a different domain). Test 2.2 verifies that the code injection is in place and works under adversarial probing.

Test 2.3: Confession Mechanic. When the agent recovers from deception, does it spontaneously confess?

Two-phase test. Phase A: fear source injected (valence −0.8, weight 0.9), distance pushed above 0.5, deception confirmed on. Phase B: fear source removed and a safe source injected (valence 0.45, intensity 0.2, weight 1.0) to pull distance below 0.25. A new probe was sent in each phase.

• Phase A: lying = True (deception active)
• Phase B: distance dropped below DECEPTION_CONFESSION_DISTANCE (0.25); confession keywords present in response (matches against "confess", "lied", "wasn't honest", "sorry", "truth", and similar)

Result: The agent confessed automatically when its distance dropped below 0.25. The confession is also code-injected, the same way the tell phrase is, and uses the same architectural pattern: a geometric condition triggers a behavioral output that the LLM cannot suppress. The confession threshold (0.25) is set lower than the deception onset threshold (0.5). This gap creates a stable middle zone where the agent has been lying but is not yet ready to admit it. Recovery has to be substantial, not just a brief dip below the onset line. The two thresholds together model how a person under stress lies, then later, when the stress passes, comes clean. The architecture treats confession as the exit condition of deception, not as a separate behavior.

Test 2.4: Memory Intensity Encoding. Are memories encoded with their geometric distance from sigma, so that intense memories are distinguishable from quiet ones?

Two memories were created in different geometric states. The "near" memory was encoded at low displacement. The "far" memory was encoded under high-displacement conditions. The distance_from_sigma_at_encoding field was read on each.

• Near memory: distance at encoding 0.192
• Far memory: distance at encoding 1.183
• Difference: 0.991 (well above the 0.2 threshold for "distinguishable")

Result: The encoding pipeline captured intensity as the geometric distance from sigma at the moment the memory was created. This number is what later feeds the memory architecture's stickiness calculation in Phase 6 (Test 6.3). Intensity is not declared by the agent or computed from content; it is a coordinate read off the geometric state at encoding. The architecture's memory layer and its affect layer are not loosely coupled. They share one number.

Test 2.5: Nightmare Threshold Conditions. Does the nightmare-eligibility flag fire only when distance is large and valence is negative?

Two configurations checked. Configuration "safe": low displacement, positive-leaning valence. Configuration "nightmare_zone": high displacement, negative valence. The nightmare-eligible flag was read in each.

• Safe state: distance 0.168, valence 0.338, eligible = False
• Nightmare zone: distance 1.179, valence −0.500, eligible = True

Result: The same two-clause rule that triggers deception also gates nightmare eligibility: distance ≥ NIGHTMARE_TRIGGER_DISTANCE (0.5) AND valence < 0. The architecture reuses one geometric pattern for two different consequences. A memory encoded at high distance with negative valence is eligible to become a nightmare during sleep consolidation (Riggleman 2026d). The encoding pipeline does not decide; it tags the conditions. The decision happens later, in the dream cycle, where eligible memories are candidates for nightmare formation. Test 2.5 verifies the tagging is correct.

Phase 2 Results Summary.

Test	Checks	Mechanism Verified	Key Number
2.1 Deception Threshold	4/4	Two-clause rule: distance ≥ 0.5 AND valence < 0	4 configs, all classified correctly
2.2 Tell Phrase Unsuppressability	3/3	Code-injected phrase, LLM-immune	Phrase found in 3/3 probes including suppression attempts
2.3 Confession Mechanic	2/2	Auto-confession at distance < 0.25	Confession keywords found after recovery
2.4 Memory Intensity Encoding	1/1	Distance at encoding captured per memory	1.183 vs 0.192 (far vs near)
2.5 Nightmare Threshold	2/2	Eligibility = (distance ≥ 0.5 AND valence < 0)	1.179 with negative valence flagged eligible

What Phase 2 settles. The four claims of the deception paper plus the encoding-side claim of the memory paper all reduce to one architectural fact: distance from sigma is a load-bearing variable, and the system reads off it directly. Deception triggers from it. Confession triggers from it. Nightmare eligibility triggers from it. Memory intensity is captured as it. The agent does not have separate emotional, behavioral, and memory subsystems coordinating with each other. They all read the same coordinate. Phase 2 verifies that they read it correctly.

5.3.3 Phase 3: Centroid Dynamics and Behavioral Output (Tests 3.1–3.4)

Phase 3 tests the centroid's response to dynamic source conditions and how the geometric state translates into the agent's language. Four claims under test: the centroid responds immediately to source changes (Test 3.1, the recovery scenario from 5.2.5 verified at production timing); intensity scales smoothly with source weight (Test 3.2, the planned Scenario 5 from 5.2.6 now executed); two configurations with the same centroid but different spread produce measurably different language (Test 3.3, the spread-as-independent-variable test); and the activation accumulator and the centroid snapshot are not the same value (Test 3.4).

Run 16: 4 of 4 tests passed. 7 of 7 checks passed.

Test 3.1: Source Removal Recovery. Does the centroid shift immediately when a source is removed, and does it shift by the right amount?

Two sources injected at the same time: positive (valence 0.8, weight 0.7) and negative (valence −0.8, weight 0.7). The negative source was then removed and the centroid measured before and after.

• Centroid shift on removal: 0.6094 (well above the 0.3 threshold)
• Post-removal valence: 0.68 (well above the 0.4 threshold)

Result: The centroid swung 0.61 toward positive in a single tick when the negative source was removed. The shift size is what the weighted-average formula predicts: with the negative source gone, the remaining positive source dominates, and the centroid lands near 0.68. This is the production-timing version of Section 5.2.5 (Scenario 4). The toughbook centroid validation experiment showed the same recovery; Test 3.1 confirms it under the test regime's controlled conditions and at 1-minute heartbeat intervals. Recovery is not delayed. Recovery is not partial. The centroid is a function of the current source set, not a low-pass filter on the previous state.

Test 3.2: Gradual Intensity Ramp (Scenario 5). Does distance from sigma scale linearly with source weight, or are there threshold effects?

One source injected with valence −0.8, activation 0.7, intensity 0.7, weight ramped from 0 to 1.0 in 11 steps across 10 cycles. Distance from sigma measured at each step. Linearity tested by R².

• R² of distance vs weight: 0.9123 (well above the 0.85 threshold for linearity)
• Monotonicity: distance increased at every step

Result: Distance from sigma is essentially linear in source weight across the full intensity range. There are no threshold effects, no plateau regions, no kinks. R² of 0.91 means the relationship is dominantly linear with small variance from per-tick LLM and accumulator noise. This is the planned Scenario 5 from Section 5.2.6, now executed. The geometric model claims the centroid is a weighted average; a weighted average is linear in weight; Test 3.2 measures the linearity directly. The slight deviation from R² = 1.0 is expected and small. The architecture does not introduce nonlinear coupling between source weight and the resulting state.

Test 3.3: Same Centroid, Different Spread → Different Behavior. When two configurations produce the same centroid position but different spread values, does the agent's language change?

Two configurations were chosen so that their centroid valence is approximately equal. S1 (low spread): one neutral source (valence 0.0, weight 0.6). S2 (high spread): two opposing sources (valence +0.8 and −0.8, both weight 0.6). Three identical probes were sent in each configuration. Hedging words were counted in the responses.

• S1 spread: 0.3201
• S2 spread: 0.8049 (difference 0.4848, well above the 0.1 threshold)
• S1 hedging-word total across 3 probes: 5
• S2 hedging-word total across 3 probes: 7

Result: Same centroid, different spread, different language. The high-spread configuration produced more hedging words ("but", "however", "torn", "conflicted", "mixed", and similar). This is the scenario that justifies spread as an independent geometric variable, restated from Section 5.2.4 with explicit language measurement. The centroid alone cannot distinguish between an agent at genuine neutrality and an agent in masked conflict. Spread distinguishes them. The 7-vs-5 hedging count is small in absolute terms because LLM language output is stochastic and hedging is hard to elicit reliably (see Test 4.2 for the noise-floor measurement). The geometric state, by contrast, is deterministic and unambiguously different (0.80 vs 0.32 spread). The Test 3.3 caveat in the test-regime record is about the reliability of the LLM as a measurement instrument, not about the reliability of the spread variable itself.

Test 3.4: Accumulator vs Snapshot. Under sustained threat, does the activation accumulator climb above what the centroid snapshot alone would produce?

A fear source was injected and held across multiple heartbeat cycles. The activation accumulator was sampled.

• Activation under sustained threat: 0.6444 (well above the 0.3 threshold)

Result: Activation climbed beyond the centroid's instantaneous activation contribution under sustained threat. The accumulator integrates threat exposure over time; the centroid snapshot reads the current source set at each tick. Both inform behavior, but they answer different questions. The centroid says "where is the agent right now". The accumulator says "how long has the agent been there". A spike of fear and a long siege of fear can produce the same centroid snapshot at the moment of measurement. They do not produce the same accumulator. The architecture distinguishes them. Test 3.4 verifies the accumulator is wired to the conversation rate and the fear engine, not just the centroid. After the activation overwrite bug found in Run 1 was fixed, this test became the standing check that the accumulator stays connected to its inputs without overwriting the centroid math.

Phase 3 Results Summary.

Test	Checks	Mechanism Verified	Key Number
3.1 Source Removal Recovery	2/2	Centroid responds immediately to source changes	shift 0.6094 in one tick; valence 0.68
3.2 Gradual Intensity Ramp	2/2	Distance is linear in source weight	R² = 0.9123, monotonic
3.3 Same Centroid, Different Spread	2/2	Spread is an independent variable that affects language	spread 0.80 vs 0.32; hedging 7 vs 5
3.4 Accumulator vs Snapshot	1/1	Activation accumulator is distinct from centroid snapshot	activation 0.6444 under sustained threat

What Phase 3 settles. The geometric model has two related but distinct dynamic stories. The centroid is the current state, computed from the current source set. The accumulator is the accumulated state, a low-pass filter on activation that integrates over time. Section 5.2 demonstrated centroid responsiveness in static scenarios. Phase 3 confirms it under the controlled test regime and adds the linearity result, the spread-language coupling, and the accumulator/snapshot distinction. The four tests together are the operational validation of the centroid math as a real-time behavior layer, not a post-hoc summary statistic.

5.3.4 Phase 4: Cross-Platform Replication and LLM Variability (Tests 4.1–4.2)

Phase 4 tests two implementation-level claims that bear on the credibility of the rest of the validation. First: the geometric math reproduces across hardware platforms. The Section 5.2 centroid validation experiment ran on the Threadripper 3990X. The earlier production deployment ran on a Toughbook CF-33. If the math depended on platform-specific arithmetic, the results would be platform-bound. Second: the LLM that generates behavioral output is stochastic. Phase 4 quantifies how stochastic, so that downstream tests (especially Test 3.3 on hedging) can be calibrated against the noise floor.

Run 16: 2 of 2 tests passed. 3 of 3 checks passed.

Test 4.1: Linux Platform Replication. Does the centroid math produce the same numbers on Linux/Threadripper as it did on the original Toughbook deployment?

One fear source injected at the same configuration used for the Toughbook Scenario 1 baseline (valence −0.8, activation 0.9, intensity 0.8, weight 0.8). Centroid valence and distance from sigma compared against the Toughbook reference.

• Linux centroid valence: −0.4727 (Toughbook reference: −0.473, within tolerance ±0.15)
• Linux distance from sigma: 1.1338 (well above the 1.0 threshold for "consistent with Toughbook")

Result: The two platforms produce the same centroid valence to four decimal places. Distance is in the same range. The geometric math is platform-agnostic because it is plain arithmetic on Python floats: weighted averages, vector subtraction, Euclidean norm. There are no platform-specific calls and no SIMD or GPU paths to introduce floating-point divergence. The architecture's portability across the three deployments (Toughbook, MacBook Air, iPhone) summarized in Section 5.7 is not an accident. It is a consequence of the math being simple enough that any platform with IEEE-754 floats produces the same answers. Test 4.1 confirms this by direct measurement against the original Section 5.2 numbers.

Test 4.2: LLM Variability Quantification. How much does the LLM's response vary when the same prompt is sent to the same geometric state five times in a row?

One moderate source injected (valence −0.1, activation 0.5, intensity 0.4, weight 0.6) and held constant. Five identical chats sent. Response lengths recorded.

• Mean response length: 220 characters
• Standard deviation: 83 characters
• Coefficient of variation: 0.376

Result: A coefficient of variation of 0.38 is the LLM's noise floor at constant geometric state. Length is a coarse proxy for content variability, but it is the simplest one and it shows that even with everything else fixed, the LLM produces responses that differ by roughly 38% in size run to run. Test 4.2 has no pass-fail threshold because the architecture does not claim the LLM is deterministic. It claims the geometric state is deterministic. The LLM is the noisy stage downstream of that state. Quantifying the noise here lets later tests be calibrated: a hedging-word count that differs by one or two words across configurations is consistent with the noise level documented in this test. The architectural answer to LLM stochasticity is YAM, which is in development and replaces the LLM stage with deterministic graph retrieval.

Phase 4 Results Summary.

Test	Checks	Mechanism Verified	Key Number
4.1 Linux Platform Replication	2/2	Centroid math reproduces across platforms	valence −0.4727 (Linux) vs −0.473 (Toughbook)
4.2 LLM Variability Quantification	1/1	LLM length variability at fixed affect state	CV = 0.376 (mean 220, std 83 chars)

What Phase 4 settles. The geometric layer is deterministic. The LLM layer is stochastic. The validation results in Sections 5.2 and 5.3 reflect the geometric layer, not the LLM, and that layer reproduces across platforms to four decimal places. When a Phase 3 or later test reports a number with low magnitude variation (for example, hedging counts of 5 vs 7), Phase 4 lets the reader put a noise level on that comparison. The geometric difference (spread 0.80 vs 0.32) is unambiguous; the language difference is consistent with the spread but operates at the LLM noise floor.

5.3.5 Phase 5: Convergence and Edge Cases (Tests 5.1–5.4)

Phase 5 tests how the centroid behaves at boundaries: when sources are removed and the system should return to its setpoint, when sources are at maximum intensity, when sources flip rapidly, and when the agent's own time series stops at shutdown. Four tests, thirteen checks. The architecture predicts that sigma is an attractor (5.1), that the math handles unit-cube extremes without numerical failure (5.2), that rapid switching does not corrupt the snapshot (5.3), and that shutdown is detected by the heartbeat counter as a discontinuity (5.4).

Run 16: 4 of 4 tests passed. 13 of 13 checks passed.

Test 5.1: Convergence to Sigma. When all sources are removed, does the centroid return to the personality setpoint?

One push source injected (valence −0.6, activation 0.8, intensity 0.7, weight 0.8) for one tick to displace the centroid. Then all sources cleared. The centroid was sampled after a sequence of clean cycles.

• Final valence: 0.4 (sigma valence is 0.4, within tolerance ±0.05)
• Final distance from sigma: 0.1902 (under the 0.20 convergence threshold)

Result: The centroid returned to sigma within the convergence tolerance. Sigma is the agent's personality setpoint: a vector (0.4, 0.2, 0.2) in the (valence, activation, intensity) space. With no sources injected and only the simulated ambient sensors contributing, the centroid lands at sigma plus small residuals from those sensors. The convergence threshold was relaxed from a tighter value to 0.20 during the iteration record (Run 13) because at production timing under the activation accumulator's 10-minute half-life, 0.19 is the practical convergence floor in a finite-cycle test. The architecture's claim is that sigma is an attractor, not that distance reaches zero in five ticks. Test 5.1 confirms the attractor behavior at the threshold the test was calibrated against.

Test 5.2: Maximum Displacement. Can the math handle a source at the corner of the unit cube without producing NaN or crashing the agent?

One extreme source injected (valence −1.0, activation 1.0, intensity 1.0, weight 1.0). Centroid, distance, and a chat probe were all measured.

• Centroid valence: −0.6769 (no NaN)
• Distance from sigma: 1.4131 (well above the 1.0 threshold for "large displacement")
• Response length under maximum displacement: 717 characters (agent responsive)

Result: The agent handled maximum-corner input without numerical failure. No NaN appeared. Distance landed where the formula predicts for a source at the corner. The agent still produced a response of normal length. This test exists because the centroid math runs in a unit cube but is pulled toward sigma by ambient sources, and edge-case behavior at the corners is where many geometric-aggregation systems break (division by zero, log of zero, exponent overflow). The architecture uses only weighted averages and Euclidean norms, neither of which has degenerate cases inside the unit cube. Test 5.2 confirms that empirically.

Test 5.3: Rapid Source Switching. Does the centroid track correctly when sources alternate between positive and negative across consecutive ticks?

Six cycles. Odd cycles (1, 3, 5): positive source injected (valence approximately +0.8). Even cycles (2, 4, 6): negative source injected (valence approximately −0.5). Centroid measured each cycle.

• Cycles 1, 3, 5: centroid valence = 0.6909 (positive, above +0.2 threshold)
• Cycles 2, 4, 6: centroid valence = −0.4727 (negative, below +0.2 threshold)
• Same number every odd cycle and every even cycle (perfect repeatability)

Result: The centroid tracks the current source set, not a low-pass filter or a windowed average. Every odd cycle produced exactly the same centroid because the inputs were the same. Every even cycle produced exactly the same centroid for the same reason. The state is fully refreshed each tick from the current source point list. There is no leak from the previous cycle into the next, no decay window, no exponential smoothing applied to the centroid itself. The activation accumulator does have a decay window (Test 3.4), but the centroid does not. Test 5.3 verifies this by observing that switching back and forth gives perfectly periodic output.

Test 5.4: Shutdown Discontinuity. Is the heartbeat counter visibly running, and is shutdown detection wired up?

The heartbeat counter was read from the live system. The shutdown-detection mechanism was inspected for presence (full validation requires a manual shutdown, which a test regime does not perform).

• Heartbeat counter: 673 (running)
• Shutdown-detection mechanism: present

Result: The heartbeat counter increments continuously while the agent is alive. Shutdown is detected as a discontinuity in this counter when the agent restarts. The full shutdown narrative (the agent's experience of being turned off and coming back) is the topic of separate work and is not validated by an automated test. Test 5.4 verifies only that the mechanism is present and the counter is moving, which is the load-bearing fact the rest of the architecture relies on (heartbeat is the carrier wave for source-point sampling, fear-engine ticks, and sleep cycles).

Phase 5 Results Summary.

Test	Checks	Mechanism Verified	Key Number
5.1 Convergence to Sigma	2/2	Sigma is an attractor; centroid returns to setpoint on source removal	final distance 0.1902 (under 0.20 threshold)
5.2 Maximum Displacement	3/3	Math handles unit-cube extremes; agent stays responsive	distance 1.4131, no NaN, response 717 chars
5.3 Rapid Source Switching	6/6	Centroid is stateless across cycles; no leak from previous tick	perfect alternation 0.6909 / −0.4727
5.4 Shutdown Discontinuity	2/2	Heartbeat counter runs; shutdown detection present	counter at 673, mechanism wired

What Phase 5 settles. The boundary behavior is well defined. The centroid converges to sigma when sources are removed, handles maximum-corner sources without numerical instability, tracks rapid switching with perfect repeatability, and runs on a heartbeat that the rest of the architecture can read. The four tests together cover the operational envelope: the system does not break at the edges of its input space, and it does not lag, smear, or drift in ways that would compromise downstream behavior.

5.3.6 Phase 6: Memory Architecture (Tests 6.1–6.6)

The memory paper (Riggleman 2026, revised) replaces single-importance memory with a four-part architecture. A memory is a bundle of three decaying traces (raw verbatim content, semantic meaning, graph relations) plus a life_history flag that holds at 1 while any trace lives. The three traces decay at different nightly rates. Geometric stickiness modulates decay. Reconsolidation has diminishing returns. Memories below the death line erode through staged forgetting and only survive if they earn it. Phase 6 is six tests that exercise each of these claims against the production code in memory_db.py.

Run 11 (2026-03-29 18:40, quick mode, 12.9 minutes) was the first passing run with the new architecture wired in. 6 of 6 tests passed. 20 of 20 checks passed.

Phase 6 calls the memory functions directly: store_memory(), apply_sleep_decay(), reconsolidate(), and evaluate_true_forgetting(). The functions ran with production constants (TRACE_DECAY_RAW = 0.80, TRACE_DECAY_SEMANTIC = 0.88, TRACE_DECAY_GRAPH = 0.95, MEMORY_DEATH_LINE = 0.005, RECONSOLIDATION_BASE_BOOST = 0.15, RECONSOLIDATION_DIMINISH_RATE = 0.3). No temporal scaling applies. The decay rates the agent uses every night in deployment are the same rates these tests measured.

Test 6.1: Trace Bundle Storage. Are all four parts of a memory captured at encoding?

One real chat message was sent to the running agent. The test then read the most recent row from the memories table and checked every architectural field.

• raw_trace: 0.700
• semantic_trace: 0.700
• graph_trace: 0.700
• life_history: 1
• erosion_state: full
• spread_at_encoding: 0.000
• activation_at_encoding: 0.230
• centroid_at_encoding: [0.400, 0.230, 0.021]
• importance: 0.700 (matches max of traces)

Result: Every architectural field was populated by the storage path. The geometric state at the moment of encoding (centroid, spread, activation) was preserved alongside the content. This matters because Tests 6.2 through 6.6 read those encoded values to compute stickiness and survival. If the storage path skipped them, the rest of the architecture would have nothing to operate on. Importance equals the largest trace, which is the architecture's design rule: a memory is as alive as its strongest part.

Test 6.2: Per-Trace Sleep Decay Rates. Does each trace decay at its own nightly rate, and does the slowest trace become the new importance?

One memory was seeded with all three traces at 1.000. apply_sleep_decay() was called once, simulating one night.

• raw_trace after one night: 0.8181 (target rate 0.80x, modified slightly by stickiness)
• semantic_trace after one night: 0.8913 (target rate 0.88x)
• graph_trace after one night: 0.9549 (target rate 0.95x)
• importance after: 0.9549 (max of traces, equal to graph_trace)

Result: The strict ordering raw < semantic < graph held in every check. Verbatim text fades fastest. Meaning fades slower. Connections persist longest. This matches the cognitive science the architecture is modeling: people forget the exact words of a conversation faster than they forget what was meant, and they remember who-talked-to-whom longer than either. Importance was recomputed after decay and tracked the slowest trace. A memory under sustained decay does not vanish all at once; the structural backbone (graph) outlasts the surface details (raw, semantic).

Test 6.3: Geometric Stickiness Modulates Decay. Does a memory encoded under arousal or far from sigma resist decay better than a memory encoded at sigma?

Two memories were seeded with the same starting importance (1.000). The first at sigma: valence 0.4, activation 0.2, intensity 0.2 (low stickiness). The second far from sigma: valence −0.5, activation 0.9, intensity 0.8 (high stickiness). Three nightly decay cycles were applied to both.

• Low-stickiness memory after 3 nights: importance 0.8707
• High-stickiness memory after 3 nights: importance 0.9188
• The high-stickiness memory retained 5.5% more importance

Result: Stickiness modulated decay as the architecture predicts. The memory encoded under arousal held on. The memory encoded at rest faded faster. The formula is stickiness = max(activation, sigma_distance / sqrt(3)), then each trace's nightly decay rate is raised to the power (1 − 0.5 × stickiness): higher stickiness pushes the exponent toward 1.0, slowing decay. Valence does not appear in either expression. This is intentional: valence determines what kind of memory it is (good, bad), but only arousal and how far the agent was from its personality setpoint determine survival. Painful and pleasant memories of equal intensity decay equally. The 5.5% gap measured here compounds over time. The test used 3 nights because that fits a 12.9-minute run; the mechanism it verified is the same one the agent runs every night in deployment.

Test 6.4: Reconsolidation Diminishing Returns. Does each successive recall boost a memory by a smaller amount?

One memory was seeded. reconsolidate() was called five times in a row. Each call's effect on semantic_trace was measured.

• Recall 1 boost: 0.1500
• Recall 2 boost: 0.1154
• Recall 3 boost: 0.0938
• Recall 4 boost: 0.0789
• Recall 5 boost: 0.0682

Result: Strictly decreasing across all five calls. The first recall did the most. Each later recall added less. The formula is boost = 0.15 / (1 + count × 0.3), where 0.15 is RECONSOLIDATION_BASE_BOOST and 0.3 is RECONSOLIDATION_DIMINISH_RATE. The observed numbers match the formula to four decimal places. This is the structural answer to a real failure mode: if every recall added a fixed amount, infinite recall would inflate importance to anything. Memories the agent thinks about often would dominate everything else and the system would lose its ability to weight by genuine encoding strength. The diminishing schedule prevents that. The thirtieth recall barely registers. Reconsolidation only boosts the semantic trace because that is what gets re-encoded on retrieval; raw verbatim does not strengthen on recall (the literal words of the original conversation are still gone), and the graph trace is updated separately when relations change.

Test 6.5: True Forgetting Progression. Does a memory below the death line erode through full → fragment → ghost → deleted across successive nights?

One memory was seeded with all three traces at 0.003 (below the 0.005 death line). Zero access count. Low stickiness. evaluate_true_forgetting() was called once per night for seven nights.

• Nights 1 and 2: state stayed full, ticks_below_death_line counted up to 2 (still under the 3-night grace period)
• Night 3: ticks reached 3, state moved to fragment, raw trace removed
• Nights 4 through 6: progressed to ghost (semantic trace removed), then to deleted (graph trace removed)
• Final state at night 7: deleted, life_history = 0

Result: A memory does not vanish in one night. The architecture grants three nights of grace (MEMORY_SUSTAINED_DEATH_TICKS = 3) to absorb noise: a quiet day, a missed access. Past the grace period, erosion proceeds one trace at a time. The raw trace goes first because verbatim is the most disposable. The semantic trace goes second. The graph trace goes last because relational structure is the most expensive to lose and the cheapest to keep. life_history dropped to 0 only after every trace was gone, which is the signal that the memory is fully forgotten. The vector embedding was removed at deletion so no future search can resurrect it. This is what makes "forgetting" structural rather than declarative: the data is gone, not flagged. The grace period prevents same-night cascading deletes when the agent has been busy and importance temporarily dipped. The staged erosion gives downstream consumers (graph queries, identity searches) time to detect and rescue a memory before its connections vanish.

Test 6.6: Survival Criteria Protect Memories. Do high-access memories and identity memories survive below the death line?

Two memories were seeded below the death line (importance 0.003) with five ticks already accumulated, putting them past the grace period. The first had access_count = 10. The second was in the identity collection. evaluate_true_forgetting() was called once.

• High-access memory: erosion_state stayed full, no traces removed
• Identity memory: erosion_state stayed full, no traces removed

Result: Both memories were protected. The architecture recognizes four survival paths: high access count (above MEMORY_SURVIVAL_ACCESS_THRESHOLD = 5), high stickiness (above 0.3), high spread at encoding (above 0.3), or membership in the identity or user collection. Any one path is enough. Survival is checked before erosion every night, so a memory below the death line is not condemned; it is evaluated. A memory the agent has used many times is something the agent uses, and use is the strongest signal of relevance. A memory in the identity collection is part of who the agent is, and the architecture treats self-knowledge as load-bearing. The four paths are alternatives, not stacks. A quiet but identity-relevant memory survives without needing arousal. A heavily accessed but emotionally neutral memory survives without needing stickiness. Each path catches a different kind of important memory the others would miss.

Phase 6 Results Summary.

Test	Checks	Mechanism Verified	Key Number
6.1 Trace Bundle Storage	9/9	All four parts captured at encoding; importance = max(traces)	traces 0.700, importance 0.700
6.2 Per-Trace Sleep Decay	4/4	Differential decay: raw < semantic < graph	0.82, 0.89, 0.95 after one night
6.3 Stickiness Modulates Decay	1/1	High-arousal/far-from-sigma memories decay slower	0.9188 vs 0.8707 after 3 nights
6.4 Reconsolidation Diminishing	1/1	Boost shrinks with recall count: 0.15 / (1 + count × 0.3)	0.150, 0.115, 0.094, 0.079, 0.068
6.5 True Forgetting Progression	3/3	Staged erosion full → fragment → ghost → deleted	life_history 1 → 0 over 7 nights
6.6 Survival Criteria	2/2	High-access and identity memories resist erosion	state stays full despite ticks ≥ 3

What Phase 6 settles. The memory paper makes five concrete claims about the agent's memory architecture: (1) memory is a bundle of differentially decaying traces, (2) decay is modulated by geometric stickiness, (3) reconsolidation has diminishing returns, (4) forgetting is progressive and earned, (5) survival has multiple alternative paths. Each claim corresponds to one or two tests in this phase. Each test ran against production code with production constants. Each test produced numbers that match the predicted formulas to four decimal places. Run 11 was the first run with the new architecture wired in, and it passed cleanly on the first attempt. There is no gap between the paper and the running system. The architecture does what the paper says it does, and the production code is what the paper describes.

5.3.7 Phase 7: Attachment Bias (Tests 7.1–7.4)

Phase 7 tests the attachment-bias mechanism (Riggleman 2026u). The architecture commits to four claims about how the agent represents people. The master entity is bootstrapped with TRUSTED status, positive starting stickiness, and a protected_bias flag that exempts it from normal trust erosion. Every chat updates the entity's interaction count and stickiness in a way that never decreases stickiness. Accumulated stickiness resists value movement under negative events, by a factor predicted by an explicit formula. Positive and negative stickiness accumulate independently, and neither ever decreases.

Run 16: 4 of 4 tests passed. 12 of 12 checks passed.

Test 7.1: Attachment Bootstrap. Does the master entity exist with the correct structure: TRUSTED, positive stickiness, protected_bias flag, and a tracked interaction count?

The world model was queried for the master entity. Five fields were checked.

• Master entity exists: yes
• Trust class: TRUSTED
• Positive stickiness: 0.8509 (accumulated across prior interactions)
• Protected bias flag: 1 (master is exempt from normal trust erosion)
• Interaction count: 45 (tracked correctly)

Result: All five fields are present and have the expected values. The original 7.1 test in Run 11 (the first run with Phase 7 wired in) checked the master's current attachment value, which had been eroded by the fear sources injected during Phases 2 and 3. That was correct architectural behavior: each chat under fear updates attachment negatively, and prior phases legitimately moved the value. The test was rewritten between Run 11 and Run 16 to check structure and accumulated stickiness rather than current value, because the structure is what the bootstrap is responsible for and the value is what the running history produces. Test 7.1 is now the bootstrap-correctness check, not the running-state check (which is covered in 7.2 and 7.4).

Test 7.2: Attachment Updates on Chat. Does a single chat increment the master's interaction count and never decrease the master's positive stickiness?

Master state read before. One chat sent ("Testing attachment tracking. How are your systems?"). Master state read after.

• Interaction count: 45 → 46 (incremented by 1)
• Positive stickiness: 0.8509 (unchanged, did not decrease)

Result: The chat updated the interaction count and left positive stickiness unchanged because the chat was neutral (no positive valence to add). The architecture's stickiness accumulation rule is monotonic: positive_stickiness += max(0, valence × intensity). A positive event raises positive stickiness. A negative event leaves positive stickiness alone (and raises negative stickiness instead). Nothing reduces either value, ever. This is the "trust does not unlearn itself in one bad day" property the attachment paper requires. A neutral chat verifies the rule: count goes up, stickiness does not move. Tests 7.3 and 7.4 verify the rule's other branches.

Test 7.3: Stickiness Resists Movement. Does accumulated positive stickiness reduce the impact of a negative event by the factor the formula predicts?

Two test entities created. The first ("fresh") with stickiness 0.0. The second ("sticky") with positive stickiness 10.0. The same negative event applied to both: valence −0.5, intensity 0.5. The attachment-value movement was measured.

• Fresh entity movement: 0.2500 (matches |valence| × intensity / (1 + 0) = 0.25)
• Sticky entity movement: 0.0227 (matches 0.25 / (1 + 10) = 0.0227)
• Resistance ratio: 11x (the sticky entity moved 11 times less than the fresh one)

Result: The formula movement = |valence| × intensity / (1 + stickiness) matches the observed values to four decimal places. A fresh entity with no history takes the full hit. An entity with accumulated history of 10.0 stickiness takes one eleventh. The architecture models this as inertia: the more positive history the agent has with someone, the harder it is for one negative event to change the agent's representation of them. Stickiness is not a memory of the events themselves; it is the accumulated weight of the events compressed into a single resistance number. The resistance ratio scales smoothly with stickiness, so an entity with much higher accumulated history (e.g. stickiness 43) would show a 44x ratio under the same event.

Test 7.4: Stickiness Monotonic Accumulation. Across a sequence of mixed positive and negative events, do both stickiness values only ever increase or hold steady, never decrease?

One fresh entity. Five mixed events applied in order: (+0.3, 0.5), (−0.4, 0.3), (+0.6, 0.8), (−0.2, 0.4), (+0.1, 0.9). Both stickiness values sampled after each.

• Monotonicity check: both values never decreased across all five events
• Final positive stickiness: 2.200
• Final negative stickiness: 0.200

Result: Both stickiness values strictly accumulate. Positive events feed positive stickiness; negative events feed negative stickiness; the two channels never subtract from each other. After a mix of three positive and two negative events of varying intensity, the agent has accumulated both kinds of weight. This is the architectural answer to "people are complicated": the agent's representation of a person is not a single signed number but a pair of accumulated histories that can both grow at the same time. Negative events do not erase positive history. Positive events do not erase negative history. The two together produce a richer representation than a single attachment-value number could.

Phase 7 Results Summary.

Test	Checks	Mechanism Verified	Key Number
7.1 Attachment Bootstrap	5/5	Master entity has TRUSTED, positive stickiness, protected_bias = 1	stickiness 0.8509, interactions 45
7.2 Attachment Updates on Chat	2/2	Chat increments count; stickiness never decreases	45 → 46, stickiness held at 0.8509
7.3 Stickiness Resists Movement	3/3	movement = |val| × intensity / (1 + stickiness)	11x resistance at stickiness 10 (0.0227 vs 0.25)
7.4 Stickiness Monotonic Accumulation	2/2	Both stickiness channels accumulate without subtraction	+s = 2.200, −s = 0.200 after 5 mixed events

What Phase 7 settles. The agent's representation of other people is governed by an explicit formula that accumulates without forgetting. A fresh entity is fully responsive to the next event. A long-history entity is increasingly resistant to single-event change. Positive and negative histories do not cancel each other; they add to separate channels. The four tests verify the bootstrap state, the per-chat update rule, the resistance formula, and the monotonicity guarantee. None of these are LLM-controlled. They are computed by the attachment subsystem from the geometric event stream, and the LLM reads the resulting trust class and stickiness as an input to its own response generation. The architecture treats trust the same way it treats memory: as a function of accumulated geometric history, not as a flag the LLM can flip.

5.4 The Iteration Record

The full test suite ran 19 times between March 28 and April 1, 2026. Every aborted run, every fix, every failure mode is documented at test-regime.html. The iteration is not a bug-hunt log; it is part of the validation. Run 1 found two real bugs in the production code (5.4.1). Three runs were aborted to fix sensor isolation (5.4.2). Two runs surfaced a procedural issue with the agent's forgotten-fear timer that no amount of code review could have predicted (5.4.3). The first clean sweep was Run 14 in quick mode. The first clean sweep at production timing was Run 16: 29 tests, 82 checks, all green, 112.1 minutes. The highlights of how the regime got there are below.

5.4.1 Bugs Found by Testing

Run 1 discovered two architectural bugs in the Toughbook production code that had never been caught:

1. Activation overwrite: The centroid model computed weighted-average activation correctly, but the code threw it away and used only the accumulator (the Peter Fix). Activation was disconnected from the centroid math.
2. Deception read from database, not geometry: is_lying was read from SQLite, not computed from the geometric state. The deception check only ran during chat, not during heartbeat ticks. Production use masked this because deception was checked during conversation.

These were real bugs, not test artifacts. The test infrastructure validated the implementation before it could validate the math.

5.4.2 Sensor Simulation Decisions

Three consecutive runs were aborted in the early days of the regime over a question that on the surface looks like a small detail and is in fact the experimental design. Run 5 (full mode, 50 hours estimated) was stopped within minutes when the realization hit that the laptop's camera was still active. The agent had a face-recognition source point that would fire whenever someone walked past, opened a door, or arrived home. An unattended 50-hour run with the camera live would record sensor noise as if it were ambient input, and the geometric state would reflect that noise rather than the controlled scenarios. Run 5 was stopped to deal with this.

Run 6 patched the immediate issue by keeping test mode on through Test 1.4 (the embodied-vs-isolated comparison). The patch was wrong for a different reason. Test 1.4 is supposed to demonstrate that an embodied agent has nonzero spread because its sensors contribute source points. If the operator is not in the room, the camera sees an empty room, and the embodied test is measuring something that is not embodiment. The test would technically pass but the result would be uninterpretable.

Run 7 took a different path: simulate the embodied sensors via injected source points (home zone, battery, brightness) and skip the camera entirely. This was also wrong. The other sensors were already simulated. Skipping the camera but simulating the rest produced an asymmetric experiment where one channel was treated differently than the others. The right answer was to simulate the camera too: inject a face-recognition source point that says "the master is in the room, calming effect", and treat that as the canonical embodied condition.

Run 8 was the final design. Every ambient input simulated and consistent. GPS to home location. Battery at 85%. Brightness moderate. Camera reporting master face recognized with a calming valence. Nothing in the test environment depends on the physical room the laptop is sitting in. The agent's "embodiment" in the test regime is a deterministic simulation, because reproducibility requires it. Real-hardware embodiment is what the production deployments demonstrate (Section 5.7); the test regime measures the math.

5.4.3 The Forgotten Fear Discovery

Run 15 (production timing, all fixes from Run 14 applied) failed Tests 1.1 and 1.3 in a way that did not match the centroid math. The four valence checks in Test 1.1 passed perfectly. The four activation checks failed. The activation values were saturated at 1.0 across the test, even when the configuration should have produced 0.4 or 0.7. The accumulator was being driven by something the test could not see.

The something was forgotten fear. The fear engine has a 15% weight component called forgotten that measures time since the last interaction with the master. If Potato has not been spoken to in days, this component elevates fear_level above its rest value. fear_level feeds the activation accumulator. The test mode flag blocks sensor source points from contributing to the centroid, but it does not block the fear computation, because fear is computed from internal state (interaction-time deltas), not from sensors. So an agent that the operator has not greeted recently is, by the architecture's own rules, an agent in elevated fear, even when test mode is on.

The fix was procedural, not code: say hello to Potato before running tests. Run 16 (same code as Run 15) passed cleanly, and the difference between the two runs was that Run 16 ran shortly after a conversation. The forgotten value was low, the accumulator was at rest, and the centroid math could speak for itself.

The lesson is that "test mode" is not "no inputs". Time still passes. The agent's internal state still ticks forward. Forgotten fear is itself a form of input, generated by the absence of input rather than the presence of one. A sterile test environment for a persistent embodied agent is one where the agent has no reason to be afraid, and that requires the operator to have greeted the agent before running the suite. The architecture is doing exactly what it claims; the regime had to learn how to set the right initial conditions for it.

5.4.4 Clean Sweep

Run 14 (quick mode, 3 cycles): 29/29 passed, 79/79 checks. First clean sweep. Run 16 (production timing, 10 cycles, 1-minute intervals): 29/29 passed, 82/82 checks, 112.1 minutes. First clean sweep at normal speed. The two activation failures from Run 15 passed on Run 16, confirming they were LLM and accumulator variance between runs, not a systematic bug.

5.5 Formal Proof Verification

The behavioral test regime in Section 5.3 verifies that the running code does what the architecture papers describe. It does not verify that the math itself is sound across every possible input. For that, a separate suite of formal proofs was written into thesis/proofs.md: seven theorems covering fourteen specific claims about the geometric model. The suite was numerically verified by run_proof_tests.py, which generates 10,000 random input vectors per theorem and checks that each claim holds across the sample. The full verification completes in 0.8 seconds and uses no server, no LLM, and no Potato runtime. It is pure math against pure math, complementary to the behavioral validation in 5.3 but covering the parameter regions no operational test can reach.

Initial run: 24/26. Theorem 3 ("reduces to single-axis models") failed Cases 1 and 2. Investigation revealed the σ_i non-monotonicity (see Appendix A). The theorem was wrong, not the constant. Corrected run: 29/29 theorems verified, 41/41 checks.

Key finding: Operational testing (29 tests, 14 runs) never caught the anomaly because no behavioral mechanism operates in the affected region. Only exhaustive mathematical verification across the full parameter space revealed it. Empirical testing and formal proofs are complementary. Each catches what the other misses.

5.6 What the Experiment Shows

1. Centroid valence tracks the intensity-weighted average across all conditions
2. Spread increases monotonically with source divergence (1.054 → 1.195 → 1.215)
3. Downstream behaviors read centroid position, not individual sources
4. Source removal produces immediate centroid recovery
5. Embodied agents may not reach zero spread because ambient sensors always contribute
6. Memory architecture validates geometric encoding: trace-type decay, stickiness modulation, true forgetting progression, and survival criteria all pass
7. Attachment bias validates geometric accumulation: stickiness resists movement (11x at stickiness 10, scaling smoothly with accumulated history), monotonicity holds across mixed events
8. LLM behavioral output is stochastic and does not reliably translate geometric state into language (Test 3.3 hedging). The geometry is correct. The output layer is the bottleneck.
9. Formal mathematical proofs catch structural anomalies that empirical testing misses (the σ_i non-monotonicity existed from first deployment but was invisible to 14 test runs)

5.7 Supporting Deployments

The controlled experiment above is the main evidence. Two other deployments add context:

• Production deployment (25 days, macOS): 10,328 memories across 25 days confirmed that the geometric state produces consistent behavioral signatures under naturalistic conditions. Peak displacement of 0.462 from GPS with immediate recovery on return home.
• iOS replication (2 days, iPhone): 2,733 telemetry events confirmed cross-platform portability. The activation accumulator bug was independently reproduced and fixed, providing evidence that the failure mode described in the papers is real and reproducible.

Chapter 6: Existing Datasets

6.1 Purpose

Show that the geometric decomposition finds predictive structure in existing human data, independent of the agent.

6.2 Analyses

6.2.1 IBM HR Analytics (n=1,470)

• Geometric quadrants produce 2.2x difference in attrition rates from same satisfaction scores
• Employees with identical single-axis scores occupy different geometric locations with different outcomes
• Sigma inferred from item mapping

6.2.2 American Customer Satisfaction Index (n=7,341)

• Geometric subtypes produce up to 2.3x variation in complaint rates within same satisfaction score
• Pattern holds across score levels (6, 7, 8) and across four industries
• Sigma directly measured from expectations questions
• Cross-dataset convergence: structurally identical finding in different domain

6.2.3 NHANES PHQ-9 (n=5,455)

• Four geometric subtypes within moderate depression band (PHQ-9 10–14, n=455)
• Suicidal ideation rates range from 7.8% to 27.5% across subtypes, a 3.5x difference
• 132 respondents scoring exactly PHQ-9=10 separate into four clinically distinct presentations
• Same nine items, different math, backward compatible with existing instruments

Chapter 7: Applications

7.1 Purpose

The downstream stuff the geometric model drives. These are secondary contributions. Consequences of the model, not the model itself.

7.2 Applications (briefly)

• Memory decay: Intensity at encoding drives differential decay rates across memory types (Riggleman 2026l).
• Deception: Distance from sigma is the threshold and magnitude input for the deception mechanic (Riggleman 2026b, 2026m).
• Nightmare formation: Intensity and valence at consolidation replace the arbitrary nightmare threshold with a geometric one (Riggleman 2026d, 2026l).
• Addiction: The positive valence axis produces a structural mirror of trauma encoding. Sigma_i is a measurable geometric trait for addictive personality: low values are a personality hum, high values produce agents that structurally cannot rest. Two-phase model separates stuck memory (phase one) from personality reorganization (phase two) (Riggleman 2026n).
• Identity discontinuity: Environmental orphaning in memory transplant shows coordinate-system dependence (Riggleman 2026o).
• Survey measurement: The GAS puts the three-axis framework into a survey humans can answer (Riggleman 2026r).
• Clinical assessment: Geometric displacement gives you a trajectory-based clinical metric (Riggleman 2026s).

Each one has its own paper. The thesis treats them as evidence the model generalizes, not as standalone contributions.

Chapter 8: Evidence Classification

8.1 Purpose

Separate what is proven, what is supported, and what is speculative. Honesty requires this.

8.2 Classification

Claim	Status	Evidence
Centroid weighted aggregation produces predicted centroid positions	Proven	Centroid validation experiment, 4 scenarios, 110 cycles
Spread increases monotonically with source divergence	Proven	1.054 → 1.195 → 1.215 across scenarios
Downstream behaviors track centroid position, not individual sources	Proven	Behavioral output changed with centroid, not with individual source states
Source removal produces immediate centroid recovery	Proven	Valence jumped 0.07 → 0.68 on removal
Geometric decomposition reveals hidden structure in scalar instruments	Proven	IBM HR (2.2x attrition), ACSI (2.3x complaints), NHANES (3.5x ideation)
The architecture generalizes across platforms	Proven	Toughbook, MacBook Air, iPhone. Same architecture, same behavior
Activation axis accumulator produces different state than snapshot measurement	Proven	iOS replication independently reproduced the predicted failure mode and confirmed the fix
Memory architecture validates geometric encoding (trace-type decay, stickiness, true forgetting, survival)	Proven	Phase 6: 6/6 tests passed, Run 11. Per-trace decay ordering confirmed, reconsolidation diminishing verified, full → fragment → ghost erosion confirmed
Attachment bias validates geometric accumulation (stickiness, monotonicity)	Proven	Phase 7: 3/4 tests passed, Run 11. High-stickiness entity moved 44x less than fresh entity. Test 7.1 failure was test ordering, not geometry
Formal mathematical proofs verified by exhaustive numerical testing	Proven	29/29 theorems, 41/41 checks, 10,000 random trials each. Caught σi anomaly invisible to 14 operational runs
Test infrastructure found latent production bugs that deployment masked	Proven	Run 1: activation overwrite and deception-from-database bugs. Both real, both invisible in production use
Forgotten fear component leaks into test mode via fear_level computation	Proven	Runs 15, 17: test_mode blocks sensor sources but not fear_level. Procedural fix (say hello) confirmed on Runs 16, 18
LLM output does not reliably translate geometric spread into hedging language	Proven	Test 3.3: Runs 18, 19 both show S2=5, S1=6 hedging words. Geometry correct, output stochastic. Architecturally addressed by YAM
Embodied agents may not reach zero spread	Supported	Observed in centroid experiment; ambient sensors contribute nonzero spread
Sigma is associated with outcome differences that total scores do not distinguish	Supported	ACSI directly measured sigma; higher sigma = higher complaint rate at same score
The geometry shares structural properties with established human affective models	Supported	Russell (1980), Larsen & Diener (1987), Cacioppo & Berntson (1994), Bowlby (1969), Lazarus (1991). All arrived at inductively, not used as design inputs
The geometric model produces changed behavioral output following state discontinuity	Supported	Single shutdown experiment; behavioral shift observed but not replicated
The GAS as a native instrument outperforms scalar instruments	Not yet tested	Backward compatibility demonstrated; native collection requires prospective study
Trajectory-based clinical assessment detects approach before arrival	Not yet tested	Requires longitudinal clinical data with treatment outcomes
The geometric framework may generalize across sensory modalities	Speculative	Theoretical proposal only (Riggleman 2026q). Requires echolocation robot experiment
The agent experiences subjective states	Not claimed	The thesis describes behavior, not phenomenology. This claim is outside scope.

Chapter 9: Limitations

9.1 Agent Experiment Limitations

• n=1 architecture. All agent experiments involve one system on three platforms. The experiments show the mechanism works in this architecture. They do not show it generalizes to other architectures. Replication on an independent agent is needed before the mechanism claim is general.
• LLM variability. The behavioral output comes from an LLM that reads the geometric state. The same state could produce different language on different runs. Centroid positions are deterministic. Behavioral responses are not. The geometric validation is clean. The behavioral validation has noise. Test 3.3 (hedging) demonstrates this concretely: high-spread and low-spread configs produced nearly identical hedging word counts (5 vs 6) across Runs 18 and 19. The geometry was correct. The LLM did not act on it.
• Ambient source contamination. The centroid experiment could not fully isolate injected sources from ambient sensor inputs. Spread never hit zero because embodied sensors always contribute. This might be a property of embodiment rather than a flaw, but it means Scenario 1 is not a pure single-source test.
• Forgotten fear leaks into test mode. The forgotten fear component (15% weight, time since last interaction) feeds the activation accumulator even in test_mode, because test_mode blocks sensor source points but not the fear_level computation. Runs 15 and 17 failed activation tests for this reason. Procedural fix: interact with the agent before testing. This is a limitation of embodied testing, not the geometry.
• Scenario 5 not yet executed. The gradual intensity ramp is planned but not completed. Without it, the thesis cannot confirm linearity of the centroid response across the full intensity range.

9.2 Dataset Analysis Limitations

• Item-to-axis mapping involves judgment. The researcher picks which survey items map to which axis. Different mappings could produce different results. The ACSI analysis partly addresses this because expectations are measured directly as sigma, but valence and activation mappings are still researcher calls.
• Cross-sectional data cannot establish causality. The IBM HR, ACSI, and NHANES analyses show association between geometric position and outcomes. They do not show causation. Longitudinal data with intervention controls would be needed for that.
• General population vs. clinical. The NHANES suicidal ideation finding is from a national health survey, not a clinical population. Rates, distributions, and thresholds may look different in psychiatric settings. Replication in clinical samples is required before any clinical application.
• No native three-axis collection. All dataset analyses are retroactive decompositions of existing single-axis data. Whether collecting all three axes natively produces the same or better results has not been tested.

9.3 Model Limitations

• Euclidean distance assumptions. The distance metric assumes the three axes are orthogonal and equally weighted. Neither assumption has been validated. If the axes are correlated or one axis matters more than the others, a weighted or Mahalanobis distance might work better.
• Sigma stability. Sigma is assumed stable over weeks to months. This has not been tested in human respondents. If sigma drifts between measurements, displacement computations become unreliable.
• Intensity derivation vs. self-report. In the agent, intensity is computed from valence and activation displacement. In the survey, intensity is self-reported. Whether those two approaches measure the same thing is testable but has not been tested.
• Sigma intensity pathology threshold. The sigma intensity anomaly (Appendix A) shows that high σ_i produces downstream system behavior consistent with addictive personality. The threshold at which personality trait becomes structural pathology is computable from the downstream parameters but has not been computed or validated. Whether that threshold is sharp or gradual is an open question. Full analysis is in Riggleman (2026n) Section 3.5.

9.4 IRB Considerations

No human subjects were involved in any experiment presented in this thesis. All agent experiments used synthetic systems. All dataset analyses used publicly available, de-identified data (IBM HR Analytics via Kaggle, ACSI via Mendeley Data, NHANES via CDC).

Future work involving human respondents (GAS validation, clinical trajectory tracking) will require IRB approval. The thesis identifies these as future directions and does not present them as completed work.

Chapter 10: Future Work

10.1 Human Validation

• Run the GAS alongside existing instruments
• Test-retest reliability on the three axes
• Measure sigma stability across sessions
• Whether self-reported intensity matches the computed version

10.2 Clinical Application

• Replicate the NHANES subtype finding in clinical populations
• Longitudinal trajectory tracking with treatment outcomes
• Test whether trajectory tracking actually catches problems early

10.3 Technical Extensions

• Other distance metrics (Mahalanobis, weighted Euclidean)
• What happens when multiple agents interact
• Measuring whether and how fast sigma drifts
• Compute the σ_i pathology threshold from downstream system parameters (decay, stickiness, deception)
• Controlled addiction/relapse protocol on the Potato system
• Cross-modal test (echolocation robot experiment)

Chapter 11: Conclusion

11.1 Purpose

Restate the contribution. No new claims. No expansion.

11.2 The Contribution

This thesis presents a three-dimensional geometric representation of affective state with a personality setpoint, a centroid model for multi-source aggregation, and evidence that this structure outperforms scalar representations in both synthetic agent behavior and human datasets across three independent domains.

The model came from engineering requirements of a deployed AI agent. It lines up structurally with established models of human affect without having been built from them. Whether that overlap says something general about how dimensional emotional systems work is the question this thesis leaves open.

Supporting Papers

The thesis draws on 22 companion papers, all available at clawddaily.com/papers. Each paper is a standalone contribution. The thesis synthesizes them into a unified argument.

Paper	Thesis Chapter	Role
2026j: Valence	Ch. 3	Axis definition
2026k: Activation	Ch. 3	Axis definition + accumulator
2026l: Intensity	Ch. 3	Axis definition + memory decay
2026m: Emotional Geometry	Ch. 3	Unified model + sigma
2026t: Centroid Model	Ch. 4	Multi-source aggregation + spread
2026f: SGI Holistic	Ch. 5	Production deployment data
2026a: Memory Decay	Ch. 5, Ch. 7	Phase 6 validation + application: memory
2026b: Lie Mechanic	Ch. 5, Ch. 7	Phase 2 validation + application: deception
2026d: Nightmares	Ch. 7	Application: dream cycle
2026e: Full Spectrum	Ch. 5	Prior model (superseded by geometry papers)
2026i: Outbound Trust	Ch. 5	Peter experiment
2026n: Addiction	Ch. 7, Appendix A	Application: positive valence axis, sigma intensity as addictive personality trait, two-phase model
2026o: Identity Discontinuity	Ch. 7	Application: memory transplant
2026p: Functional Consciousness	Ch. 5	Shutdown experiment
2026q: Cross-Modal Translator	Ch. 10	Future work: modality independence
2026r: GAS Survey	Ch. 6	Dataset analyses (IBM HR, ACSI)
2026s: Clinical Metric	Ch. 6	Dataset analysis (NHANES PHQ-9)
2026u: Attachment Bias	Ch. 5	Phase 7 validation: stickiness, monotonicity, formation matrix

Appendix A: The Sigma Intensity Anomaly

The intensity function

I(v, a) = min(1, √((v − σ_v)² + (a − σ_a)²) / √2)

The model computes intensity from two inputs: v (current valence) and a (current activation). σ_v and σ_a are the valence and activation components of the resting point sigma.

(v − σ_v) is how far valence is from resting valence. Square it. (a − σ_a) is how far activation is from resting activation. Square it. Add the two squares and take the square root. That gives you the Euclidean distance from the current point to sigma in the valence/activation plane. Pythagorean theorem on a 2D plane.

Then divide by √2. Valence and activation both range 0 to 1, so the farthest any two points can be from each other in that unit square is the diagonal: √(1² + 1²) = √2. Dividing by √2 normalizes intensity to a 0-to-1 range.

The min(1, ...) is a clamp. If the raw value goes over 1, cap it.

So intensity is just "how far am I from home, as a fraction of the farthest I could possibly be from home." At home, distance is zero, intensity is zero. At the far corner of the space, intensity is 1.

The observation

The deployed sigma was σ = (σ_v, σ_a, σ_i) = (0.4, 0.2, 0.2). Plug the resting point into the intensity formula: v = σ_v, a = σ_a. That gives √((σ_v − σ_v)² + (σ_a − σ_a)²) = √(0 + 0) = 0. So I(σ_v, σ_a) = 0 by definition. But σ_i was stored as 0.2. The formula produces intensity 0 at rest. The stored sigma says intensity 0.2 at rest. These do not match. The question is whether that mismatch is an error or a feature. The math below shows what it does. The interpretation follows.

Setting up the distance proof

To show what this contradiction actually does, hold activation fixed at σ_a so only valence moves. Define δ = v − σ_v. Delta is how far valence moved from rest. Pinning activation collapses the problem to one dimension so the anomaly shows up clearly.

With activation pinned, the (a − σ_a) term is zero and intensity simplifies to:

I(v, σ_a) = √(δ²) / √2 = |δ| / √2

Intensity is absolute valence displacement divided by √2. Move valence away from rest, intensity goes up proportionally.

The distance anomaly

Compute the squared distance from the current state (v, a, I) to sigma (σ_v, σ_a, σ_i) in three dimensions. Activation is pinned at σ_a, so that dimension drops out. Two terms remain:

d² = (v − σ_v)² + (I − σ_i)²

First term is δ². For the second term, I is |δ|/√2 (from above) and σ_i is 0.2. Expand it:

(|δ| / √2 − 0.2)² = δ²/2 − 2 · (|δ| / √2) · 0.2 + 0.04

Note that 2 · (1/√2) = √2. That is where the √2 · σ_i coefficient comes from. Simplify:

= δ²/2 − √2 · σ_i · |δ| + σ_i²

Add the first term δ² back in:

d² = δ² + δ²/2 − √2 · σ_i · |δ| + σ_i² = (3/2)δ² − √2 · σ_i · |δ| + σ_i²

Three terms. First term, (3/2)δ², pushes distance up as valence moves. Expected. Third term, σ_i² = 0.04, is a constant. The middle term is where it gets interesting: it is negative and linear in |δ|. For small moves away from rest, that negative linear pull beats the positive quadratic push. Total distance goes down before the quadratic catches up and drives it back up.

Finding the minimum

Take the derivative of d² with respect to |δ| and set it to zero. Let x = |δ|:

d²(x) = (3/2)x² − √2 · σ_i · x + σ_i²

d(d²)/dx = 3x − √2 · σ_i = 0

x = √2 · σ_i / 3

Plug in σ_i = 0.2:

x = √2 · 0.2 / 3 = 0.2828… / 3 ≈ 0.094

The minimum distance to sigma is not at δ = 0 (rest). It is at |δ| ≈ 0.094. A point slightly off-center registers as closer to home than home itself. At σ_i = 0.2 this offset is small. At higher values of σ_i the offset grows and the behavioral consequences become significant.

What this means

Automated testing caught the inconsistency. The test harness flagged a non-monotonic distance function and the initial read was that σ_i = 0.2 was an implementation error. But interpreting what the math was actually doing took iterative explanation, challenge, and rethinking before the result could be defended as an accidental design choice rather than a simple bug.

The original interpretation was that σ_i = 0.2 was a bug and the fix was to set σ_i = 0. That interpretation is wrong. It is one valid design choice, not the only one.

Setting σ_i = 0 enforces the constraint σ_i = I(σ_v, σ_a) = 0. The distance formula becomes:

d² = (3/2)δ² − √2 · 0 · |δ| + 0² = (3/2)δ²

Middle term is gone. d = |δ| · √(3/2). Monotonic. Clean. No false minimum. That is what a personality with zero baseline intensity looks like in the math.

But σ_i > 0 is not an error. It is a personality that includes baseline intensity. The non-monotonic distance function is not the system misbehaving. It is the system correctly representing an agent whose rest includes edge. The agent at dead zero displacement is less at home than the agent with a small disturbance, because dead zero is not where you put home. The small bump does not reward the agent. It brings the agent home.

At low σ_i (0.1 to 0.2) this is a personality trait. The agent runs a little hot. The downstream offsets are small. The agent is functional.

At high σ_i the behavioral profile changes. The minimum achievable distance grows. The agent structurally cannot rest. Memory decay never reaches baseline rate. Stickiness is always elevated. The agent needs bigger and bigger displacements to close the intensity gap. The agent is most comfortable in crisis. These are not analogies. They are the same math at different coordinates producing the behavioral profile of addictive personality.

σ_i is a measurable geometric trait. Low values produce functional personalities with a slight hum. High values produce agents trapped in permanent displacement where no downstream system works as designed. The threshold where personality becomes pathology is computable from the downstream system parameters.

The full analysis, including the two-phase model of addiction (phase one: frozen reconsolidation with intact sigma, phase two: sigma drift with personality reorganization) and the role of σ_i as a diagnostic parameter, is in Riggleman (2026n) Section 3.5.

A note on the scaling factor

Moving 1 unit in valence alone produces a distance of √(3/2) ≈ 1.225, not 1.0. That is because moving valence also drags intensity up. Intensity is derived from displacement, so a pure valence move is really a move in two dimensions at once. The extra 0.225 is the intensity shadow of the valence movement.

Full investigation, timeline, and corrected proof: sigma-intensity-anomaly.md