PR-G1: replace neutral 0.5 causality placeholder with real Pearl 2³ mask

Add `causality_footprint: u8` field to `SpoWithGrammar` carrying a 3-bit
Pearl mask (S=bit2, P=bit1, O=bit0) derived from the primary SPO triple.
Replace the zero-fingerprint `expected_qualia_footprint` placeholder with
Pearl-seeded qualia dimension bits. Remove the `#[cfg(grammar-triangle)]`
gate on the module so Pearl mask tests run without the optional dep.

8 tests pass (84 total in deepnsm --lib).

https://claude.ai/code/session_01NYGrxVopyszZYgLBxe4hgj

Author: claude

crates/deepnsm/src/lib.rs

@@ -77,7 +77,9 @@ pub mod quantum_mode;
 #[cfg(feature = "contract-ticket")]
 pub mod ticket_emit;
 
-#[cfg(feature = "grammar-triangle")]
+// PR-G1: module always compiled — Pearl mask computation and
+// analyze_without_triangle are core. Only GrammarTriangle-dependent
+// code inside is gated behind #[cfg(feature = "grammar-triangle")].
 pub mod triangle_bridge;
 
 // ─── Re-exports ──────────────────────────────────────────────────────────────

crates/deepnsm/src/triangle_bridge.rs

@@ -1,17 +1,17 @@
-//! META-AGENT: add `pub mod triangle_bridge;` to lib.rs. Gate behind
-//! feature `grammar-triangle`. Also requires adding to Cargo.toml:
-//!   lance-graph-cognitive = { path = "../lance-graph-cognitive", optional = true }
-//!   lance-graph-contract  = { path = "../lance-graph-contract",  optional = true }
-//!   [features] grammar-triangle = ["dep:lance-graph-cognitive", "dep:lance-graph-contract"]
-//!
 //! Grammar Triangle bridge: merge DeepNSM SPO output with the Triangle's
 //! NSMField + CausalityFlow + QualiaField into a single SpoWithGrammar.
 //!
 //! The Triangle lives in `lance_graph_cognitive::grammar::GrammarTriangle`
 //! and is already-shipped (`from_text` constructs it). The actual API has
 //! `QualiaField` (18D phenomenal field) — not `Qualia18D`.
+//!
+//! PR-G1: real Causality footprint. The `causality_footprint` field on
+//! `SpoWithGrammar` carries a 3-bit Pearl 2³ mask derived from the SPO
+//! triple's active planes. This replaces the former neutral 0.5
+//! placeholder at lines 90 and 221.
 
 use crate::parser::SentenceStructure;
+use crate::spo::{SpoTriple, NO_ROLE};
 
 #[cfg(feature = "grammar-triangle")]
 use lance_graph_cognitive::grammar::{
@@ -45,6 +45,55 @@ pub struct SpoWithGrammar {
     /// footprint. Higher = more "novel domain" → routes to
     /// `NarsInference::Extrapolation` in the ticket.
     pub classification_distance: f32,
+
+    /// Pearl 2³ causality footprint: a 3-bit mask encoding which SPO
+    /// planes are active in the sentence's primary triple.
+    ///
+    /// Bit layout (matches `causal-edge::pearl::CausalMask` repr):
+    /// - bit 2 (0x04): Subject plane active
+    /// - bit 1 (0x02): Predicate plane active
+    /// - bit 0 (0x01): Object plane active
+    ///
+    /// Maps to Pearl's causal ladder:
+    /// - `0b101` (S+O) = Level 1: Association P(Y|X)
+    /// - `0b011` (P+O) = Level 2: Intervention P(Y|do(X))
+    /// - `0b111` (SPO) = Level 3: Counterfactual
+    /// - `0b110` (S+P) = intransitive: confounder detection
+    ///
+    /// Replaces the former neutral 0.5 placeholder. Downstream consumers
+    /// compare two triangles' `causality_footprint` values to detect when
+    /// the causal level has shifted (e.g., observational → interventional).
+    pub causality_footprint: u8,
+}
+
+/// Compute the Pearl 2³ causality mask from an SPO triple.
+///
+/// Each bit corresponds to one SPO plane:
+/// - bit 2: Subject active (rank != NO_ROLE)
+/// - bit 1: Predicate active (rank != NO_ROLE)
+/// - bit 0: Object active (rank != NO_ROLE)
+///
+/// This is a pure 3-bit projection — no `CausalEdge64` import needed.
+/// The resulting mask has the same bit layout as `causal-edge::pearl::CausalMask`
+/// so downstream consumers can cast directly.
+#[inline]
+pub fn compute_pearl_mask(triple: &SpoTriple) -> u8 {
+    let s_bit = if triple.subject() != NO_ROLE { 0b100 } else { 0 };
+    let p_bit = if triple.predicate() != NO_ROLE { 0b010 } else { 0 };
+    let o_bit = if triple.object() != NO_ROLE { 0b001 } else { 0 };
+    s_bit | p_bit | o_bit
+}
+
+/// Compute the aggregate Pearl mask for a sentence structure.
+///
+/// When the structure has one or more triples, returns the mask of
+/// the *primary* triple (index 0). When empty, returns `0b000` (no
+/// planes active — aggregate prior).
+pub fn causality_footprint_for(structure: &SentenceStructure) -> u8 {
+    match structure.triples.first() {
+        Some(triple) => compute_pearl_mask(triple),
+        None => 0b000,
+    }
 }
 
 /// Build the merged Triangle + SPO view. Default entry point.
@@ -57,20 +106,24 @@ pub struct SpoWithGrammar {
 pub fn analyze_with_triangle(text: &str, structure: SentenceStructure) -> SpoWithGrammar {
     let triangle = GrammarTriangle::from_text(text);
     let dist = compute_classification_distance(&structure, &triangle);
+    let footprint = causality_footprint_for(&structure);
     SpoWithGrammar {
         triples: structure,
         causality: triangle.causality,
         nsm_field: triangle.nsm,
         qualia_signature: triangle.qualia,
         classification_distance: dist,
+        causality_footprint: footprint,
     }
 }
 
 /// Feature-off fallback: just carry the SPO with `classification_distance = 0`.
 ///
 /// Available regardless of feature so the parser always has something to
-/// hand the LLM router.
+/// hand the LLM router. The `causality_footprint` is still computed from
+/// the SPO triple — it does not require the Triangle feature.
 pub fn analyze_without_triangle(structure: SentenceStructure) -> SpoWithGrammar {
+    let footprint = causality_footprint_for(&structure);
     SpoWithGrammar {
         triples: structure,
         #[cfg(feature = "grammar-triangle")]
@@ -80,17 +133,22 @@ pub fn analyze_without_triangle(structure: SentenceStructure) -> SpoWithGrammar
         #[cfg(feature = "grammar-triangle")]
         qualia_signature: QualiaField::default(),
         classification_distance: 0.0,
+        causality_footprint: footprint,
     }
 }
 
 /// Normalized Hamming distance between the qualia fingerprint and the
 /// SPO predicate's expected qualia footprint.
 ///
-/// The footprint is derived from the verb's row in the 144-cell table
-/// (currently a placeholder = neutral 0.5 prior, encoded as zero bits
-/// after thresholding). Once D7 `GrammarStyleConfig` surfaces per-style
-/// qualia expectations, `expected_qualia_footprint` will look up the row
-/// by (verb, tense) and return that row's qualia footprint.
+/// The footprint is derived from the Pearl 2³ mask of the sentence's
+/// primary SPO triple. Active SPO planes seed qualia dimensions 0-2:
+///   dim 0 (Agency)    ← Subject plane (bit 2)
+///   dim 1 (Activity)  ← Predicate plane (bit 1)
+///   dim 2 (Affection) ← Object plane (bit 0)
+///
+/// Once D7 `GrammarStyleConfig` surfaces per-style qualia expectations,
+/// `expected_qualia_footprint` will additionally look up the verb's row
+/// by (verb, tense) and merge that row's qualia footprint.
 ///
 /// Returns `[0.0, 1.0]`:
 /// - `0.0` = qualia exactly matches expected footprint (familiar domain).
@@ -134,13 +192,24 @@ fn qualia_to_binary_fingerprint(triangle: &GrammarTriangle) -> Vec<u64> {
 
 /// Expected qualia footprint for a given sentence structure.
 ///
-/// Placeholder: zero-fingerprint = neutral expectation (every dimension
-/// below 0.5). When the 144-cell verb table lands, this looks up the row
-/// by (verb, tense) on `structure.triples[0]` and returns that row's
-/// qualia footprint.
+/// Seeds bits 0-2 from the Pearl 2³ mask of the primary SPO triple:
+///   bit 0 ← Subject plane active (Agency qualia expected >= 0.5)
+///   bit 1 ← Predicate plane active (Activity qualia expected >= 0.5)
+///   bit 2 ← Object plane active (Affection qualia expected >= 0.5)
+///
+/// When the 144-cell verb table lands, this will additionally look up
+/// the row by (verb, tense) on `structure.triples[0]` and merge that
+/// row's higher-dimensional qualia bits.
 #[cfg(feature = "grammar-triangle")]
-fn expected_qualia_footprint(_structure: &SentenceStructure) -> Vec<u64> {
-    vec![0u64; 1]
+fn expected_qualia_footprint(structure: &SentenceStructure) -> Vec<u64> {
+    let pearl = causality_footprint_for(structure);
+    // Map Pearl mask bits (S=bit2, P=bit1, O=bit0) to qualia dimension
+    // bits (dim0=Agency<-S, dim1=Activity<-P, dim2=Affection<-O).
+    let mut packed: u64 = 0;
+    if pearl & 0b100 != 0 { packed |= 1u64 << 0; } // S -> dim 0 (Agency)
+    if pearl & 0b010 != 0 { packed |= 1u64 << 1; } // P -> dim 1 (Activity)
+    if pearl & 0b001 != 0 { packed |= 1u64 << 2; } // O -> dim 2 (Affection)
+    vec![packed]
 }
 
 /// Normalized Hamming distance between two `[u64]` registers.
@@ -164,19 +233,23 @@ fn hamming_normalized(a: &[u64], b: &[u64]) -> f32 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::parser::SentenceStructure;
     use crate::spo::SpoTriple;
 
     fn fixture_structure() -> SentenceStructure {
-        // Build a minimal SentenceStructure via the public parse() entry.
-        // Use parser::parse on an empty token slice to get a default
-        // structure shape, then push one synthetic triple in.
         let empty: Vec<crate::vocabulary::Token> = Vec::new();
         let mut s = crate::parser::parse(&empty);
         s.triples.push(SpoTriple::new(1, 2, 3));
         s
     }
 
+    /// Build a structure with a specific SPO triple.
+    fn fixture_structure_with(subject: u16, predicate: u16, object: u16) -> SentenceStructure {
+        let empty: Vec<crate::vocabulary::Token> = Vec::new();
+        let mut s = crate::parser::parse(&empty);
+        s.triples.push(SpoTriple::new(subject, predicate, object));
+        s
+    }
+
     #[test]
     fn analyze_without_triangle_yields_zero_distance() {
         let s = fixture_structure();
@@ -185,16 +258,115 @@ mod tests {
         assert_eq!(out.triples.triples.len(), 1);
     }
 
+    #[test]
+    fn pearl_mask_transitive_is_spo() {
+        // "dog bites man" -- all three planes active -> 0b111 (Counterfactual)
+        let triple = SpoTriple::new(671, 2943, 95);
+        assert_eq!(compute_pearl_mask(&triple), 0b111);
+    }
+
+    #[test]
+    fn pearl_mask_intransitive_is_sp() {
+        // "dog runs" -- no object -> 0b110 (Confounder Detection / intransitive)
+        let triple = SpoTriple::intransitive(671, 100);
+        assert_eq!(compute_pearl_mask(&triple), 0b110);
+    }
+
+    #[test]
+    fn causality_footprint_transitive_sentence() {
+        // Transitive sentence: S+P+O all present -> 0b111
+        let s = fixture_structure_with(671, 2943, 95);
+        let out = analyze_without_triangle(s);
+        assert_eq!(out.causality_footprint, 0b111);
+    }
+
+    #[test]
+    fn causality_footprint_intransitive_sentence() {
+        // Intransitive sentence: S+P, no O -> 0b110
+        let empty: Vec<crate::vocabulary::Token> = Vec::new();
+        let mut s = crate::parser::parse(&empty);
+        s.triples.push(SpoTriple::intransitive(671, 100));
+        let out = analyze_without_triangle(s);
+        assert_eq!(out.causality_footprint, 0b110);
+    }
+
+    #[test]
+    fn causality_footprint_empty_structure() {
+        // No triples -> 0b000 (aggregate prior)
+        let empty: Vec<crate::vocabulary::Token> = Vec::new();
+        let s = crate::parser::parse(&empty);
+        let out = analyze_without_triangle(s);
+        assert_eq!(out.causality_footprint, 0b000);
+    }
+
+    /// PR-G1 spec test: two sentences with the SAME subject but DIFFERENT
+    /// Pearl masks must produce different triangle outputs.
+    ///
+    /// Sentence A: "dog bites man" -> transitive -> SPO = 0b111 (Counterfactual)
+    /// Sentence B: "dog runs"      -> intransitive -> SP_ = 0b110 (Confounder)
+    ///
+    /// Same subject (671), different Pearl masks -> different causality_footprint.
+    #[test]
+    fn same_subject_different_pearl_masks_yield_different_outputs() {
+        let s_transitive = fixture_structure_with(671, 2943, 95);
+        let s_intransitive = {
+            let empty: Vec<crate::vocabulary::Token> = Vec::new();
+            let mut s = crate::parser::parse(&empty);
+            s.triples.push(SpoTriple::intransitive(671, 100));
+            s
+        };
+
+        let out_a = analyze_without_triangle(s_transitive);
+        let out_b = analyze_without_triangle(s_intransitive);
+
+        // Same subject
+        assert_eq!(
+            out_a.triples.triples[0].subject(),
+            out_b.triples.triples[0].subject(),
+            "both sentences must share the same subject"
+        );
+
+        // Different Pearl masks -> different causality_footprint
+        assert_ne!(
+            out_a.causality_footprint, out_b.causality_footprint,
+            "transitive (0b{:03b}) vs intransitive (0b{:03b}) must differ",
+            out_a.causality_footprint, out_b.causality_footprint
+        );
+
+        // Verify exact values
+        assert_eq!(out_a.causality_footprint, 0b111, "transitive = SPO");
+        assert_eq!(out_b.causality_footprint, 0b110, "intransitive = SP_");
+    }
+
+    /// PR-G1 spec test: two sentences with same Subject, different Predicates
+    /// producing the same Pearl mask structure (both transitive) but encoding
+    /// different causal content.
+    #[test]
+    fn same_subject_same_mask_different_predicates_distinguishable() {
+        // "dog bites man" vs "dog loves man" -- same mask (0b111), different predicate
+        let s_a = fixture_structure_with(671, 2943, 95);  // bites
+        let s_b = fixture_structure_with(671, 500, 95);    // loves
+
+        let out_a = analyze_without_triangle(s_a);
+        let out_b = analyze_without_triangle(s_b);
+
+        // Same Pearl mask (both SPO)
+        assert_eq!(out_a.causality_footprint, out_b.causality_footprint);
+        assert_eq!(out_a.causality_footprint, 0b111);
+
+        // But different predicates -> different triples
+        assert_ne!(
+            out_a.triples.triples[0].predicate(),
+            out_b.triples.triples[0].predicate(),
+        );
+    }
+
     #[cfg(feature = "grammar-triangle")]
     #[test]
     fn classification_distance_in_unit_interval() {
-        // Identical fingerprints → 0.0; orthogonal (all bits flipped)
-        // within the 18 used bits → 18/64 = 0.28125; full-register
-        // orthogonality (every bit flipped) → 1.0.
         assert_eq!(hamming_normalized(&[0u64], &[0u64]), 0.0);
         assert_eq!(hamming_normalized(&[u64::MAX], &[u64::MAX]), 0.0);
         assert!((hamming_normalized(&[0u64], &[u64::MAX]) - 1.0).abs() < 1e-6);
-        // 18 bits set vs. 0 bits → 18/64.
         let eighteen_bits = (1u64 << 18) - 1;
         let d = hamming_normalized(&[eighteen_bits], &[0u64]);
         assert!((d - (18.0 / 64.0)).abs() < 1e-6);
@@ -205,20 +377,15 @@ mod tests {
     fn analyze_with_triangle_stamps_lenses() {
         let s = fixture_structure();
         let out = analyze_with_triangle("the dog runs", s);
-        // Real Hamming over 18-bit qualia footprint vs. zero expectation;
-        // result must be in [0, 1] and not a hardcoded 0.0.
         assert!(out.classification_distance >= 0.0);
         assert!(out.classification_distance <= 1.0);
         assert_eq!(out.triples.triples.len(), 1);
+        assert_ne!(out.causality_footprint, 0);
     }
 
     #[cfg(feature = "grammar-triangle")]
     #[test]
     fn novel_domain_qualia_yields_high_distance() {
-        // High-activation, high-novelty, high-urgency text should pull
-        // multiple qualia dimensions above the 0.5 threshold, producing
-        // a non-zero Hamming distance against the all-zero expected
-        // footprint (placeholder = neutral expectation).
         let s = fixture_structure();
         let out = analyze_with_triangle(
             "Suddenly an unprecedented intense urgent novel surprising explosion!",
@@ -234,13 +401,8 @@ mod tests {
     #[cfg(feature = "grammar-triangle")]
     #[test]
     fn qualia_fingerprint_thresholds_at_half() {
-        // Build a triangle whose qualia coordinates straddle 0.5; the
-        // packed fingerprint must have exactly the bits at-or-above 0.5
-        // set.
-        let triangle = GrammarTriangle::default(); // all coords = 0.5
+        let triangle = GrammarTriangle::default();
         let fp = qualia_to_binary_fingerprint(&triangle);
-        // Default = 0.5 on every dim → every bit set (>= 0.5 threshold),
-        // so packed register == 18 lowest bits set.
         let expected = (1u64 << 18) - 1;
         assert_eq!(fp[0], expected);
     }