This guide will take you from zero to your first working Structured Narrative Object (SNO) in approximately 15 minutes. If you want to understand the “why” behind the code, start with Chapter 1. If you want to prove this works right now, you’re in the right place.

Prerequisites

Before starting, verify you have:

• Python 3.9 or higher (check: python --version or python3 --version)
• 4GB RAM minimum (8GB recommended)
• 2GB free disk space (for models and dependencies)
• Internet connection (for downloading models and packages)

Part 1: Installation (5 minutes)

Step 1: Create Virtual Environment

Creating an isolated environment prevents dependency conflicts with other Python projects.

# Create virtual environment
python -m venv cns-env

# Activate it
# On macOS/Linux:
source cns-env/bin/activate

# On Windows:
cns-env\Scripts\activate

You should see (cns-env) appear in your terminal prompt.

Step 2: Install Core Dependencies

Install the essential libraries needed for CNS 2.0:

# Upgrade pip first
pip install --upgrade pip

# Install core ML/NLP libraries (~1.5GB download)
pip install torch transformers sentence-transformers

# Install supporting libraries
pip install networkx numpy scikit-learn matplotlib

Expected time: 3-5 minutes depending on your internet connection.

Download sizes:

• PyTorch: ~800MB
• Transformers: ~400MB
• Sentence-transformers: ~50MB
• Other libraries: ~250MB

Step 3: Verify Installation

Test that all imports work:

python -c "import torch; import transformers; import sentence_transformers; import networkx; import numpy; print('✓ All imports successful')"

Expected output:

✓ All imports successful

If you see errors:

• ModuleNotFoundError: Rerun the pip install command for that specific package
• ImportError with CUDA: This is fine if you don’t have a GPU, PyTorch will use CPU
• Other errors: See Troubleshooting below

Part 2: Create Your First SNO (5 minutes)

Now let’s create a minimal but complete Structured Narrative Object.

Step 1: Save the Code

Create a new file called first_sno.py and paste this code:

"""
Minimal CNS 2.0 Example: Create Your First SNO
This demonstrates the core concept of a Structured Narrative Object
with semantic embedding capability.
"""

from sentence_transformers import SentenceTransformer
import numpy as np
from datetime import datetime
import uuid

print("=" * 60)
print("CNS 2.0 Quick Start: Creating Your First SNO")
print("=" * 60)

# Step 1: Initialize the embedding model
# This downloads ~400MB on first run - be patient!
print("\n[1/5] Loading embedding model...")
print("      (First run downloads ~400MB, subsequent runs are instant)")
model = SentenceTransformer('all-MiniLM-L6-v2')
print("      ✓ Model loaded successfully")

# Step 2: Define a minimal SNO class
class SimpleSNO:
    """
    A simplified Structured Narrative Object for demonstration.
    The full version (Chapter 2) includes reasoning graphs and evidence sets.
    """
    def __init__(self, hypothesis: str, model):
        self.sno_id = str(uuid.uuid4())[:8]  # Short unique ID
        self.hypothesis = hypothesis
        self.embedding = model.encode(hypothesis)  # 384-dim semantic vector
        self.created_at = datetime.now()

    def __repr__(self):
        return f"SNO({self.sno_id}): {self.hypothesis}"

    def similarity_to(self, other: 'SimpleSNO') -> float:
        """Calculate semantic similarity with another SNO (0 to 1)"""
        dot_product = np.dot(self.embedding, other.embedding)
        norm_a = np.linalg.norm(self.embedding)
        norm_b = np.linalg.norm(other.embedding)
        return dot_product / (norm_a * norm_b)

# Step 3: Create several SNOs
print("\n[2/5] Creating Structured Narrative Objects...")

sno1 = SimpleSNO("Coffee improves programming productivity", model)
print(f"      ✓ Created: {sno1}")

sno2 = SimpleSNO("Caffeine enhances cognitive performance", model)
print(f"      ✓ Created: {sno2}")

sno3 = SimpleSNO("Python is a programming language", model)
print(f"      ✓ Created: {sno3}")

# Step 4: Verify embeddings
print("\n[3/5] Verifying embeddings...")
print(f"      Embedding shape: {sno1.embedding.shape}")
print(f"      Embedding type: {type(sno1.embedding)}")
print(f"      First 5 dimensions: {sno1.embedding[:5]}")
print("      ✓ Embeddings computed successfully")

# Step 5: Calculate semantic similarities
print("\n[4/5] Calculating semantic similarities...")
sim_1_2 = sno1.similarity_to(sno2)
sim_1_3 = sno1.similarity_to(sno3)
sim_2_3 = sno2.similarity_to(sno3)

print(f"      Similarity (Coffee & Caffeine): {sim_1_2:.3f}")
print(f"      Similarity (Coffee & Python):   {sim_1_3:.3f}")
print(f"      Similarity (Caffeine & Python): {sim_2_3:.3f}")
print("      ✓ As expected: Coffee/Caffeine are highly similar!")

# Step 6: Summary
print("\n[5/5] Summary")
print("=" * 60)
print(f"✓ Successfully created {3} Structured Narrative Objects")
print(f"✓ Each SNO has a unique ID, hypothesis, and 384-dim embedding")
print(f"✓ Semantic similarity works: related concepts cluster together")
print("\nWhat you just built:")
print("  • Semantic embeddings for natural language")
print("  • Similarity calculations between narratives")
print("  • Foundation for the full CNS 2.0 architecture")
print("\nNext steps:")
print("  → Chapter 1: Understand the CNS 2.0 architecture")
print("  → Chapter 2: Build the full SNO with reasoning graphs")
print("  → Chapter 3: Add critics for evaluation")
print("=" * 60)

Step 2: Run It

python first_sno.py

Expected Output

============================================================
CNS 2.0 Quick Start: Creating Your First SNO
============================================================

[1/5] Loading embedding model...
      (First run downloads ~400MB, subsequent runs are instant)
      ✓ Model loaded successfully

[2/5] Creating Structured Narrative Objects...
      ✓ Created: SNO(a3b5c7d9): Coffee improves programming productivity
      ✓ Created: SNO(f8e2c1b4): Caffeine enhances cognitive performance
      ✓ Created: SNO(d9f4a7b2): Python is a programming language

[3/5] Verifying embeddings...
      Embedding shape: (384,)
      Embedding type: <class 'numpy.ndarray'>
      First 5 dimensions: [-0.0234  0.0891 -0.0456  0.1234 -0.0678]
      ✓ Embeddings computed successfully

[4/5] Calculating semantic similarities...
      Similarity (Coffee & Caffeine): 0.847
      Similarity (Coffee & Python):   0.123
      Similarity (Caffeine & Python): 0.098
      ✓ As expected: Coffee/Caffeine are highly similar!

[5/5] Summary
============================================================
✓ Successfully created 3 Structured Narrative Objects
✓ Each SNO has a unique ID, hypothesis, and 384-dim embedding
✓ Semantic similarity works: related concepts cluster together

What you just built:
  • Semantic embeddings for natural language
  • Similarity calculations between narratives
  • Foundation for the full CNS 2.0 architecture

Next steps:
  → Chapter 1: Understand the CNS 2.0 architecture
  → Chapter 2: Build the full SNO with reasoning graphs
  → Chapter 3: Add critics for evaluation
============================================================

Part 3: What You Just Built

Congratulations! You’ve created your first Structured Narrative Objects. Here’s what each component does:

The Hypothesis

hypothesis = "Coffee improves programming productivity"

This is the central claim or narrative. In a full CNS system, this would be extracted from research papers, reports, or other knowledge sources.

The Embedding (384-dimensional vector)

embedding = model.encode(hypothesis)  # Shape: (384,)

This converts natural language into a mathematical representation that captures semantic meaning. Similar concepts have similar vectors, enabling computational reasoning about ideas.

Why 384 dimensions? The all-MiniLM-L6-v2 model outputs 384-dimensional vectors. This is a balance between:

• Expressive power: 384 dimensions can capture nuanced semantic relationships
• Computational efficiency: Small enough to compute quickly, even on CPUs

Semantic Similarity

similarity = sno1.similarity_to(sno2)  # 0.847 (highly similar)

By comparing embeddings mathematically (cosine similarity), the system can identify:

• Related narratives (high similarity, like “coffee” and “caffeine”)
• Contradictory narratives (low similarity, opposite meanings)
• Orthogonal narratives (low similarity, unrelated topics)

This is the foundation for the Chirality Score in Chapter 4, which identifies productive conflicts.

What’s Missing (Coming in Later Chapters)

Your SimpleSNO is a starting point. The full StructuredNarrativeObject from Chapter 2 adds:

1. Reasoning Graph (Chapter 2): A directed graph of logical claims and their relationships
2. Evidence Set (Chapter 2): Links to source documents supporting each claim
3. Trust Score (Chapter 3): Quality assessment from the critic pipeline
4. Serialization (Chapter 2): Ability to save/load SNOs to/from disk
5. Schema Versioning (Chapter 2): Handle changes to the SNO structure over time

Experiment: Create Your Own SNO

Modify first_sno.py to create SNOs about your own research topic or area of interest:

# Replace these with your own hypotheses
my_sno1 = SimpleSNO("Your hypothesis here", model)
my_sno2 = SimpleSNO("A related hypothesis", model)
my_sno3 = SimpleSNO("A contradictory hypothesis", model)

# Check similarities
print(f"Similarity 1-2: {my_sno1.similarity_to(my_sno2):.3f}")
print(f"Similarity 1-3: {my_sno1.similarity_to(my_sno3):.3f}")

Try creating SNOs for:

• Competing scientific theories (e.g., “Dark matter explains galaxy rotation” vs “Modified gravity explains galaxy rotation”)
• Political positions
• Business strategies
• Historical interpretations

Share your results in GitHub Discussions with the tag #chapter0!

Troubleshooting

Error: “No module named ’torch'”

Cause: PyTorch not installed Fix:

pip install torch

Error: “No module named ‘sentence_transformers’”

Cause: Sentence-transformers not installed Fix:

pip install sentence-transformers

Error: “CUDA out of memory” or GPU warnings

Cause: Trying to use GPU but insufficient VRAM Fix: Force CPU mode:

model = SentenceTransformer('all-MiniLM-L6-v2', device='cpu')

Model download is stuck or very slow

Causes:

• Firewall blocking HuggingFace servers
• Slow internet connection
• Server temporarily down

Fixes:

1. Check your firewall settings (allow huggingface.co)
2. Try a different network
3. Manually download model from HuggingFace

Import works but model loading fails

Symptom:

OSError: Can't load tokenizer for 'all-MiniLM-L6-v2'

Fix: Clear the cache and re-download:

rm -rf ~/.cache/huggingface/
python first_sno.py

Different similarity scores than expected

This is normal. Embedding models are non-deterministic across different:

• CPU vs GPU
• Different model versions
• Different random seeds

As long as:

• Related concepts have HIGH similarity (>0.7)
• Unrelated concepts have LOW similarity (<0.3)

Your system is working correctly.

Python version error

Symptom:

SyntaxError: invalid syntax (match/case statement, etc.)

Fix: Upgrade Python:

python --version  # Check current version
# If < 3.9, install Python 3.9+ from python.org

Performance Notes

First Run vs Subsequent Runs

First run:

• Downloads model: ~2-3 minutes
• Loads model into memory: ~5 seconds
• Creates embeddings: <1 second

Subsequent runs:

• Model already cached locally
• Loads from disk: ~5 seconds
• Creates embeddings: <1 second

Hardware Requirements

Minimum (CPU only):

• 4GB RAM
• ~30 seconds to load model
• ~0.1 seconds per embedding

Recommended (GPU):

• 8GB RAM + NVIDIA GPU (2GB VRAM)
• ~5 seconds to load model
• ~0.01 seconds per embedding (10x faster)

For large-scale systems:

• See Chapter 6 for production deployment
• See Chapter 5 for distributed processing with Celery

Next Steps

Now that you have a working CNS 2.0 environment and understand the basic concept of Structured Narrative Objects, you’re ready to dive deeper.

Complete Learning Path

Total Time: ~7 hours for complete mastery

Recommended Approach:

• Day 1: Chapters 0-2 (90 min) → Understand SNOs
• Day 2: Chapters 3-4 (105 min) → Add evaluation & synthesis
• Day 3: Chapters 5-7 (240 min) → Production system

What Each Chapter Adds

Chapter 1: Introduction & Architecture

• Understand the theoretical foundation
• Set up complete Python environment
• Initialize embedding models
• Define configuration system

Chapter 2: SNO Foundations

• Build full StructuredNarrativeObject class
• Add reasoning graphs (claims + logical edges)
• Attach evidence sets with DOI citations
• Implement serialization for persistence

Chapter 3: Critic Pipeline

• Implement Grounding Critic (evidence coverage)
• Implement Logic Critic (structural coherence)
• Implement Novelty Critic (innovation vs complexity)
• Build composite trust score
• Enable contextual evaluation

Chapter 4: Synthesis Engine

• Calculate chirality (semantic opposition)
• Calculate evidential entanglement (shared evidence)
• Detect chiral pairs algorithmically
• Visualize narrative space with t-SNE
• Identify productive conflicts

Additional Resources

• Research Roadmap: Long-term vision and advanced research directions
• Case Studies: Real-world applications and experiments
• Tutorials: Step-by-step guides for specific use cases

Note: A GitHub repository with all example code from this guide will be published soon. Check back for updates or contact the maintainers for early access.

Estimated completion time for this chapter: 15-20 minutes

If you completed this chapter successfully, you’ve proven the core concept works. The rest of the guide builds on this foundation.

Navigation

← Previous: Developer’s Guide Home → Next: Chapter 1: Introduction to CNS 2.0

1. What is strictly proven?
2. What is likely true across admissible worlds?
3. What uncertainty remains because of evidence quality, missing records, access conditions, source incentives, or contradiction structure?

The system emits three distinct quantities:

A claim can be probable while still record-contingent. A claim can be strictly proven inside a narrow reference set while its broader interpretation remains low-confidence. A claim can be plausible yet unsuitable for promotion because access-state uncertainty remains material.

Evidence Atoms

An evidence atom is:

where u_i is a stable source identifier, s_i is a span, observation, record, or structured datum, t_i is temporal scope, q_i is source/evidence quality, a_i is access path, and m_i is metadata.

The available evidence set is:

Evidence atoms are immutable within a run. Later corrections or productions create new atoms and preserve the earlier state as part of the audit trail.

Record-Access States

GCTS models missing evidence as structured information. A record-access state is:

The access_k value may be available, inaccessible, sealed, withheld, destroyed, not_generated, unknown, produced_late, partial, contradicted, or unavailable_at_time_t.

This lets the system distinguish:

• absence of evidence;
• evidence of absence;
• inaccessible evidence;
• sealed evidence;
• withheld evidence;
• destroyed evidence;
• not-generated evidence;
• partial or nonresponsive production;
• evidence unavailable at the relevant decision time.

Absence can affect ranking only when record-generation duty, expected observability, ownership/control, collection path, production state, and access state justify that effect.

Claims And Statuses

A claim is:

where p_j is a proposition, frame_j is an argument frame, refs_j is an evidence-reference set, contingencies_j is a record-contingency set, and \sigma_j is one of proven, probable, plausible, record_contingent, conflicted, unsupported, rejected, or insufficient_evidence.

Relations among claims are typed through a relation set R, including supports, refutes, implies, specializes, generalizes, qualifies, depends_on, undercuts, and independent.

Language, Logic, And Access

Let L be the language/concept manifold, T the logic/proof space, and A the access/missingness space. A grounding map extracts proof and access structure:

A rendering map turns structured worlds back into language:

The orthesis is the stable structured state:

The orthesis is the structured state that survives language rendering without losing proof support, likely-truth support, access-state coherence, or uncertainty.

Chirality Residuals

Round-trip chirality measures whether a structured state survives rendering and re-grounding:

A fluent narrative can have high chirality if its logical or access structure falls apart under grounding. In GCTS, chirality is a diagnostic residual:

• graph chirality, based on edge-incidence differences between claim graphs;
• residual tensor chirality, based on unresolved support/refutation mass;
• access chirality, when structured modeling breaks narrative access assumptions;
• rendering chirality, when generated language drops proof or access contingencies.

Chirality does not prove falsity. It identifies mismatch that must be resolved by evidence, rules, access modeling, or explicit uncertainty.

Possible Worlds

A world view is:

where F_k contains accepted facts and likely-truth claims, R_k is a rule subset, Z_k are latent context predicates, \Pi_k are proof traces, A_k are assumptions, M_k is a record-access model, and H_k is an institutional-incentive hypothesis set.

Worlds are scored by energy:

$$ \mathcal{E}(W_k;E,A,I) = \alpha C(W_k) + \beta X(W_k) + \gamma G_w(W_k) + \delta K(W_k)

• \eta S_r(W_k) - \lambda S_e(W_k) $$

where C is contradiction, X is access mismatch, G_w is weak grounding, K is unsupported complexity, S_r is source risk, and S_e is evidence support.

World posterior mass is:

Lower energy worlds are better supported. Contradictions, unsupported complexity, access mismatch, weak grounding, and source risk raise energy; evidence support lowers it.

Likely-Truth Ranking

For a claim c:

The score reports posterior mass across structured worlds. LLM confidence has no role in the runtime truth value.

Strict proof support is emitted separately:

Confidence is a function of grounding quality, world entropy, access-state uncertainty, source risk, and residual conflict:

The system must emit P(c | E,A,I), P0(c | E), and Conf(c) separately.

I am one person with a laptop on the North Shore of Oʻahu, reading public records about institutions that usually encounter each other behind closed doors: financial disclosures, board rosters, donor lists, court filings, legislative testimony, annual reports, and appellate opinions.

The reader’s task is procedural: look at the records, the process gaps, and the places where ordinary institutions failed to produce reviewable answers. The site advances testable institutional questions and avoids a single master explanation.

That distinction controls the method. A public record showing two people on the same board establishes overlap and raises safeguard questions. A sealed audio file can test timing around a reported visual courtroom event, while eyewitness testimony remains the source for the visual claim. A newsroom’s non-publication decision can have structural consequences, even when motive remains unresolved. A platform-indexing anomaly can reduce visibility while leaving technical cause and human intent open.

The editorial method is procedural minimalism: state what happened, identify the record that proves or tests it, present the ordinary explanation first, and separate inference from fact. The institution is the protagonist. The author is the witness, complainant, or stress-test subject.

A firsthand report is stated as a report, not as a courtroom finding and not as a hypothetical. Conditional proof language belongs in the review lane: legal consequences, outside verification, corroboration, falsification, or adjudication. The rule is simple: the author reports what he saw, heard, received, or did; third-party reviewers decide what records, witnesses, and legal standards confirm, contradict, or explain.

The Shortest Path Rule

The volume is controlled by a rule: use the shortest evidentiary path between the reported event and the accountable process. Some files require detail because the accountable process is opaque. Detail should still serve a defined evidentiary function: record, process, decision-maker, deadline, conflict screen, or test. Details outside that function belong in background.

I know a many-part institutional autopsy can look disproportionate from the outside. It is disproportionate in the same way the process is disproportionate: one form letter can close a complaint, while showing why that closure matters may require reconstructing the office, rule, record, deadline, conflict screen, and appeal path that produced it.

I learned why that discipline matters the hard way. In early 2025, I brought a dossier to Honolulu Civil Beat — documented conflicts of interest, public filings, and a broader accountability story. The initial response was interest. What followed was non-publication. There are ordinary explanations for that: limited newsroom resources, legal risk, editorial judgment, verification difficulty, complexity, and competing priorities. The structural effect was still real. A story involving powerful local institutions did not receive public review from the state’s most visible investigative newsroom.

Oʻahu Underground exists to make those review gaps visible. The only currency here is whether the documents cited are real, whether firsthand claims are labeled, whether sealed-record-dependent claims are identified, and whether readers can tell what would confirm, contradict, or explain each assertion. Corrections are invited and will be published for any documented error.

Each investigation places records and events beside each other without asking proximity to carry the whole evidentiary burden. Financial disclosures may sit next to board seats. Board seats may sit next to oversight bodies. Oversight bodies may sit next to courtrooms. Courtrooms may sit next to media non-coverage. Each adjacency triggers a process question: what institution handled the event, what record did it create, what ordinary explanation accounts for the outcome, and what records or witness interviews would test what remains unresolved.

Personal history belongs in a separate lane. The records-first investigations should stay cold: public documents, firsthand observations, sealed-record references, institutional structures, ordinary explanations, and testable questions. The author’s lived chronology explains why certain events were experienced as threatening or connected. The public-record claims stand or fall on their own records, witnesses, timelines, and falsification tests.

The chronology uses abstracted exposure with limited disclosure. The author had public music and civic-technology visibility before these events, and some more sensitive background is intentionally withheld to protect privacy, safety, and third parties. That context explains why reputation and searchability matter. Later coordination, targeting, or restricted-information access would require actor-specific evidence.

Readers should read each article as a procedural file: what record exists, what process acted, what ordinary explanation may apply, and what records would resolve the remaining dispute.

The same rule applies outside the site. A journalist, agency reviewer, attorney, or researcher should evaluate a claim through a single-file audit: one anomaly, one accountable process, one set of records, one list of ordinary explanations, and one short list of steps that would confirm, contradict, or explain the claim.

How to read this site:

• Read each article as its own file.
• Identify the evidence type before accepting the inference.
• Consider ordinary explanations first.
• Use cross-links for source context or navigation only.
• Treat separate portfolios as separate unless a direct evidentiary bridge is identified.

Welcome to Oʻahu Underground.

— E.L.

The foundational research proposal, “CNS 2.0: A Practical Blueprint for Chiral Narrative Synthesis,” opens by identifying a fundamental challenge in artificial intelligence:

“Complex domains—from scientific research to intelligence analysis—require synthesizing incomplete, uncertain, and contradictory information into coherent knowledge. Despite AI’s success in pattern recognition, the cognitive challenge of reconciling conflicting hypotheses remains unsolved.” This guide provides the practical engineering blueprint for **Chiral Narrative Synthesis (CNS) 2.0**, translating that formal paper into a working Python system. We will build, step-by-step, a framework that operationalizes knowledge synthesis by treating hypotheses not as simple text, but as mathematically evaluable data structures.

Who Is This Guide For?

This guide is designed for developers, researchers, and engineers interested in building sophisticated AI systems for knowledge synthesis. It is for you if:

• You are a **Python developer** looking to implement advanced, research-grade AI concepts.
• You are a **researcher** in NLP or AI who wants to move from theory to a practical, working implementation.
• You are an **engineer** tasked with building systems that can reason about and reconcile conflicting data sources. A strong understanding of Python is required, and familiarity with core machine learning concepts (like embeddings) and libraries (like NumPy) will be highly beneficial.

Core Innovations

CNS 2.0 introduces four key advances that we will implement throughout this guide:

1. **Structured Narrative Objects (SNOs):** Rich data structures capturing hypotheses, logical reasoning graphs, evidence sets, and trust scores.
2. **Multi-Component Critic Pipeline:** Transparent evaluation replacing black-box oracles with specialized assessors for grounding, logic, and novelty.
3. **Generative Synthesis Engine:** LLM-powered dialectical reasoning that transcends naive vector averaging.
4. **Evidential Entanglement Metric:** A novel measure identifying narratives that oppose each other while arguing over shared evidence. This guide focuses on the practical implementation of these components. To explore the long-term vision and the advanced research required to push these concepts to their limits, see the **CNS 2.0 Research Roadmap**.

The CNS 2.0 Workflow at a Glance

The system operates in a continuous, cyclical process of ingestion, evaluation, and synthesis. This diagram illustrates how raw information is transformed into structured knowledge, which is then refined through a dialectical process that pits competing narratives against each other to generate novel, more robust insights.

The key stages are:

1. **Narrative Ingestion:** Unstructured text is converted into a formal StructuredNarrativeObject (SNO).
2. **SNO Population:** The system maintains a collection of all known SNOs.
3. **Chiral Pair Selection:** The system finds pairs of SNOs that are highly contradictory (Chirality) and argue over the same evidence (Entanglement).
4. **Generative Synthesis:** The pair is passed to an LLM, which is prompted to perform dialectical reasoning and generate a new SNO that resolves the conflict.
5. **Critic Evaluation:** The new SNO is rigorously evaluated by the critic pipeline. If its Trust Score is high enough, it is added to the population.

Setting Up the CNS 2.0 Environment

**New to CNS 2.0?** If you haven’t completed Chapter 0: Quick Start, we highly recommend starting there. It will get you from zero to your first working SNO in 15 minutes. We will now establish the Python environment for our implementation. We’ll start with installation, then foundational data structures, and finally a centralized configuration class.

Installation Prerequisites

Before writing any code, you need to install the required dependencies. If you completed Chapter 0, you already have these installed. **Required Python version:** 3.9 or higher **Check your Python version:**

python --version # Should show 3.9.x or higher

**Install core dependencies:**

# If you haven't already, create and activate a virtual environment
python -m venv cns-env
source cns-env/bin/activate # Windows: cns-env\Scripts\activate
# Install required packages (~1.5GB download)
pip install --upgrade pip
pip install torch transformers sentence-transformers networkx numpy scikit-learn matplotlib

**Installation breakdown:**

• torch (800MB): PyTorch for neural network operations
• transformers (400MB): Hugging Face transformers library
• sentence-transformers (50MB): Sentence embedding models
• networkx (5MB): Graph data structures for reasoning graphs
• numpy (20MB): Numerical computing
• scikit-learn (30MB): Machine learning utilities (for t-SNE in Chapter 4)
• matplotlib (40MB): Visualization (for Chapter 4) **Verify installation:**

python -c "import torch; import transformers; import sentence\_transformers; import networkx; import numpy; print('✓ All imports successful')"

**Expected output:**

✓ All imports successful

**If you see import errors:**

• Check that your virtual environment is activated
• Rerun the pip install command for the specific package
• See Chapter 0 Troubleshooting for detailed help

Initializing the Embedding Model

Before defining data structures, let’s explicitly show how to initialize the embedding model that will be used throughout the system.

from sentence\_transformers import SentenceTransformer
import torch
# Check device availability (GPU vs CPU)
device = 'cuda' if torch.cuda.is\_available() else 'cpu'
print(f"Using device: {device}")
# Initialize the embedding model
# This downloads ~400MB on first run and caches locally
print("Loading embedding model 'all-MiniLM-L6-v2'...")
embedding\_model = SentenceTransformer('all-MiniLM-L6-v2', device=device)
print(f"✓ Model loaded on {device}")
# Test the model
test\_text = "This is a test hypothesis for CNS 2.0"
test\_embedding = embedding\_model.encode(test\_text)
print(f"✓ Test embedding shape: {test\_embedding.shape}") # Should be (384,)
print(f" First 5 dimensions: {test\_embedding[:5]}")

**Expected output:**

Using device: cpu
Loading embedding model 'all-MiniLM-L6-v2'...
✓ Model loaded on cpu
✓ Test embedding shape: (384,)
First 5 dimensions: [-0.0234 0.0891 -0.0456 0.1234 -0.0678]

**Why ‘all-MiniLM-L6-v2’?** This model provides an excellent balance:

• **Output dimension**: 384 (manageable for computation)
• **Performance**: 68.06 on semantic similarity benchmarks
• **Speed**: ~2,800 sentences/sec on CPU
• **Size**: 80MB model file, 400MB total download **Alternative models:**
• all-mpnet-base-v2: Higher quality (69.57), slower, 768 dims
• all-distilroberta-v1: Faster, slightly lower quality, 768 dims For production systems, you can cache the model to avoid repeated downloads:

# Save model locally
embedding\_model.save('models/embedding\_model')
# Later, load from disk (instant)
embedding\_model = SentenceTransformer('models/embedding\_model')

Foundational Data Structures

Now that we have our embedding model initialized, we can define the foundational data structures: RelationType and EvidenceItem. Using dataclasses ensures our code is readable, type-safe, and self-documenting.

# --- Standard Library Imports ---
from enum import Enum
from typing import Optional
from dataclasses import dataclass, field
import hashlib
class RelationType(Enum):
"""
Enumeration of logical relationship types in reasoning graphs.
Paper Reference: Section 2.1, Definition of Reasoning Graph G = (V, E\_G).
This enum represents the set of possible relationship types R for the
typed edges E\_G ⊆ V × V × R.
"""
SUPPORTS = "supports"
CONTRADICTS = "contradicts"
IMPLIES = "implies"
WEAKENS = "weakens"
EXPLAINS = "explains"
GENERALIZES = "generalizes"
@dataclass
class EvidenceItem:
"""
Represents a single piece of evidence, corresponding to an element e\_i
in the Evidence Set E from the paper. Includes source tracking and a
content hash for integrity.
Paper Reference: Section 2.1, Definition of Evidence Set E = {e\_1, e\_2, ..., e\_n}.
"""
content: str
source\_id: str # e.g., a DOI, URL, or document ID
doc\_hash: Optional[str] = None
confidence: float = 1.0
def \_\_post\_init\_\_(self):
"""
This is a special dataclass method that runs after the object is created.
We use it here to automatically generate a SHA256 hash of the evidence
content. This ensures that every piece of evidence has a unique, verifiable
fingerprint, which is crucial for tracking data provenance and ensuring
the integrity of the Evidence Set E.
"""
if self.doc\_hash is None:
self.doc\_hash = hashlib.sha256(self.content.encode()).hexdigest()[:16]

Core System Imports

Next, we set up the necessary imports. A research-grade implementation relies on semantic understanding, which requires powerful NLP libraries. We include a check to ensure these are installed, allowing the system to run in a simplified, data-structure-only mode if they are missing.

# --- Standard Library Imports ---
import json
from typing import Dict, List, Tuple, Set, Union
from abc import ABC, abstractmethod
# --- Core Scientific Computing and Graph Libraries ---
import numpy as np
import networkx as nx
# --- Machine Learning and NLP Libraries ---
# These are critical for the system's semantic capabilities.
try:
import torch
import transformers
from sentence\_transformers import SentenceTransformer
HAS\_TRANSFORMERS = True
except ImportError:
HAS\_TRANSFORMERS = False
print("WARNING: Key NLP/ML libraries (torch, transformers, sentence-transformers) not found.")
print("CNS 2.0 will run in a simplified, data-structure-only mode.")
print("The following components will NOT function:")
print("- SNO.compute\_hypothesis\_embedding()")
print("- GroundingCritic (requires NLI model)")
print("- NoveltyParsimonyCritic (requires embeddings)")
print("- ChiralPairDetector (requires embeddings)")
if HAS\_TRANSFORMERS:
print("NLP/ML libraries loaded successfully. Full functionality enabled.")
else:
print("Proceeding in simplified mode.")

System Configuration

A robust system requires a centralized place to manage key parameters. The CNSConfig class serves this purpose, directly mapping tunable parameters to concepts in the research proposal.

class CNSConfig:
"""
Configuration class for all CNS 2.0 system parameters.
Centralizing configuration makes the system easier to tune and manage. Each parameter
maps directly to a concept in the formal research proposal.
"""
def \_\_init\_\_(self):
# --- Embedding Model ---
# Paper Reference: Section 2.1, Hypothesis Embedding H ∈ R^d
# This parameter defines 'd', the dimension of the vectors used to represent
# text semantically. It MUST match the output dimension of the chosen
# sentence-transformer model.
# 'all-MiniLM-L6-v2' -> d=384
# 'all-mpnet-base-v2' -> d=768
self.embedding\_dim: int = 384
# --- Critic Pipeline Weights ---
# Paper Reference: Section 2.2, Equation 1: Reward(S) = Σ w\_i \* Score\_i(S)
# These are the weights 'w\_i' that define the system's "values." They control
# the balance between evidential support (grounding), logical coherence, and
# originality. Adjusting these weights allows for context-sensitive evaluation.
self.critic\_weights: Dict[str, float] = {
'grounding': 0.4,
'logic': 0.3,
'novelty': 0.3
}
# --- Novelty-Parsimony Critic Parameters ---
# Paper Reference: Section 2.2, Score\_N formula:
# Score\_N = α \* min\_i ||H - H\_i||₂ - β \* (|E\_G| / |V|)
# These are the 'α' and 'β' hyperparameters in the Novelty-Parsimony score.
self.novelty\_alpha: float = 0.7 # 'α': Scales the reward for novelty (distance from other SNOs).
self.novelty\_beta: float = 0.3 # 'β': Scales the penalty for complexity (graph size).
# --- Synthesis Trigger Thresholds ---
# Paper Reference: Section 3.2, "Synthesis Trigger"
# These thresholds act as a gatekeeper for the expensive synthesis process.
# An SNO pair is only considered for synthesis if BOTH its Chirality and
# Entanglement scores exceed these minimums. This is key to balancing
# the cost of synthesis with the potential for discovery.
self.synthesis\_thresholds: Dict[str, float] = {
'chirality': 0.7,
'entanglement': 0.5
}
# --- Model Identifiers ---
# These are the concrete HuggingFace model identifiers for the abstract
# components described in the paper.
self.models: Dict[str, str] = {
# Used to compute the Hypothesis Embedding 'H' (Section 2.1)
'embedding': "sentence-transformers/all-MiniLM-L6-v2",
# The Natural Language Inference model for the Grounding Critic (Section 2.2)
'nli': "roberta-large-mnli",
# The generative instruction-tuned model for the Synthesis Engine (Section 2.3)
'synthesis': "mistralai/Mistral-7B-Instruct-v0.1"
}
def to\_dict(self) -> Dict:
"""Convert configuration to a dictionary for easy serialization and logging."""
return {
'embedding\_dim': self.embedding\_dim,
'critic\_weights': self.critic\_weights,
'novelty\_alpha': self.novelty\_alpha,
'novelty\_beta': self.novelty\_beta,
'synthesis\_thresholds': self.synthesis\_thresholds,
'models': self.models
}

Initializing the Environment

Finally, we create a global configuration instance to be used throughout the system.

# Create a global configuration instance.
cns\_config = CNSConfig()
print("\nCNS 2.0 Foundation Environment Ready")
print("Current Configuration:")
print(json.dumps(cns\_config.to\_dict(), indent=2))

This enhanced setup provides a more rigorous and clearly annotated foundation, preparing you for the advanced implementations in the chapters to come.

✓ Chapter 1 Checkpoint

Before proceeding to Chapter 2, verify your environment is correctly configured.

Quick Verification Test

Save this as test\_chapter1.py:

"""
Chapter 1 Verification Test
Tests that all foundational components are working correctly.
"""
# Test 1: Verify all imports work
print("Test 1: Checking imports...")
try:
import json
from typing import Dict, List
import numpy as np
import networkx as nx
import torch
import transformers
from sentence\_transformers import SentenceTransformer
print("✓ All imports successful")
except ImportError as e:
print(f"✗ Import failed: {e}")
print(" → Rerun: pip install torch transformers sentence-transformers networkx numpy")
exit(1)
# Test 2: Verify foundational data structures
print("\nTest 2: Testing data structures...")
try:
from enum import Enum
from dataclasses import dataclass
from typing import Optional
import hashlib
class RelationType(Enum):
SUPPORTS = "supports"
CONTRADICTS = "contradicts"
@dataclass
class EvidenceItem:
content: str
source\_id: str
doc\_hash: Optional[str] = None
def \_\_post\_init\_\_(self):
if self.doc\_hash is None:
self.doc\_hash = hashlib.sha256(self.content.encode()).hexdigest()[:16]
# Create test evidence
evidence = EvidenceItem(
content="Test evidence content",
source\_id="test-001"
)
assert evidence.doc\_hash is not None
assert len(evidence.doc\_hash) == 16
print("✓ Data structures working")
except Exception as e:
print(f"✗ Data structure test failed: {e}")
exit(1)
# Test 3: Verify model can be loaded
print("\nTest 3: Testing embedding model...")
try:
print(" Loading model (this may take a moment)...")
model = SentenceTransformer('all-MiniLM-L6-v2')
test\_embedding = model.encode("Test sentence")
assert test\_embedding.shape == (384,), f"Expected shape (384,), got {test\_embedding.shape}"
print(f"✓ Embedding model working (shape: {test\_embedding.shape})")
except Exception as e:
print(f"✗ Model test failed: {e}")
print(" → Check internet connection or firewall settings")
exit(1)
# Test 4: Verify CNSConfig
print("\nTest 4: Testing configuration...")
try:
class CNSConfig:
def \_\_init\_\_(self):
self.embedding\_dim = 384
self.critic\_weights = {'grounding': 0.4, 'logic': 0.3, 'novelty': 0.3}
config = CNSConfig()
assert config.embedding\_dim == 384
assert sum(config.critic\_weights.values()) == 1.0
print("✓ Configuration working")
except Exception as e:
print(f"✗ Configuration test failed: {e}")
exit(1)
# All tests passed
print("\n" + "="\*60)
print("✓ ALL TESTS PASSED - Chapter 1 Complete!")
print("="\*60)
print("\nYou are ready to proceed to Chapter 2: SNO Foundations")
print("→ /guides/building-cns-2.0-developers-guide/chapter-2-sno-foundations/")

Run the verification:

python test\_chapter1.py

Expected Output:

Test 1: Checking imports...
✓ All imports successful
Test 2: Testing data structures...
✓ Data structures working
Test 3: Testing embedding model...
Loading model (this may take a moment)...
✓ Embedding model working (shape: (384,))
Test 4: Testing configuration...
✓ Configuration working
============================================================
✓ ALL TESTS PASSED - Chapter 1 Complete!
============================================================
You are ready to proceed to Chapter 2: SNO Foundations
→ /guides/building-cns-2.0-developers-guide/chapter-2-sno-foundations/

If Tests Fail:

**Import errors:**

• Ensure virtual environment is activated
• Rerun: pip install torch transformers sentence-transformers networkx numpy **Model download fails:**
• Check internet connection
• Check firewall allows huggingface.co
• Try: rm -rf ~/.cache/huggingface/ then rerun **Other errors:**
• See Chapter 0 Troubleshooting
• Post in GitHub Discussions with error details

Navigation

**← Previous:** Chapter 0: Quick Start **→ Next:** Chapter 2: SNO Foundations

Where GCTS Differs From Standard Fact Verification

Core Modules

Evidence Ingestor

Parses the corpus, assigns stable evidence IDs, segments spans, computes source quality priors, and stores provenance, temporal metadata, and access path.

Output: EvidenceAtom[].

Record Access Modeler

Identifies records expected by procedure, role, instrumentation, policy, or ordinary practice. It classifies access states, distinguishes absence of evidence from evidence of absence, and emits record-contingency notes.

Output: RecordAccessState[].

Institutional Incentive Modeler

Models actor roles and evidence-control asymmetries. It estimates incentives to disclose, conceal, delay, narrow, or frame evidence. It adjusts source reliability and missingness likelihood while leaving claim proof to evidence and rules.

Output: InstitutionalIncentiveProfile[].

Claim Proposer

Extracts candidate claims, attaches evidence references, proposes typed relations, preserves extraction confidence, and marks claims that depend on unavailable or expected records.

LLMs may be used here, but proposed claims are untrusted until verified.

Grounding Verifier

Resolves citations, runs claim-evidence entailment, detects invalid references, rejects unsupported strict promotion, and emits grounding reports.

Rule Compiler And Tensor Logic Closure

The compiler converts verified claims, relations, and access states into strict and soft rules. The closure engine computes zero-temperature closure for strict rules, soft closure for hypotheses, proof traces, and contradiction structure.

World Builder And Ranker

The world builder enumerates or searches possible worlds with alternative assumptions, contexts, access states, missingness hypotheses, and institutional-incentive hypotheses. The ranker computes:

• world posterior mass;
• claim likely-truth rankings;
• strict support mass;
• confidence;
• uncertainty decomposition;
• record-contingency notes.

Synthesizer / Renderer

The renderer produces top-K worlds and natural-language reports with proof links, evidence links, access-contingency notes, calibrated hedging, and next record requirements. It must refuse unsupported strict claims.

Data Flow

1. Evidence enters as immutable atoms.
2. Expected records and access states are modeled separately from available evidence.
3. Claims are proposed and linked to evidence, access states, or record contingencies.
4. Verification rejects non-resolving references and low-entailment strict links.
5. Rules compile verified claims, relations, and access states into a proof substrate.
6. Worlds are generated from alternative assumptions, contexts, access models, and missingness hypotheses.
7. Worlds are ranked by evidence support, contradiction energy, parsimony, source reliability, source risk, and access coherence.
8. Claims receive posterior mass, strict proof support, confidence, and status.
9. The renderer outputs ranked alternatives and collapses to a single answer only when uncertainty is low.

Audit Artifacts

Every run emits an input corpus manifest, evidence atom manifest, record-access manifest, institutional-incentive manifest, claim extraction manifest, grounding report, rule compilation manifest, world distribution report, proof trace file, access-contingency report, rendered synthesis, and metrics report.

If any strict gate fails, no strict promoted truth claim is produced. The report uses statuses such as unsupported, record_contingent, conflicted, or insufficient_evidence and lists missing records, access constraints, and next collection actions.

Oahu is a roughly 600-square-mile island where courts, local politics, law enforcement, military and intelligence-adjacent communities, private wealth, media, and civic institutions share limited institutional space. When a reporter’s work moves from music, civic spaces, and technical systems into public-record accountability, overlap with high-voltage local networks is proximity before it is theory. The resulting friction is disclosed here as context and conflict environment, not as proof of a master design.

Its job is context: to show why later institutional failures were treated as significant while preserving the distinction between fact, account, context, and inference. The records-first articles remain the place where individual legal, media, federal, platform, and institutional claims are tested.

Chronology rule: sequence organizes the account; causation is tested only where records or witness testimony connect events. Events appear here because they shaped the author’s reporting history, evidence-preservation choices, and requests for review.

Reader Note: Sequence Is Not Causation

This chronology contains unusual events. Some are documented by public records. Some are firsthand reports. Some are included because they shaped later reporting decisions, evidence-preservation choices, and requests for institutional review.

The page asks event-by-event questions: what was reported, what is documented, what remains interpretation, and what record would test it. The aggregate may look implausible when compressed into a list. The chronology is organized by evidence category for that reason.

Review Boundary

This chronology is a context lane for lived sequence and reporting context. The records-first investigations remain responsible for their own logic. If this page disappeared, the Wilson Loo, Rule 8.3(b), Commission, media, federal, platform, and access-mapping articles would still stand or fall on their own records, witnesses, timelines, ordinary explanations, and public-record limits.

Evidence Categories

Withheld Context

The author had prior contact with law-enforcement systems and withheld background context that made later law-enforcement encounters material to the chronology. Specific biographical details are withheld to protect privacy, source safety, and third parties. Those details are not needed to evaluate the records-first investigations.

The relevance is limited to context. Withheld background does not prove later targeting, coordination, restricted-information access, or institutional motive. The records-first investigations remain independent of biography.

This chronology uses abstracted exposure to protect privacy, source safety, and third parties while giving readers enough context to understand why career-threatening pressure mattered.

What is reported: The author had prior law-enforcement and reputational context before these events.

What is documented: Any specific background fact would require its own public record, official record, or lawful records request before publication.

What remains interpretation: The effect of withheld background, prior law-enforcement contact, or reputational context on later reporting choices.

What would test it: Official records produced through lawful request channels, public records where safely disclosable, and records showing whether any later actor relied on that background.

Information Imbalance in Institutional Encounters

One recurring problem in this chronology is asymmetrical access to information. One side of an institutional interaction may have access to labels, background impressions, sealed material, informal reputation, or technical signals that the affected person cannot see or rebut.

That is a review problem. It can affect intake, credibility screening, and institutional triage without requiring coordination among the people involved.

Process Friction

Procedural friction is the simplest frame for this chronology. The author was a pro se litigant asking slow, specific questions; a citizen demanding paper trails; and an anomaly in systems optimized for speed, quiet disposition, and professional deference.

That framing matters. The risk described in this chronology is ordinary institutional response: procedures can fail to create review when a person creates friction, insists on a record, asks for intake, demands review, or refuses to let a visual event disappear inside an audio-only proceeding.

The 2015-2017 Prosecution

The author reports that the 2015-2017 prosecution began with a tax-office booth encounter he describes as a coercive payment demand under color of tax authority.

According to the author’s account, he appeared in person to address a disputed tax issue. The encounter occurred in a small, camera-less booth. The author states that the tax official demanded payment based on an inflated figure, verbally attacked him, and made clear that leaving the booth without paying would bring worse consequences. The author states that later accounting and trial evidence supported his lower tax position. He denies making the verbal threat alleged by the official.

The author’s position is that the alleged verbal threat language was false and converted an unrecorded tax-office confrontation into a violent-threat narrative. That is a firsthand account and interpretive claim. The precise record support for the tax amount, testimony, and trial handling belongs in any separate prosecution-history file, with transcripts, accounting records, and filings identified directly.

According to the author’s account, the tax official’s threat allegation was presented in the grand-jury process, a charging channel that is secret by design. The author states that he told his attorney he had not made that threat. At trial, according to the author, the alleged threat language was not presented, argued, or tested by any party. The process issue is concrete: a serious allegation can help shape a secret charging record and then disappear from the adversarial trial record where the defense could confront it.

The case ended in a hung jury. The author states that the matter was later expunged.

What is reported: The booth encounter, the coercive payment demand, the verbal attack, the disputed tax figure, the grand-jury threat allegation, the author’s statement to counsel denying the alleged threat, the alleged non-presentation of the threat language at trial, the hung jury, and the stated expungement.

What is documented: Trial, accounting, court, and expungement records if produced or reviewed.

What remains interpretation: Whether the prosecution fairly or unfairly converted the tax-office booth encounter into a violent-threat narrative, and why the alleged threat language was not tested at trial if it appeared in the secret charging record.

What would test it: Trial transcripts, exhibits, tax records, attorney files, indictment materials, grand-jury material where available, motions in limine or evidentiary rulings, jury instructions, verdict forms, and expungement records.

Out-of-State Investigator Encounter

During the same prosecution period, the author reports that an out-of-state law-enforcement investigator was present with James Yuen during Hawaii-related questioning.

According to the author, the investigator referenced knowing the author’s childhood associates later publicly associated with organized-crime prosecutions and used the phrase “colonoscopy.” In the author’s account, “colonoscopy” functioned as crude law-enforcement language for an invasive investigation: a warning that the state could take apart his personal, financial, and social life. The word is included because it was the reported phrase and because it records the coercive content of the encounter.

The author is withholding names, specific background details, and public-record anchors for safety and third-party privacy. The point of this section is to disclose the category of background invoked by law enforcement without publishing private biography.

This account belongs in the chronology lane as context only. Any claim that later Hawaii actors knew of, used, or coordinated around that background requires article-specific evidence.

What is reported: The investigator’s involvement, references to organized-crime-associated childhood associates, and the reported “colonoscopy” statement.

What is documented: Records showing the investigator’s formal role, if obtained.

What remains interpretation: Whether the statement functioned as invasive-investigation pressure or coercive rhetoric.

What would test it: Agency records, interview notes, attorney files, witness testimony, FOIA/Privacy Act responses, and any correspondence showing why the investigator was involved.

Pretrial North Shore/Haleiwa Threat Report

Before the 2017 trial, the author reports stalking, harassment, witness intimidation, a career-destruction threat, and other threats around the North Shore/Haleiwa period.

This includes the author’s account that the warning was framed around a named boundary: “Stay away from Jack,” followed by “or you’ll be whacked.” In the author’s account, that was witness intimidation using conditional phrasing: the condition identified the investigative conduct being controlled. Jack Johnson’s name appears here because, according to the author’s account, it was used as the boundary marker in the coercive instruction.

The author also reports that one specific man, described by the author as a friend of Jack and Kim Johnson, threatened the author’s career if he kept talking about “what happened.” In that statement, “what happened” referred to the stalking, hacking, Hartmann threat, and related reports described in this chronology. The social context around the Johnson/Hartmann environment made reporting and press engagement unusually difficult, according to the author’s account.

Those are serious firsthand reports. The relevant articles should present them as reported events, reports made, institutional responses, and record gaps. Celebrity proximity, family status, wealth, or social capital may be relevant context. Motive, direction, and coordination require separate evidence.

What is reported: Stalking, harassment, the quoted “Stay away from Jack” / “or you’ll be whacked” sequence, and a career-destruction threat by one specific man described as a friend of Jack and Kim Johnson before the 2017 trial.

What is documented: Reports, notes, communications, and third-party statements if obtained or published.

What remains interpretation: Whether social status or network proximity affected non-response or media risk.

What would test it: Police records, attorney files, contemporaneous messages, witness interviews, and newsroom records.

Pretrial Assigned-Counsel Report and Leave-Hawaii Proposal

Before the 2017 trial, according to the author, Audrey L.E. Stanley was assigned counsel during a pending matter before her later judicial service. The author reports that he told Stanley about the quoted witness-intimidation sequence and its investigative context.

The file-review issue is triage. A represented client reported witness intimidation that used a threat of lethal violence to control investigative conduct. The author’s position is that competent counsel should have documented the words, asked who said them, identified the sequence, assessed whether the threat implicated witnesses or testimony, advised the client about reporting and safety options, and preserved any decision not to act.

The author also reports that, during the same pretrial representation, Stanley later communicated that there may be a way to resolve the matter if the author left Hawaiʻi. The author states that he was not given clear written terms, was not told who originated the concept, and was not told whether it was a formal resolution offer, an informal message, a dismissal condition, or something else.

The chronology records the overlap as a representation and record-preservation issue. The reported threat instructed the author to stop crossing an investigative boundary. The later reported resolution concept involved leaving Hawaiʻi. Coordination would require separate evidence. The concrete file-review questions are what assigned counsel documented, what terms were obtained, who originated the proposal, what advice was given, and whether counsel evaluated the overlap between the reported threat and the leave-Hawaiʻi concept.

What is reported: A pretrial witness-intimidation report made to assigned counsel, the quoted threat sequence, the author’s account of counsel’s response gap, and a later reported leave-Hawaiʻi resolution concept during the same representation.

What is documented: Representation files, notes, contact logs, case-management entries, supervisor consultations, opposing-side communications, resolution history, and court records if obtained.

What remains interpretation: Whether counsel’s response met professional obligations, whether the leave-Hawaiʻi concept was formal or informal, and whether the witness-intimidation report and exit concept were related or merely aligned in practical effect.

What would test it: Stanley’s representation file, attorney notes, supervisor records, communications with prosecutors or opposing parties, written offer terms, court minutes, plea or dismissal records, client-advice notes, and any conflict or withdrawal records.

The Mock-Pistol Gesture

The author reports that, during the 2017 trial, prosecutor Vincent Kanemoto argued to the jury that there had been no gun in the case, formed both hands into a mock pistol, pointed the two-handed gesture at all twelve jurors, and then asked the jury to imagine the case as if there had been a gun before urging conviction and resting his case. In the author’s account, Kanemoto said, in substance, “There was no gun in this trial,” made the two-handed mock-pistol gesture toward the jury, then said, “But what if there was? Convict him. I rest my case.”

The legally serious frame is courtroom fairness and prosecutorial misconduct. In the author’s account, the sequence inserted an extra-record danger cue and a hypothetical gun into the jury’s evaluation, visually and verbally associating the defendant with guns, dangerousness, or other inadmissible character themes without proving those themes through admissible evidence. The author’s position is that this was obvious misconduct. Jury-pool contamination remains a separate risk question requiring its own evidence.

The prior investigator encounter is the context the author gives for treating the sequence as a serious extra-record cue. In the author’s account, law enforcement had already introduced an organized-crime frame by referencing childhood associates later publicly associated with organized-crime prosecutions. The courtroom sequence then visually invoked that same frame in front of jurors. Kanemoto’s subjective intent, source of knowledge, and any coordination with the investigator require direct evidence.

According to the author, the trial judge called chambers after the sequence. No visible corrective action followed before the jury was allowed to deliberate. The remaining questions are what was said in chambers, whether the conduct was preserved on the record, whether counsel advised the author about available remedies or professional-responsibility complaints, and whether any motion, objection, curative instruction, mistrial request, appellate issue, or ODC report was pursued.

The author also reports a summer 2019 encounter with Kanemoto at Glazers in Haleiwa. According to the author, he asked Kanemoto why he had formed a two-handed mock pistol, pointed it at all twelve jurors, and asked them to imagine a gun that was not in evidence. Kanemoto denied doing it.

What is reported: A closing-argument sequence in which the author reports that Vincent Kanemoto acknowledged there was no gun in the case, formed both hands into a mock pistol, pointed it at all twelve jurors, asked them to imagine a gun anyway, urged conviction, and rested his case; the judge calling chambers; no visible corrective action before deliberation; and Kanemoto’s reported 2019 denial at Glazers in Haleiwa.

What is documented: Trial records and any chambers or counsel records if obtained.

What remains interpretation: Kanemoto’s subjective intent, how jurors understood the two-handed mock-pistol sequence, whether it invoked the organized-crime frame introduced in the investigator encounter, and what the 2019 denial establishes.

What would test it: Trial transcripts, chambers records if any exist, attorney notes, juror or courtroom witness testimony, motion practice, appellate records, ODC records if any exist, professional-responsibility records, contemporaneous notes or messages about the 2019 Glazers exchange, and witnesses to that exchange.

The Media Non-Coverage Paradox

The absence of media coverage cut both ways.

It deprived the public of visibility into a serious prosecution and reported courtroom misconduct. It also benefited the author personally because, after the hung jury and stated expungement, the absence of press coverage reduced the risk that an indictment without conviction would become the first public fact attached to his name.

That dual effect matters. Ordinary explanations for non-coverage include editorial judgment, resource limits, legal risk, verification difficulty, source concerns, low perceived news value, and story complexity. The practical effect was still real: no public accountability layer formed around the proceeding.

What is reported: No contemporaneous media coverage of the prosecution despite its significance to the author.

What is documented: The absence of known coverage and any available communications with journalists or attorneys.

What remains interpretation: Why coverage did not occur and what effect that had on accountability.

What would test it: Pitch records, newsroom communications, editorial notes, conflict policies, and right-of-reply logs.

Additional Reported Events

Several other reported events belong in this chronology because they shaped the author’s reporting choices. Each remains in its own evidence category.

Spring 2021 FBI/HPD sequence: The author reports an FBI online report and later in-person FBI contact in Mokuleia regarding prior reported threats, witness-tampering concerns, and law-enforcement integrity context. The author also reports that an HPD officer was later “cycled out” or replaced, and that the following day two HPD cruisers responded to his truck at Malama Market in Haleiwa and issued parking citations in a manner the author experienced as intimidation. The chronology treats this as a firsthand account and record-locator issue; whether the officer change or cruiser response was routine, retaliatory, intimidating, coincidental, or otherwise connected would require dispatch, assignment, citation, bodycam, in-car video, and federal-intake records.

2021-2022 HPD report sequence involving the redacted witness: The author reports that after ending a brief work relationship and social acquaintance with a redacted witness in September 2021, he later contacted that person by text and email to collect a small work debt, then wrote off the debt and stated he would avoid further in-person contact after a reported Starbucks assault. The author states that the assault was initially reported to HPD as occurring in November 2021, that HPD investigated and referred the matter to prosecutors with that date in the record, and that after the related proceedings ended he located a contemporaneous photo and now dates the incident to January 2022. The author reports a sequence of reported incidents involving the same redacted witness: vehicle intimidation at Malama Marketplace in December 2021; the corrected January 2022 Starbucks assault date; a vehicle threat outside Breakers at North Shore Marketplace in June 2022; bicycle/vehicle intimidation on Waialua Beach Road in July 2022; a July 24, 2022 cease-and-desist email; a September 12, 2022 PaaLaa Road report in which the author reports that while he was walking east on the left side of PaaLaa Road, the same witness approached from behind while driving east, accelerated hard with the engine redlining according to the author’s account, crossed the double yellow line toward him in a stick-shift vehicle the author recognized from prior experience riding in and driving it, narrowly missed him, returned to the travel lane, and raced off, identified as HPD report 22-353421; a September 16, 2022 TRO submission at Wahiawa Police Station; September 19-22, 2022 reported harassment and TRO-service confusion, including HPD report 22-365099; HPD safety advice to avoid PaaLaa Road; and the author’s position that in-person encounters were coincidental while he was on foot or bicycle on main roads in Haleiwa. The record question is what HPD reports, CAD logs, dispatch audio, bodycam, in-car video, TRO-service records, emails, photos, prosecutor referral records, witness accounts, and any closure or declination notes show about intake, response, service, investigation, referral, and non-response.

Federal-buddy statement: The author reports overhearing a reference to a “federal buddy.” The meaning is unknown. It may have been bragging, exaggeration, intimidation, a misunderstood phrase, or a real reference to a relationship. The record category is reported statement and possible witness question.

Officer Brandt intake obstruction: The author reports that Officer Brandt obstructed another HPD officer from fielding the author’s report about the quoted threat. The record category is a reported intake event involving a named officer. The review question is whether a report was attempted, whether another officer was prepared to receive it, what Brandt did, and what records were created or omitted.

HPD allowed-threat statement: The author reports that an HPD officer made a statement to him using language indicating that Jack Johnson’s inner circle was allowed to make murder threats. The claim is limited to the reported statement made to the author; authorization by any specific person would require separate evidence. A more ordinary explanation may be credibility discounting: once a complainant is labeled unreliable, difficult, “known,” or entangled in a civil dispute, officers may use that label to rationalize non-response. That would still be a serious process failure if it caused a reported threat to be ignored.

What is reported: The Spring 2021 FBI/HPD sequence, the 2021-2022 HPD report sequence involving the redacted witness, the “federal buddy” statement, the Officer Brandt intake-obstruction account, and the HPD allowed-threat statement.

What is documented: HPD reports, dispatch notes, CAD logs, bodycam or surveillance records, TRO-service records, emails, messages, witnesses, public profiles, or contemporaneous notes if obtained.

What remains interpretation: Whether any of these events reflected intimidation, bias, bravado, misunderstanding, ordinary social conflict, ordinary report triage, service-process limits, or another motive.

What would test it: Witness interviews, call logs, CAD logs, bodycam, dispatch records, internal-affairs records, TRO-service records, date/time/location evidence, messages, video, report-intake records, officer notes, emails, photos, report files, and statements by the people involved.

Platform Context Kept Out of the Core Claims

The author reports platform recommendations and surfaced content that were temporally and thematically aligned with dispute-specific topics, including LSD-related material after proceedings where LSD was central. The observed alignment is the claim; mechanism remains unresolved and requires platform records.

The current record supports a firsthand observation of aligned recommendation patterns and preserved technical artifacts. Establishing cause, human selection, sealed-record access, or targeting would require platform logs or comparable technical records. Ordinary explanations include recommender behavior, account history, engagement patterns, keyword context, timing coincidence, generic content saturation, third-party engagement, ad-category inference, and abuse-reporting dynamics.

What is reported: The author saw platform recommendations and surfaced content that were temporally and thematically aligned with dispute-specific topics.

What is documented: Screenshots, logs, ad-library records, platform data exports, or support responses if obtained.

What remains interpretation: Whether the timing reflected ordinary personalization, coincidence, misuse by third parties, a platform bug, or another mechanism.

What would test it: Platform logs, ad-delivery records, data exports, complaint history, ad-library entries, and reproducible technical analysis.

The 2022 Loo Proceeding

The December 2, 2022 proceeding is treated in separate records-first articles because it has its own evidence track:

• the author asked a specific question about LSD / lysergic acid diethylamide;
• the author states that a sealed text exhibit supplied the predicate for the question;
• the author states that Judge Wilson M.N. Loo gave a nonverbal “no” signal before the witness answered;
• the author states that Bosko Petricevic was looking at Judge Loo during the sequence;
• the witness denied furnishing LSD;
• the author immediately attempted to place the judge’s conduct on the record;
• Judge Loo cut him off;
• the sealed audio can test the timing around the question, answer, attempted record statement, and cutoff, though it cannot capture the visual signal itself.

The prior prosecution, threats, and career-destruction warning explain why the author treated the 2022 sequence as serious. The courtroom event stands or falls on testimony, sealed audio timing, the text exhibit, line of sight, witness interviews, and professional-responsibility review.

What is reported: The author reports the visual signal, Petricevic’s line of sight, the denial, the attempted record statement, and the cutoff.

What is documented: The sealed audio sequence and sealed court exhibit if reviewed by an authorized person.

What remains interpretation: What each participant saw, understood, or intended, and what an authorized reviewer would conclude after testing the author’s report against the sealed audio, court file, line of sight, and witness testimony.

What would test it: Sealed audio, court exhibits, courtroom layout, witness testimony, line-of-sight reconstruction, and attorney or judicial-conduct records.

Firsthand Report Chronology

This table is a triage chart: event, source category, record status, and review path.

Scope Boundaries

This chronology makes one kind of claim: the author reports a sequence of prosecution, reported intimidation, reported courtroom symbolism, institutional non-response, sealed-record problems, and career-threatening pressure that requires context to evaluate.

It separates that context from article-specific evidentiary claims. Coordination by a single group, knowledge among named people, and causal significance of withheld background, employment overlap, geographic proximity, media silence, or celebrity proximity require records or testimony beyond the chronology itself.

The author’s interpretation is part of the account. Records are needed to test it.

What Would Test It

The useful questions are ordinary:

• What do the 2015-2017 grand-jury materials where available, indictment materials, trial transcripts, exhibits, attorney files, and accounting records show?
• Was an out-of-state law-enforcement investigator formally involved, and what records document the role?
• What record exists of the reported “colonoscopy” statement?
• What police, attorney, or agency reports exist for the Hartmann threat and related pressure?
• What does Audrey L.E. Stanley’s representation file show about the pretrial quoted threat report, the leave-Hawaiʻi concept, written terms, advice, preservation, and any supervisor consultation?
• What advice did assigned counsel give about intimidation, reporting, safety, preservation, or legal remedies?
• What did the 2017 trial judge do after the reported two-handed mock-pistol sequence, and what was preserved?
• What witnesses, notes, messages, or date/location records exist for the summer 2019 Glazers/Haleiwa exchange with Kanemoto?
• What FBI intake or agent notes, online-report records, correspondence, case or referral records, HPD CAD/dispatch logs, event numbers, unit IDs, citation records, bodycam or in-car video, or FOIA/Privacy Act responses exist for the Spring 2021 federal contact and the reported Malama Market HPD response?
• What HPD reports, TRO-service records, dispatch/CAD logs, 911 audio, bodycam, in-car video, surveillance video, emails, photos, witness records, report files, or closure notes exist for the 2021-2022 reported assault, vehicle-threat, harassment, TRO-service, and non-response sequence involving the redacted witness, including HPD reports 22-353421 and 22-365099?
• What bodycam, dispatch, CAD, report-intake, officer-note, or internal-affairs records exist for the reported Officer Brandt intake event and the reported HPD statements?
• What platform data exports, ad-delivery records, support tickets, or reproducible tests exist for the reported recommendation sequences?
• What does the sealed December 2, 2022 audio show about timing?
• What does the sealed text exhibit show about the LSD question predicate?
• What did the witness and Petricevic see, hear, and understand?

This chronology shows why the questions exist and identifies the records-first investigations that should test them.

Procedural note, May 15, 2026: This article documents non-coverage, public-record overlaps, and firsthand reports of threats. Ordinary explanations for non-coverage come first: limited newsroom resources, legal risk, verification burden, source risk, complexity, lack of perceived news value, editorial priorities, and the fact that civil injunction proceedings rarely become major news. The residual question is what structural effect the non-coverage produced and whether conflicts were handled through recusal, firewall, or documented editorial review. The current public record contains no order, instruction, or agreement not to cover the story. Any claim that a donor, board member, musician, family member, or newsroom manager ordered coverage stopped requires separate evidence.

I. The Interest

In early 2025, I presented Honolulu Civil Beat with a dossier documenting structural conflicts of interest within Hawaiʻi’s judiciary. The materials included:

• Judge Wilson M.N. Loo’s financial disclosures showing >$1M in K.J.L. Associates plus additional bank and real-estate interests (Hawaii National Bancshares, Loyalty Enterprises)
• Documentation that Wilson Loo served as a Commissioner on the Hawaiʻi Supreme Court Commission on Judicial Conduct (Exhibit A)—the body that investigates complaints against judges—while his spouse (listed in Exhibit A) is part of the Luke family network that includes Hawaii National Bank and related Luke entities
• Evidence of the 90-day jurisdictional rule that closed ethics review (as stated to me in writing by the Commission in response to my complaint, date on file)
• Specific reports regarding witness coaching during a December 2, 2022 injunction hearing

The response was initially positive. The documents were reviewed. I was told the conflicts warranted investigation.

Then: non-coverage. No follow-up calls. No editorial decisions communicated. The story did not become a published article.

The absence of coverage cut both ways. It reduced public accountability for the reports and process gaps described in this series. It also limited reputational harm to the author where older proceedings ended without conviction and later expungement is part of the author’s account. Ordinary explanations include news judgment, legal caution, under-resourcing, editorial uncertainty, social friction, or some combination of those forces. The structural issue is the same either way: public coverage did not become an accountability layer.

Exhibits

• A. Wilson Loo financial disclosures
• B. Civil Beat supporters list
• C. Ryan Ozawa employment history
• D. Punahou trustee archive – Omidyar since 2007
• E. Punahou Bulletin – Warren Luke retirement 2019
• F. Punahou Bulletin – Omidyar stepped down 2021
• G. Kōkua Hawaiʻi Foundation team & board page
• H. Cathy Luke – Hawaiʻi Leadership Forum board
• I. HLF is part of The Omidyar Group / funded by Omidyar ʻOhana Fund

II. The Structural Explanation

The ordinary explanations for non-coverage remain primary: editors may have judged the story too difficult to verify, too legally risky, too resource-intensive, too low-value for the audience, or too dependent on sealed and firsthand material. The structural issue that remains after those explanations is whether Civil Beat’s funding, board, donor, and personnel overlaps created conflict-management questions around Luke-Loo coverage.

The Personnel Bridge

Ryan Ozawa, a Civil Beat contributor, previously served as Information Security Officer for Hawaii National Bank—the Luke family’s institution (see Exhibit C). The ISO role involves securing client data, internal communications, and financial records. Ozawa moved from an Information Security Officer role at the Luke family’s bank to the newsroom tasked with oversight.

The relevant record is topology: donor, board, personnel, and prior-employer relationships that may make close newsroom scrutiny professionally and socially difficult.

The Donor Relationship

Civil Beat lists Warren, Karen, Theresa, and Corey Luke under “Individual Donors – $1-$499” (Exhibit B). The amounts are modest. The donor relationship is public-record context for conflict-screening review.

Warren Luke is Chairman and CEO of Hawaii National Bank. He is Judge Wilson Loo’s brother-in-law. Wilson Loo served as a Commissioner on the Judicial Conduct Commission (Exhibit A) while his spouse (listed in Exhibit A) is part of the Luke family network that includes Hawaii National Bank and related Luke entities.

The Boardroom Overlap

Pierre Omidyar has been a Punahou trustee since 2007. Warren Luke served on the board since 1988 and chaired 2008–2009; he retired at the end of the 2018–2019 school year. Their overlap ran twelve years (2007–2019), ending with Luke’s retirement (Exhibits D/E); Omidyar stepped down later in 2021 (Exhibit F). Warren Luke’s daughter Cathy Luke serves on the board of Hawaiʻi Leadership Forum (Exhibit H)—an organization that is part of The Omidyar Group and receives funding from the Omidyar ʻOhana Fund (Exhibit I).

Both families’ names appear on permanent Punahou campus facilities (Omidyar K-1 Neighborhood; Luke Center for Public Service) (Exhibits D/E).

Coverage Record

Civil Beat maintains Wilson Loo’s financial disclosures in its own database. It has conducted investigations into judicial conflicts of interest in other Hawaiʻi cases. It has published no substantive investigation into the Luke-Loo network’s documented conflicts. It already possesses many of the raw ingredients for the story; the reason coverage has not followed remains an inference.

Structural friction can arise from documented donor, board, and personnel overlaps that create a conflict environment. Ordinary constraints include social cost, legal risk, editorial uncertainty, verification burden, limited newsroom resources, and the fact that civil injunction proceedings rarely become major news.

III. The Ecosystem Adjacency

The dossier raised questions beyond a single judge. It concerned institutions that convert financial, cultural, philanthropic, and civic standing into public legitimacy.

The Luke Center for Public Service at Punahou is a node linking Luke philanthropy to the school’s civic infrastructure. Heather Williams, now a staff member at Kōkua Hawaiʻi Foundation, “played a pivotal role in the creation of Punahou School’s innovative Luke Center for Public Service.” She is a personnel bridge from Luke Center creation to the Kōkua ecosystem.

That ecosystem overlaps with North Shore conservation networks. Kōkua’s own board bios list NSCLT roles for both Kawika Kahiapo (board) and Blake McElheny (advisor) (see Exhibit G, Kahiapo and McElheny bios). Evidence category: published affiliations.

Investigating Wilson Loo would mean scrutinizing the Luke network’s institutions and the civic ecosystem around them — including Kōkua Hawaiʻi Foundation, co-founded by Jack and Kim Johnson. Celebrity proximity is included because it identifies the civic ecosystem that could make ordinary newsroom choices socially and legally more difficult. Newsroom motive, family direction, and coordinated action require separate evidence.

The family relationship is included to explain social-capital and coverage-risk context. It does not allege that Jack Johnson, Kim Johnson, Pete Johnson, or any related person directed a threat, newsroom silence, or institutional response.

IV. What Followed

The newsroom non-coverage came later. The author reports earlier private threats and intimidation. Those firsthand reports establish the author’s claimed context and sequence; newsroom motive remains a separate public-record question.

The Hartmann Meeting

Gene and Rita Hartmann are not public figures. Their significance is specific: they are the parents of Pete Johnson’s wife. Pete is Jack Johnson’s brother.

According to my firsthand account, Eugene Hartmann told me to discontinue my investigation into the crimes I suspected. Rita Hartmann then said, “or you’ll be whacked.” The communication was direct, extra-legal, and delivered outside counsel channels. It was reported; no communicated investigation followed.

The Blackmail

A close associate of Kim Johnson — connected to Hawaiʻi’s tech and funding ecosystem — delivered a direct threat, according to my firsthand account: if I continued to talk about what happened, my career would be destroyed. “What happened” meant the stalking, hacking, and Hartmann threat reported in my prior reports.

The reported message was not subtle: continued disclosure would bring professional harm.

V. The Verification Problem

These reports present a specific evidence problem.

What is documented:

• Board memberships, donor lists, corporate filings, financial disclosures, employment histories—all public record
• The nodes and edges I describe are published fact; the implications are my analysis

What is firsthand testimony:

• The Hartmann threat occurred in a private meeting. I have contemporaneous documentation—notes, communications to third parties immediately after—but no recording.
• The blackmail was delivered directly. It referenced “what happened”—the stalking, the hacking, the Hartmann threat—and made clear the professional consequences of continued disclosure.

These events are firsthand reports. I am the witness.

The cause of the Civil Beat silence is not established by the records available here. The documentable facts are the structural conflicts that existed, the ordinary editorial explanations that may apply, and the coverage gap that followed.

Coverage gaps can form with little retrievable record. Accountability mechanisms leave little retrievable record. Ordinary legal caution, aligned class interests, verification burdens, and a high cost for breaking politeness may be enough.

VI. What Can Be Verified

• Wilson Loo’s financial disclosures are public record
• The Luke family’s corporate holdings are documented in SEC filings and state records
• Board memberships are published by the organizations themselves
• Kōkua’s board bios state that Kawika Kahiapo sits on NSCLT’s board and Blake McElheny advises NSCLT (Exhibit G)
• Civil Beat’s donor list is self-reported
• Ryan Ozawa’s employment history is documented
• Kōkua Hawaiʻi Foundation’s website states that staff member Heather Williams played a pivotal role in creating Punahou’s Luke Center for Public Service
• The Hartmanns’ family relationship to the Johnsons is corroborable through standard public-record methods (I’m not publishing those records here)

I am not asking anyone to take my word for what happened in private meetings. I am asking them to examine the documented structure and evaluate whether it creates a predictable conflict environment around the coverage gap.

Subsequent Method Check

Subsequent public reporting on the Sylvia Luke / $35,000 paper-bag matter showed that the same broad governance environment contained public-interest questions with news value. That later reporting does not prove why any earlier pitch was not published, does not prove newsroom motive, and does not prove coordination by any person named here.

The limited point is methodological. Public-record topology can identify coverage-risk and conflict-screening questions before the relevant institution publicly explains how it handled them. The records-first follow-up is The Paper Bag and the Architecture of Self-Investigation.

VII. Conclusion

The available record leaves two issues unresolved: whether Civil Beat dropped this story because editors found it false, and whether anyone directed non-publication. Ordinary explanations come first: resource limits, verification difficulty, source concerns, editorial judgment, and legal risk may explain non-publication. Those explanations may exist outside the public record.

The documented topology points to one additional review surface: investigating Wilson Loo would require investigating the Luke family and related institutional beneficiaries, some of whom overlap with donor, board, or civic networks adjacent to the newsroom. That overlap is not proof of newsroom motive. It is a conflict-screening question.

The coverage gap is a conflict-environment analysis. The same overlapping civic relationships that allow Hawaiʻi’s elite to resolve conflicts privately can also make public reporting less likely, even when no one gives an order.

Limits of the Public Record

This article documents public-record overlaps, a coverage gap, firsthand reports of threats, ordinary newsroom explanations, and the author’s inference that the overlaps create structural friction for investigative coverage.

The limits are important: the current public record leaves unresolved whether anyone directed non-publication, whether donors controlled editorial decisions, whether celebrity or family proximity materially contributed to non-coverage, or whether any person coordinated retaliation.

What Would Falsify This

The structural thesis would be narrowed by production of substantive editorial records showing the story was investigated and declined on the merits, public correction of any documented relationship, evidence of recusal or firewall procedures around Luke-related coverage, or published reporting that addresses the same public-record conflicts in comparable depth.

The next procedural step is direct: a newsroom, ombudsman, or independent reviewer could examine pitch records, conflict-screening notes, right-of-reply logs, recusal records, and editorial correspondence. Those records would separate ordinary editorial judgment from conflict-management gaps.

At the heart of CNS 2.0 is the Structured Narrative Object (SNO). To understand its importance, we must first recognize the limitations of simpler representations. Traditional vector embeddings, while powerful for capturing semantic similarity, are insufficient for dialectical reasoning because they discard three critical elements:

1. Logical Structure: The “how” and “why” behind a conclusion.
2. Evidential Grounding: The link between a claim and the data that supports it.
3. Evaluated Quality: A measure of the narrative’s trustworthiness.

SNOs are designed to capture this richness, transforming a narrative from an opaque string of text into a transparent, structured, and computationally evaluable object.

The Formal Definition

An SNO is formally defined in the research proposal as a 4-tuple. This mathematical precision is what allows the rest of the system to operate on it in a principled way.

From the Paper: Definition 2.1 (Structured Narrative Object) An SNO is a 4-tuple $\mathcal{S} = (H, G, \mathcal{E}, T)$ where:

• Hypothesis Embedding $H \in \mathbb{R}^d$: A $d$-dimensional dense vector encoding the narrative’s central claim, enabling geometric similarity computations while preserving semantic content.
• Reasoning Graph $G = (V, E_G)$: A directed acyclic graph with vertices $V$ representing sub-claims and edges $E_G$ encoding typed logical relationships.
• Evidence Set $\mathcal{E} = \{e_1, e_2, \ldots, e_n\}$: Pointers to grounding data sources, establishing verifiable connections to primary sources.
• Trust Score $T \in [0, 1]$: A derived confidence measure computed by the critic pipeline, not an intrinsic property of the narrative.

The Role of Each Component

It is crucial to understand that H, G, E, and T are not just data fields; they are the specific inputs and outputs for the different functional parts of the CNS 2.0 system.

• H (Hypothesis Embedding): The SNO’s “Address” in Conceptual Space.

  • Purpose: To represent the semantic essence of the SNO’s central claim in a mathematical form.
  • Used By: The RelationalMetrics (Chapter 4) to calculate the Chirality Score (i.e., how much do two SNOs disagree?) and the NoveltyParsimonyCritic (Chapter 3) to measure the distance to other SNOs. It gives the SNO a “location” in a high-dimensional map of ideas, making conceptual relationships measurable.

• G (Reasoning Graph): The SNO’s Internal Logic.

  • Purpose: To explicitly encode the structure of the argument—how different claims support, contradict, or imply one another.
  • Used By: The LogicCritic (Chapter 3), which analyzes G’s structure (e.g., for orphaned claims or circular reasoning) to assess the argument’s coherence. This moves beyond what is being claimed to how the claim is justified.

• ℰ (Evidence Set): The SNO’s Connection to Reality.

  • Purpose: To ground the abstract claims of the narrative in verifiable, external data, preventing hallucination and providing a basis for factual verification.
  • Used By: The GroundingCritic (Chapter 3), which checks the claims in G against the evidence in E to see if they are factually supported. This ensures the narrative is not just logically sound but also empirically tethered.

• T (Trust Score): The SNO’s Evaluated Quality.

  • Purpose: To represent the final, holistic quality score of the SNO after being evaluated by the critic pipeline. It is an output of the system’s judgment, not an intrinsic property of the narrative itself.
  • Used By: The RelationalMetrics (Chapter 4), where it weights the Chirality Score, ensuring that conflicts between two high-trust SNOs are prioritized. It’s also the final metric for the “survival of the fittest” selection mechanism that determines which narratives persist in the population.

Understanding this functional separation is key. We are not just creating a data class; we are instantiating a formal mathematical object where each component serves a distinct and vital purpose in the system’s workflow.

Core SNO Implementation

The following code block contains the complete StructuredNarrativeObject class. The comments have been enhanced to explicitly map the Python implementation to the formal definition from the paper.

"""
Structured Narrative Objects (SNO) Implementation
===============================================
The foundational data structure for CNS 2.0, now with enhanced
comments and robust serialization.
"""

import numpy as np
import networkx as nx
from typing import Dict, List, Set, Optional, Any
from dataclasses import dataclass, field, asdict
from datetime import datetime
import uuid
import json
import logging

# Configure basic logging for warnings and errors
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Assume RelationType and EvidenceItem are defined as in Chapter 1.

@dataclass
class ReasoningEdge:
    """
    Represents a typed logical relationship (an edge E_G) in the reasoning graph G.
    Each edge connects two claims and has a specific type (e.g., SUPPORTS)
    and strength.
    """
    source: str
    target: str
    relation_type: RelationType
    strength: float = 1.0
    metadata: Dict[str, Any] = field(default_factory=dict)

@dataclass
class ClaimNode:
    """
    Represents a claim or sub-claim (a vertex V) in the reasoning graph G.
    Each node contains the text of the claim and can hold its own embedding
    for more granular analysis.
    """
    claim_id: str
    content: str
    claim_type: str = "assertion"
    # repr=False prevents the large embedding array from cluttering log outputs.
    embedding: Optional[np.ndarray] = field(default=None, repr=False)
    metadata: Dict[str, Any] = field(default_factory=dict)

class StructuredNarrativeObject:
    """
    The complete Python implementation of a Structured Narrative Object (SNO).
    This class is the practical instantiation of the mathematical 4-tuple S = (H, G, E, T)
    from the CNS 2.0 research proposal.
    """
    
    def __init__(self, 
                 central_hypothesis: str,
                 sno_id: Optional[str] = None,
                 created_at: Optional[datetime] = None,
                 metadata: Optional[Dict] = None,
                 sno_schema_version: int = 2):

        self.sno_id = sno_id or str(uuid.uuid4())
        self.central_hypothesis = central_hypothesis
        self.created_at = created_at or datetime.now()
        
        # --- SNO Components (The Formal 4-Tuple) ---

        # H: Hypothesis Embedding (Optional[np.ndarray])
        # A dense vector representing the central hypothesis.
        self.hypothesis_embedding: Optional[np.ndarray] = None
        
        # G: Reasoning Graph (nx.DiGraph)
        # A NetworkX DiGraph storing claims (nodes) and their relationships (edges).
        self.reasoning_graph = nx.DiGraph()
        
        # E: Evidence Set (Set[EvidenceItem])
        # A set of EvidenceItem objects grounding the narrative in verifiable data.
        self.evidence_set: Set[EvidenceItem] = set()
        
        # T: Trust Score (Optional[float])
        # A score from [0, 1] computed by the Critic Pipeline. Initially None.
        self.trust_score: Optional[float] = None

        # --- End SNO Components ---
        
        self.metadata: Dict[str, Any] = metadata or {}
        self.sno_schema_version = sno_schema_version
        
        # The root node of the graph G is the central hypothesis itself.
        self._add_root_claim()
    
    def _add_root_claim(self):
        """Internal method to create the root node of the graph from the central hypothesis."""
        root_node = ClaimNode(
            claim_id="root",
            content=self.central_hypothesis,
            claim_type="central_hypothesis"
        )
        self.reasoning_graph.add_node("root", claim=root_node)
    
    def add_claim(self, claim_content: str, claim_id: Optional[str] = None, claim_type: str = "assertion") -> str:
        """Adds a new claim (a vertex V) to the reasoning graph G."""
        if claim_id is None:
            claim_id = f"claim_{len(self.reasoning_graph.nodes)}"
        
        claim_node = ClaimNode(claim_id=claim_id, content=claim_content, claim_type=claim_type)
        self.reasoning_graph.add_node(claim_id, claim=claim_node)
        return claim_id
    
    def add_reasoning_edge(self, source_claim_id: str, target_claim_id: str, relation_type: RelationType, strength: float = 1.0) -> bool:
        """
        Adds a new reasoning edge (an edge E_G) between claims in the graph G.

        Paper Reference: Section 2.1. This method enforces the "directed acyclic graph"
        (DAG) property required by the SNO formal definition by checking for cycles.
        This prevents circular logic within an argument.
        """
        if (source_claim_id not in self.reasoning_graph.nodes or target_claim_id not in self.reasoning_graph.nodes):
            logging.warning(f"Attempted to create edge with non-existent node: {source_claim_id} or {target_claim_id}")
            return False
        
        # This check enforces the "acyclic" property of the Reasoning Graph G.
        # If a path already exists from the target back to the source, adding an edge
        # from source to target would create a logical loop (a cycle).
        if nx.has_path(self.reasoning_graph, target_claim_id, source_claim_id):
            logging.error(f"Failed to add edge: Adding edge from {source_claim_id} to {target_claim_id} would create a cycle.")
            raise ValueError(f"Adding edge from {source_claim_id} to {target_claim_id} would create a cycle.")
        
        edge = ReasoningEdge(source=source_claim_id, target=target_claim_id, relation_type=relation_type, strength=strength)
        self.reasoning_graph.add_edge(source_claim_id, target_claim_id, reasoning_edge=edge)
        return True
    
    def add_evidence(self, evidence_item: EvidenceItem):
        """Adds a piece of evidence (an element e_i) to the evidence set E."""
        self.evidence_set.add(evidence_item)
    
    def compute_hypothesis_embedding(self, embedding_model):
        """Computes and stores the hypothesis embedding H using a provided sentence-transformer model."""
        if not hasattr(embedding_model, 'encode'):
            raise TypeError("embedding_model must have an 'encode' method.")
        self.hypothesis_embedding = embedding_model.encode(self.central_hypothesis)
    
    def get_graph_statistics(self) -> Dict[str, Any]:
        """Calculates key statistics about the reasoning graph G for analysis."""
        num_nodes = self.reasoning_graph.number_of_nodes()
        if num_nodes == 0:
            return {'nodes': 0, 'edges': 0, 'density': 0, 'is_dag': True}

        return {
            'nodes': num_nodes,
            'edges': self.reasoning_graph.number_of_edges(),
            'density': nx.density(self.reasoning_graph),
            'is_dag': nx.is_directed_acyclic_graph(self.reasoning_graph),
            'avg_in_degree': np.mean([d for _, d in self.reasoning_graph.in_degree()]),
            'avg_out_degree': np.mean([d for _, d in self.reasoning_graph.out_degree()]),
        }

    def to_dict(self) -> Dict[str, Any]:
        """
        Serializes the SNO to a JSON-compatible dictionary for persistence.
        This method carefully handles complex types like NumPy arrays, datetimes,
        and NetworkX graphs to ensure clean, portable serialization.
        """
        # Convert graph to a serializable format using NetworkX's node-link representation.
        serializable_graph = nx.node_link_data(self.reasoning_graph)

        # Manually convert our custom dataclasses within the graph to dictionaries.
        for node in serializable_graph.get('nodes', []):
            if 'claim' in node and isinstance(node['claim'], ClaimNode):
                claim_dict = asdict(node['claim'])
                # Convert embedding to list for JSON compatibility
                if claim_dict.get('embedding') is not None:
                    claim_dict['embedding'] = claim_dict['embedding'].tolist()
                node['claim'] = claim_dict

        for link in serializable_graph.get('links', []):
            if 'reasoning_edge' in link and isinstance(link['reasoning_edge'], ReasoningEdge):
                edge_dict = asdict(link['reasoning_edge'])
                edge_dict['relation_type'] = edge_dict['relation_type'].value # Convert enum to string
                link['reasoning_edge'] = edge_dict

        return {
            'sno_id': self.sno_id,
            'sno_schema_version': self.sno_schema_version,
            'central_hypothesis': self.central_hypothesis,
            'created_at': self.created_at.isoformat(),
            # NumPy arrays are not native to JSON, so we convert H to a list.
            'hypothesis_embedding': self.hypothesis_embedding.tolist() if self.hypothesis_embedding is not None else None,
            'reasoning_graph': serializable_graph,
            'evidence_set': [asdict(e) for e in self.evidence_set],
            'trust_score': self.trust_score,
            'metadata': self.metadata
        }

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> 'StructuredNarrativeObject':
        """
        Deserializes an SNO from a dictionary, handling data migrations.
        This method safely reconstructs an SNO and includes a schema versioning
        system to handle future changes to the SNO class.
        """
        schema_version = data.get('sno_schema_version', 1)
        if schema_version < 2:
            # This is where you would handle migrations from older SNO formats.
            # For example, if v2 added a new mandatory field, you'd add a default here.
            pass

        try:
            sno = cls(
                central_hypothesis=data['central_hypothesis'],
                sno_id=data['sno_id'],
                created_at=datetime.fromisoformat(data['created_at']),
                metadata=data.get('metadata', {}),
                sno_schema_version=schema_version
            )

            # Re-create complex types from their serialized forms.
            if data.get('hypothesis_embedding') is not None:
                sno.hypothesis_embedding = np.array(data['hypothesis_embedding'])

            graph_data = data.get('reasoning_graph', {})
            sno.reasoning_graph = nx.DiGraph()

            # Re-instantiate our custom dataclasses for nodes and edges.
            for node_data in graph_data.get('nodes', []):
                claim_data = node_data.pop('claim')
                if claim_data.get('embedding') is not None:
                    claim_data['embedding'] = np.array(claim_data['embedding'])
                claim_obj = ClaimNode(**claim_data)
                sno.reasoning_graph.add_node(node_data['id'], claim=claim_obj, **node_data)

            for link_data in graph_data.get('links', []):
                edge_data = link_data.pop('reasoning_edge')
                if isinstance(edge_data['relation_type'], str):
                    edge_data['relation_type'] = RelationType(edge_data['relation_type'])
                edge_obj = ReasoningEdge(**edge_data)
                sno.reasoning_graph.add_edge(link_data['source'], link_data['target'], reasoning_edge=edge_obj, **link_data)

            sno.evidence_set = {EvidenceItem(**e_data) for e_data in data.get('evidence_set', [])}
            sno.trust_score = data.get('trust_score')

            return sno

        except KeyError as e:
            logging.error(f"Missing mandatory key in SNO data: {e}")
            raise ValueError(f"Invalid SNO data: Missing key {e}") from e
        except Exception as e:
            logging.error(f"Error during SNO deserialization: {e}", exc_info=True)
            raise ValueError(f"Invalid SNO data. Details: {e}") from e

    def __repr__(self) -> str:
        return f"SNO(id={self.sno_id[:8]}, hypothesis='{self.central_hypothesis[:50]}...')"

Production Challenge: SNO Serialization and Persistence

For any real-world system, you must be able to save and load your data. The to_dict() and from_dict() methods are the engine for this, but a robust strategy requires thinking about three critical production challenges: scalability, concurrency, and schema evolution.

The Serialization Engine: to_dict() and from_dict()

A successful persistence strategy hinges on robust serialization. Here’s a deeper look at how our methods work:

• to_dict(): This method acts as a “dehydrator,” carefully converting the SNO instance into a JSON-compatible dictionary. It systematically handles complex types like NumPy arrays, datetime objects, and NetworkX graphs to ensure a clean, portable representation.
• from_dict(): This class method is the “rehydrator.” It takes a dictionary and meticulously reconstructs the live SNO object, converting lists back to NumPy arrays and strings to datetime objects. This ensures all methods and type-safety of the original object are restored.

While this works perfectly for a single object, deploying a system that manages millions of SNOs requires a more sophisticated approach.

Challenge 1: Scalability and Concurrency

In a live CNS system, the SNO population could grow to millions. Storing this data in a single JSON file is unworkable. The challenges of managing a large-scale, distributed SNO database become even more acute when considering systems that operate across organizational boundaries, where data privacy is paramount.

Designing such a system is a major undertaking. For more, see the research project on Federated Learning and Privacy.

The Problems with File-Based Persistence:

• Scalability: Loading a multi-gigabyte JSON file into memory on every startup is incredibly slow and resource-intensive.
• Concurrency: If multiple processes or workers (as seen in Chapter 6) try to write to the same file simultaneously, they will overwrite each other’s changes, leading to race conditions and data corruption.
• Inefficient Queries: Finding a specific SNO (e.g., by sno_id) or a set of SNOs (e.g., “all SNOs with trust_score > 0.8”) requires loading and scanning the entire file every time.

The Solution: A Document Database A document database like MongoDB or PostgreSQL with JSONB columns is the professional solution. The JSON-like structure of our serialized SNOs maps directly to a document-oriented model, where each SNO is stored as a separate, indexed document.

Why this works:

• Atomic Operations: The database guarantees that updates to a single SNO are atomic, preventing corruption from concurrent writes.
• Indexed Queries: You can create indexes on any field (e.g., trust_score, metadata.author). This allows for near-instant retrieval of SNOs based on complex criteria without scanning the entire collection.
• Horizontal Scalability: Document databases are designed to be distributed across multiple servers, allowing your persistence layer to scale alongside your application.

Challenge 2: Schema Evolution

What happens when you need to change the StructuredNarrativeObject class? For example, adding a new mandatory author field. If you deploy new code, the from_dict method will raise a KeyError when it tries to load an old SNO from the database that doesn’t have the new field.

The Solution: Schema Versioning and On-the-Fly Migration A robust system must anticipate change. The sno_schema_version field we added to the class is the key to solving this. It allows the from_dict method to act as a “migration” function.

Before creating the object, from_dict can check the schema version of the incoming data and apply transformations to make it compatible with the new code.

Here is a more robust from_dict implementation demonstrating this principle:

    @classmethod
    def from_dict(cls, data: Dict[str, Any]) -> 'StructuredNarrativeObject':
        """
        Deserializes an SNO from a dictionary, handling data migrations.
        """
        schema_version = data.get('sno_schema_version', 1)

        # --- Migration Logic ---
        # This block checks the version and applies transformations to bring
        # old data into compliance with the current schema.
        if schema_version < 2:
            # Example Migration: v2 adds a mandatory 'author' field to metadata.
            # If we load a v1 SNO, we add a default value.
            if 'metadata' not in data:
                data['metadata'] = {}
            if 'author' not in data['metadata']:
                data['metadata']['author'] = 'unknown'

        if schema_version < 3:
            # Example Migration: v3 renames 'central_hypothesis' to 'hypothesis_text'.
            if 'central_hypothesis' in data and 'hypothesis_text' not in data:
                data['hypothesis_text'] = data.pop('central_hypothesis')

        # --- End Migration Logic ---

        try:
            # The rest of the instantiation logic now works with the migrated data.
            sno = cls(
                central_hypothesis=data['hypothesis_text'], # Using the new field name
                sno_id=data['sno_id'],
                # ... other fields ...
            )
            # ... rest of the deserialization logic ...
            return sno
        except KeyError as e:
            logging.error(f"Missing mandatory key in SNO data after migration: {e}")
            raise ValueError(f"Invalid SNO data: Missing key {e}") from e

This on-the-fly migration strategy ensures that your system can evolve gracefully without breaking compatibility with its own historical data—a crucial capability for any long-running, production-level application.

Try It Now: Build Your First Complete SNO

Goal: Create a fully functional Structured Narrative Object with hypothesis embedding, reasoning graph, and evidence set in 10 minutes.

Prerequisites

• Completed Chapter 1 and passed the checkpoint test
• Virtual environment activated with all dependencies installed

Step 1: Save the Complete Example

Note: This example uses a simplified version of the StructuredNarrativeObject class for clarity and ease of execution. It includes the essential methods (add_claim, add_evidence, compute_hypothesis_embedding) but omits advanced features like full serialization and schema migration covered in the main chapter text. This allows you to focus on the core concepts without complexity.

Create a file called build_complete_sno.py:

"""
Complete SNO Example: Coffee & Programming Productivity
Demonstrates creating a full Structured Narrative Object with all components.
"""

from sentence_transformers import SentenceTransformer
import networkx as nx
import numpy as np
from datetime import datetime
from dataclasses import dataclass, field
from typing import Optional, Set, Dict, Any
from enum import Enum
import uuid
import hashlib
import json

print("="*70)
print("BUILDING A COMPLETE STRUCTURED NARRATIVE OBJECT")
print("="*70)

# Step 1: Load embedding model
print("\n[Step 1/6] Loading embedding model...")
model = SentenceTransformer('all-MiniLM-L6-v2')
print("✓ Model loaded")

# Step 2: Define data structures (from Chapter 1 & 2)
print("\n[Step 2/6] Setting up data structures...")

class RelationType(Enum):
    SUPPORTS = "supports"
    CONTRADICTS = "contradicts"
    IMPLIES = "implies"
    WEAKENS = "weakens"
    EXPLAINS = "explains"

@dataclass
class EvidenceItem:
    content: str
    source_id: str
    doc_hash: Optional[str] = None
    confidence: float = 1.0

    def __post_init__(self):
        if self.doc_hash is None:
            self.doc_hash = hashlib.sha256(self.content.encode()).hexdigest()[:16]

    def __hash__(self):
        return hash(self.doc_hash)

    def __eq__(self, other):
        return isinstance(other, EvidenceItem) and self.doc_hash == other.doc_hash

@dataclass
class ClaimNode:
    claim_id: str
    content: str  # Using 'content' to match main Chapter 2 definition
    embedding: Optional[np.ndarray] = None
    confidence: float = 1.0

@dataclass
class ReasoningEdge:
    relation_type: RelationType
    strength: float = 1.0
    evidence_refs: Set[str] = field(default_factory=set)

# Simplified SNO class (subset of full implementation from Chapter 2)
class StructuredNarrativeObject:
    def __init__(self, central_hypothesis: str, sno_id: Optional[str] = None):
        self.sno_id = sno_id or str(uuid.uuid4())[:8]
        self.central_hypothesis = central_hypothesis
        self.hypothesis_embedding: Optional[np.ndarray] = None
        self.reasoning_graph = nx.DiGraph()
        self.evidence_set: Set[EvidenceItem] = set()
        self.trust_score: Optional[float] = None
        self.created_at = datetime.now()
        self.metadata: Dict[str, Any] = {}

    def compute_hypothesis_embedding(self, model):
        """Compute semantic embedding for the hypothesis"""
        self.hypothesis_embedding = model.encode(self.central_hypothesis)
        return self.hypothesis_embedding

    def add_claim(self, claim_id: str, content: str, confidence: float = 1.0):
        """Add a claim node to the reasoning graph"""
        claim = ClaimNode(claim_id=claim_id, content=content, confidence=confidence)
        self.reasoning_graph.add_node(claim_id, claim=claim)

    def add_reasoning_edge(self, source: str, target: str, relation: RelationType, strength: float = 1.0):
        """Add a typed reasoning edge between claims"""
        edge = ReasoningEdge(relation_type=relation, strength=strength)
        self.reasoning_graph.add_edge(source, target, reasoning_edge=edge)

    def add_evidence(self, content: str, source_id: str, confidence: float = 1.0):
        """Add evidence item to the evidence set"""
        evidence = EvidenceItem(content=content, source_id=source_id, confidence=confidence)
        self.evidence_set.add(evidence)
        return evidence.doc_hash

    def __repr__(self):
        return f"SNO({self.sno_id}): {self.central_hypothesis[:50]}..."

print("✓ Data structures ready")

# Step 3: Create the SNO
print("\n[Step 3/6] Creating SNO with hypothesis...")
sno = StructuredNarrativeObject(
    central_hypothesis="Coffee consumption improves programming productivity through enhanced cognitive performance"
)
print(f"✓ Created SNO: {sno.sno_id}")

# Step 4: Build reasoning graph
print("\n[Step 4/6] Building reasoning graph...")

# Add claims
sno.add_claim("c1", "Caffeine blocks adenosine receptors in the brain", confidence=0.95)
sno.add_claim("c2", "Adenosine accumulation causes drowsiness", confidence=0.95)
sno.add_claim("c3", "Blocking adenosine reduces drowsiness and increases alertness", confidence=0.90)
sno.add_claim("c4", "Increased alertness improves sustained attention", confidence=0.85)
sno.add_claim("c5", "Sustained attention is critical for programming tasks", confidence=0.90)
sno.add_claim("c6", "Therefore, coffee improves programming productivity", confidence=0.80)

# Add reasoning relationships
sno.add_reasoning_edge("c1", "c3", RelationType.SUPPORTS, strength=0.9)
sno.add_reasoning_edge("c2", "c3", RelationType.SUPPORTS, strength=0.9)
sno.add_reasoning_edge("c3", "c4", RelationType.IMPLIES, strength=0.85)
sno.add_reasoning_edge("c4", "c5", RelationType.SUPPORTS, strength=0.85)
sno.add_reasoning_edge("c5", "c6", RelationType.IMPLIES, strength=0.80)

print(f"✓ Added {len(sno.reasoning_graph.nodes)} claims")
print(f"✓ Added {len(sno.reasoning_graph.edges)} reasoning edges")

# Step 5: Add evidence
print("\n[Step 5/6] Adding evidence...")

sno.add_evidence(
    content="Caffeine is an adenosine receptor antagonist, blocking A1 and A2A receptors (Fredholm et al., 1999)",
    source_id="doi:10.1016/S0163-7258(99)00010-6",
    confidence=0.95
)

sno.add_evidence(
    content="Adenosine accumulation during wakefulness promotes sleep pressure (Porkka-Heiskanen et al., 1997)",
    source_id="doi:10.1126/science.276.5316.1265",
    confidence=0.95
)

sno.add_evidence(
    content="Caffeine significantly improves sustained attention and psychomotor vigilance (Lieberman et al., 2002)",
    source_id="doi:10.1016/S0091-3057(01)00666-5",
    confidence=0.90
)

sno.add_evidence(
    content="Programming tasks require sustained attention and working memory (Parnin & Rugaber, 2011)",
    source_id="doi:10.1109/ICPC.2011.15",
    confidence=0.85
)

print(f"✓ Added {len(sno.evidence_set)} evidence items")

# Step 6: Compute embedding and display
print("\n[Step 6/6] Computing hypothesis embedding...")
sno.compute_hypothesis_embedding(model)
print(f"✓ Embedding computed: shape {sno.hypothesis_embedding.shape}")

# Summary
print("\n" + "="*70)
print("✓ COMPLETE SNO SUCCESSFULLY CREATED")
print("="*70)
print(f"\nSNO Details:")
print(f"  ID: {sno.sno_id}")
print(f"  Hypothesis: {sno.central_hypothesis}")
print(f"  Created: {sno.created_at.strftime('%Y-%m-%d %H:%M:%S')}")
print(f"\nComponents:")
print(f"  • Reasoning Graph: {len(sno.reasoning_graph.nodes)} nodes, {len(sno.reasoning_graph.edges)} edges")
print(f"  • Evidence Set: {len(sno.evidence_set)} items")
print(f"  • Hypothesis Embedding: {sno.hypothesis_embedding.shape[0]} dimensions")
print(f"  • Trust Score: {sno.trust_score or 'Not evaluated (requires Chapter 3)'}")

# Visualize graph structure
print(f"\nReasoning Chain:")
print(f"  c1 (Caffeine blocks receptors)")
print(f"   └→ c3 (Reduces drowsiness)")
print(f"       └→ c4 (Improves attention)")
print(f"           └→ c5 (Attention critical for programming)")
print(f"               └→ c6 (Conclusion: Coffee improves productivity)")

# Test serialization
print(f"\n[Bonus] Testing serialization...")
sno_dict = {
    'sno_id': sno.sno_id,
    'central_hypothesis': sno.central_hypothesis,
    'hypothesis_embedding': sno.hypothesis_embedding.tolist() if sno.hypothesis_embedding is not None else None,
    'claims_count': len(sno.reasoning_graph.nodes),
    'edges_count': len(sno.reasoning_graph.edges),
    'evidence_count': len(sno.evidence_set)
}
serialized = json.dumps(sno_dict, indent=2)
print(f"✓ Serialized to JSON ({len(serialized)} bytes)")

print("\n" + "="*70)
print("What you just built:")
print("  ✓ Complete SNO with all components from Chapter 2")
print("  ✓ Semantic embedding (foundation for Chapter 4 chirality)")
print("  ✓ Structured reasoning graph (ready for Chapter 3 logic critic)")
print("  ✓ Verifiable evidence set (ready for Chapter 3 grounding critic)")
print("\nNext: Chapter 3 - Add critic evaluation to compute trust scores")
print("="*70)

Step 2: Run It

python build_complete_sno.py

Expected Output

======================================================================
BUILDING A COMPLETE STRUCTURED NARRATIVE OBJECT
======================================================================

[Step 1/6] Loading embedding model...
✓ Model loaded

[Step 2/6] Setting up data structures...
✓ Data structures ready

[Step 3/6] Creating SNO with hypothesis...
✓ Created SNO: a7f4e2c9

[Step 4/6] Building reasoning graph...
✓ Added 6 claims
✓ Added 5 reasoning edges

[Step 5/6] Adding evidence...
✓ Added 4 evidence items

[Step 6/6] Computing hypothesis embedding...
✓ Embedding computed: shape (384,)

======================================================================
✓ COMPLETE SNO SUCCESSFULLY CREATED
======================================================================

SNO Details:
  ID: a7f4e2c9
  Hypothesis: Coffee consumption improves programming productivity through enhanced cognitive performance
  Created: 2025-10-07 15:30:45

Components:
  • Reasoning Graph: 6 nodes, 5 edges
  • Evidence Set: 4 items
  • Hypothesis Embedding: 384 dimensions
  • Trust Score: Not evaluated (requires Chapter 3)

Reasoning Chain:
  c1 (Caffeine blocks receptors)
   └→ c3 (Reduces drowsiness)
       └→ c4 (Improves attention)
           └→ c5 (Attention critical for programming)
               └→ c6 (Conclusion: Coffee improves productivity)

[Bonus] Testing serialization...
✓ Serialized to JSON (287 bytes)

======================================================================
What you just built:
  ✓ Complete SNO with all components from Chapter 2
  ✓ Semantic embedding (foundation for Chapter 4 chirality)
  ✓ Structured reasoning graph (ready for Chapter 3 logic critic)
  ✓ Verifiable evidence set (ready for Chapter 3 grounding critic)

Next: Chapter 3 - Add critic evaluation to compute trust scores
======================================================================

What Just Happened?

You created a complete Structured Narrative Object with all four core components:

1. Hypothesis Embedding (H): 384-dimensional semantic vector representing the central claim
2. Reasoning Graph (G): Directed acyclic graph with 6 claims and 5 logical relationships
3. Evidence Set (E): 4 evidence items linked to real research papers (via DOIs)
4. Trust Score (T): Placeholder for Chapter 3’s critic evaluation

This SNO is now ready to be:

• Evaluated by the critic pipeline (Chapter 3)
• Compared with other SNOs to find chiral pairs (Chapter 4)
• Synthesized with contradictory SNOs (Chapter 4)

Experiment: Create Your Own SNO

Modify the example to create an SNO about your research topic:

Suggested topics:

• Scientific hypotheses (e.g., “Dark matter explains galaxy rotation curves”)
• Technical architectures (e.g., “Microservices improve system scalability”)
• Historical interpretations (e.g., “Climate change caused the Bronze Age collapse”)
• Business strategies (e.g., “Remote work increases employee productivity”)

Challenge: Create TWO SNOs with opposing views (chiral pair):

• SNO_A: “Coffee improves productivity”
• SNO_B: “Coffee harms productivity through dependency and crashes”

Share your SNOs in GitHub Discussions with tag #chapter2!

✓ Chapter 2 Checkpoint

Before proceeding to Chapter 3, verify you can:

1. ✓ Create an SNO with a hypothesis
2. ✓ Add claims to the reasoning graph
3. ✓ Connect claims with typed edges (SUPPORTS, IMPLIES, etc.)
4. ✓ Add evidence items with DOI sources
5. ✓ Compute hypothesis embeddings
6. ✓ Serialize SNO to JSON

If any step fails:

• Review the example code above
• Check your Chapter 1 checkpoint passed
• See Troubleshooting

Navigation

← Previous: Chapter 1: Introduction to CNS 2.0 → Next: Chapter 3: Critic Pipeline

Learn how to evaluate SNO quality with specialized critics for grounding, logic, and novelty.

Large Language Models (LLMs) are incredibly powerful, but getting them to perform a specific, complex reasoning task reliably is a major challenge. The standard approach is “prompt engineering”: manually tweaking the text of a prompt, often through trial and error, until it produces the desired output for a few examples.

This approach has significant drawbacks:

• Brittleness: A prompt that works well for one set of examples might fail completely on slightly different ones.
• Opacity: It’s often unclear why one prompt works better than another, making the process feel more like an art than a science.
• Lack of Adaptability: If the underlying LLM is updated (e.g., from GPT-4 to GPT-5), the “optimal” prompt might change completely, forcing the developer to start the tuning process all over again.

For a system as complex as CNS 2.0, which relies on an LLM for its core Generative Synthesis Engine, this manual, brittle approach is simply not viable. We need a more robust, principled, and automated way to optimize our system’s reasoning capabilities.

The Solution: Programmatic Optimization with DSPy

This tutorial introduces a new paradigm: treating our LLM-based workflows not as static prompts, but as programs we can optimize. We will use the DSPy framework to achieve this.

As detailed in Chapter 7 of the Developer’s Guide, DSPy allows us to define the steps of our reasoning task (e.g., “analyze two opposing narratives and generate a synthesized hypothesis”) without hard-coding the prompt. Instead, we provide:

1. A Signature that defines the desired input/output behavior.
2. A Metric that defines what a “good” output looks like.
3. A few Examples of high-quality input/output pairs.

The DSPy compiler then takes over, automatically experimenting with different prompts, few-shot examples, and reasoning strategies to find the optimal “program” that maximizes the metric on the given examples.

This is the core of the self-optimization loop described in the CNS 2.0 Ideas Paper. By using our own CriticPipeline as the optimization metric, we can teach the synthesizer to generate SNOs that our system already considers to be high-quality.

In this tutorial, we will walk through a concrete example of how to use DSPy to build a self-optimizing synthesis module for CNS 2.0. We will move from a manually engineered prompt to a robust, optimized program that is more accurate, reliable, and adaptable.

To demonstrate the synthesis engine, we use a classic example from the history of science: the debate between Geosyncline theory and Plate Tectonics. This historical conflict is an ideal test case because it involves two well-defined, opposing theories that were eventually resolved into a more comprehensive model of Earth’s geology.

This tutorial walks through how to represent these two historical theories as knowledge objects and use the synthesis engine to generate a new, unified theory.

The Competing Scientific Narratives

Geosyncline Theory (Dominant paradigm, 1850s-1960s):

• Core Idea: Mountain ranges are formed by the vertical collapse and uplift of huge troughs filled with sediment. This all happens on a static, cooling Earth.
• How it Works: The Earth’s crust wrinkles and buckles as it cools, much like the skin of a drying apple.
• Key Evidence: Geologists observed massive, thick layers of sediment in mountain ranges.

Plate Tectonics Theory (The modern paradigm, 1960s-present):

• Core Idea: The Earth’s surface is made of large, moving plates. Their interactions (colliding, separating, sliding) are what cause major geological events like earthquakes and the formation of mountains.
• How it Works: The plates “float” on the semi-molten mantle beneath them, and convection currents in the mantle cause them to move.
• Key Evidence: Evidence for seafloor spreading, patterns in earthquake locations, and the puzzle-like fit of the continents.

By feeding the core concepts of these two theories into the system, we can see how the synthesis engine attempts to create a new theory that resolves their contradictions and combines their strengths.

GCTS may use labels or expert judgment for training, calibration, evaluation, and error review. Runtime truth ranking and posterior mass must come from evidence, access states, rules, possible worlds, proof traces, and calibrated parameters.

Allowed Oracle Use

• Training labels.
• Calibration labels.
• Evaluation labels.
• Expert review of error cases.
• Human approval of new strict rules.
• Human review of system failures after a run.

Forbidden Runtime Oracle Use

• Runtime access to gold labels.
• Runtime human or model truth decisions that bypass evidence closure and world ranking.
• Dataset label leakage into retrieval, ranking, world building, or rendering.
• Prompting an LLM to decide truth and using that answer as posterior mass.
• Using hidden benchmark answers as features.
• Using evaluator notes, answer keys, or adjudication metadata in a production run.

LLM Boundary

LLMs may:

• extract candidate claims;
• propose evidence spans;
• propose latent context variables;
• suggest possible access hypotheses;
• render structured outputs into readable prose.

LLMs may not:

• assign runtime truth mass;
• promote a claim to strict proof;
• erase record contingencies;
• convert missing records into ordinary absence without the access model;
• add unsupported details during rendering.

Promotion Policy

Strict claims require:

• resolvable evidence references;
• zero-temperature proof support;
• proof traces;
• no runtime label access.

Likely-truth claims require:

• posterior calculation over explicit worlds;
• confidence and uncertainty decomposition;
• clear distinction between posterior probability, strict support, and confidence.

Record-contingent claims require:

• identified record dependencies;
• access-state classification;
• an explanation of what evidence would change the ranking.

Relationship To Benchmark Leakage

The oracle boundary is related to benchmark-leakage and test-contamination concerns in machine-learning evaluation. Hidden labels, benchmark answers, evaluator notes, and gold outputs can improve apparent performance while bypassing the evidence process. GCTS treats that pattern as a governance failure in runtime truth ranking.

The deployable system must be able to explain how each claim status came from available evidence, access states, rules, worlds, proof traces, and calibrated parameters.

Main Risks

False certainty: posterior scores can be misread as objective truth. Mitigation: confidence bands, entropy, uncertainty decomposition, estimative language, and explicit caveats.

Source poisoning: manipulated evidence can shift world rankings. Mitigation: source reliability priors, source diversity metrics, adversarial evidence tests, and source-quality uncertainty.

Access overreach: the system may infer withholding or concealment from ordinary missingness. Mitigation: record-duty thresholds, access-path checks, competing missingness worlds, MDL penalties, and conservative confidence.

Access underreach: the system may treat inaccessible controlled records as simple lack of evidence. Mitigation: record-contingency status, expected-record modeling, access uncertainty, and next-evidence requirements.

LLM rendering drift: the renderer may add unsupported details. Mitigation: render from structured payload only, post-render verification, and rejection of unsupported phrases.

Deployment Checklist

• All strict promoted claims have resolvable citations.
• All strict promoted claims have proof traces.
• Runtime labels were unavailable.
• Posterior, strict support, and confidence are reported separately.
• Top alternative worlds are shown.
• Record-contingent claims identify record dependencies.
• Uncertainty decomposition is shown.
• Evidence that would change the conclusion is listed.
• Renderer output is checked against the structured payload.
• No hidden benchmark fields, answer keys, or evaluator notes are accessible to runtime ranking.

GCTS is a decision-support system. It should expose alternatives, likely-truth rankings, access constraints, and uncertainty. It should not replace human judgment in high-stakes domains.

Many AI systems rely on opaque, monolithic “oracle” models for evaluation. These models produce a score but offer no insight into their reasoning, making them difficult to debug, trust, or adapt. If an oracle gives a low score, is it because the input was factually wrong, illogical, or simply unoriginal? It’s impossible to know.

CNS 2.0 explicitly rejects this “black box” approach. Instead, it decomposes evaluation into a transparent, auditable pipeline of specialized critics. This design choice is fundamental and provides several key advantages:

• Transparency & Debuggability: By separating evaluation into components—Grounding, Logic, and Novelty—we can pinpoint the exact strengths and weaknesses of a narrative. A low score from the LogicCritic tells us to examine the argument’s structure, while a low score from the GroundingCritic points to a lack of evidence.
• Adaptability: The system’s “values” can be dynamically adjusted. By changing the weights assigned to each critic, we can shift the system’s focus. In an exploratory phase, we might prioritize novelty. In a verification phase, we would prioritize grounding and logic.
• Explainability: The final Trust Score is not a mystery. It can be explained as a weighted combination of clear, understandable criteria, making the entire system more trustworthy and interpretable.

The Mathematical Foundation: Weighted Averaging

The final Trust Score emerges from a weighted combination of the individual critic scores, as defined by Equation (1) in Section 2.2 of the paper. This formula is the heart of the pipeline’s adaptability.

From the Paper (Equation 1):

$$\text{Reward}(\mathcal{S}) = \sum_{i \in \{G, L, N\}} w_i \cdot \text{Score}_i(\mathcal{S})$$

where $w_i$ are dynamically adjustable weights for the Grounding, Logic, and Novelty-Parsimony critics.

Our CriticPipeline class directly implements this formula. It iterates through each registered critic, calculates its score, applies the corresponding weight $w_i$, and normalizes the result to produce the final Trust Score.

Implementing the Critic Infrastructure

First, we define the basic infrastructure: a BaseCritic abstract class to ensure all critics have a standard interface, a CriticResult dataclass for structured and explainable output, and the CriticPipeline orchestrator.

"""
Multi-Component Critic Pipeline Implementation
============================================
Transparent, auditable evaluation of SNO quality
"""
from abc import ABC, abstractmethod
from typing import Dict, List, Tuple, Optional, Any
import numpy as np
from dataclasses import dataclass, field
from enum import Enum
# Assume StructuredNarrativeObject is available from Chapter 2 and HAS_TRANSFORMERS is defined

@dataclass
class CriticResult:
    """A structured result from a single critic evaluation, ensuring transparency."""
    score: float
    confidence: float
    explanation: str
    # evidence can store any data that supports the explanation, e.g., claim-level scores
    evidence: Dict[str, Any] = field(default_factory=dict)
    sub_scores: Dict[str, float] = field(default_factory=dict)

class CriticType(Enum):
    GROUNDING = "grounding"
    LOGIC = "logic"
    NOVELTY = "novelty"

class BaseCritic(ABC):
    """Abstract base class for all CNS 2.0 critics, ensuring a consistent interface."""
    
    def __init__(self, critic_type: CriticType, weight: float = 1.0):
        self.critic_type = critic_type
        self.weight = weight
        self.evaluation_count = 0
        self.performance_history = []
    
    @abstractmethod
    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        """The core method for any critic. Must be implemented by subclasses."""
        pass
    
    def update_weight(self, new_weight: float):
        """Allows for dynamic adjustment of the critic's importance in the pipeline."""
        self.weight = new_weight
    
    def get_statistics(self) -> Dict[str, Any]:
        """Provides performance metrics for monitoring."""
        return {
            'type': self.critic_type.value,
            'weight': self.weight,
            'evaluations': self.evaluation_count,
            'avg_score': np.mean([r['score'] for r in self.performance_history]) if self.performance_history else 0.0,
        }

class CriticPipeline:
    """Orchestrates multiple critics to produce a comprehensive SNO evaluation."""
    
    def __init__(self):
        self.critics: Dict[CriticType, BaseCritic] = {}
        self.evaluation_history = []
    
    def add_critic(self, critic: BaseCritic):
        """Registers a critic with the pipeline."""
        self.critics[critic.critic_type] = critic
    
    def evaluate_sno(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> Dict[str, Any]:
        """
        Evaluates an SNO by running it through all registered critics and computing
        the final weighted Trust Score, directly implementing the paper's Reward formula.
        """
        results = {}
        total_weighted_score = 0.0
        total_weight = 0.0
        
        for critic_type, critic in self.critics.items():
            result = critic.evaluate(sno, context)
            results[critic_type.value] = result
            # This is the core of the formula: score * weight
            total_weighted_score += result.score * critic.weight
            total_weight += critic.weight
            critic.performance_history.append({'score': result.score, 'confidence': result.confidence})
            critic.evaluation_count += 1
        
        # Normalize by the sum of weights to get the final score
        trust_score = total_weighted_score / total_weight if total_weight > 0 else 0.0
        sno.trust_score = trust_score
        
        evaluation_result = {
            'trust_score': trust_score,
            'critic_results': {k: v.to_dict() for k, v in results.items()}, # Assuming CriticResult has to_dict
            'weights_used': {ct.value: c.weight for ct, c in self.critics.items()},
        }
        self.evaluation_history.append(evaluation_result)
        return evaluation_result
    
    def adjust_weights(self, weight_updates: Dict[CriticType, float]):
        """Dynamically adjusts the weights of the critics."""
        for critic_type, new_weight in weight_updates.items():
            if critic_type in self.critics:
                self.critics[critic_type].update_weight(new_weight)

1. Grounding Critic

The Grounding Critic ensures that narratives remain tethered to verifiable facts by evaluating how well claims are supported by the provided evidence.

From the Paper (Section 2.2):

$$ \text{Score}_G = \frac{1}{|V|}\sum_{v \in V} \max_{e \in \mathcal{E}} p(v|e) $$

where $p(v|e)$ is the plausibility of a claim $v$ given evidence $e$, computed using a Natural Language Inference (NLI) model.

Formula Breakdown: Score_G

This formula calculates the average “best possible support” for all claims in a narrative. Let’s break it down from inside out:

• p(v|e): This is the core judgment: “Given this piece of evidence e, how plausible is claim v?” We use a Natural Language Inference (NLI) model to calculate this, where p(v|e) is the model’s confidence in the “entailment” relationship between the evidence (premise) and the claim (hypothesis).
• max_{e \in E}: For each individual claim v, we loop through all available evidence in the set E and find the single best piece of evidence that supports it. A claim only needs one strong piece of evidence to be considered well-supported.
• ∑_{v \in V}: We sum up these “maximum plausibility” scores for every claim v in the reasoning graph’s vertex set V.
• 1/|V|: Finally, we average the total score by dividing by the number of claims. This ensures that SNOs with many claims aren’t unfairly advantaged or disadvantaged.

class GroundingCritic(BaseCritic):
    def __init__(self, weight: float, nli_model=None, nli_tokenizer=None, nli_model_name: str = "roberta-large-mnli"):
        super().__init__(CriticType.GROUNDING, weight)
        if nli_model and nli_tokenizer:
            self.nli_model, self.nli_tokenizer = nli_model, nli_tokenizer
        elif HAS_TRANSFORMERS:
            import transformers
            self.nli_tokenizer = transformers.AutoTokenizer.from_pretrained(nli_model_name)
            self.nli_model = transformers.AutoModelForSequenceClassification.from_pretrained(nli_model_name)
        else:
            raise ImportError("Transformers library is required for the GroundingCritic.")
        # Find the index for the 'entailment' label in the model's configuration
        self.entailment_id = self.nli_model.config.label2id.get('entailment', 2)

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        claims = [data['claim'] for _, data in sno.reasoning_graph.nodes(data=True)]
        evidence_contents = [item.content for item in sno.evidence_set]
        
        if not claims or not evidence_contents:
            return CriticResult(0.0, 1.0, "SNO has no claims or no evidence to evaluate.", {}, {})

        total_max_plausibility, sub_scores = 0.0, {}
        # This outer loop corresponds to the Σ[v ∈ V] part of the formula
        for claim in claims:
            # Prepare (evidence, claim) pairs to calculate p(v|e) for all e ∈ E at once
            pairs = [(e, claim.content) for e in evidence_contents]
            inputs = self.nli_tokenizer(pairs, return_tensors='pt', padding=True, truncation=True)

            with torch.no_grad():
                logits = self.nli_model(**inputs).logits

            probabilities = torch.softmax(logits, dim=1)
            entailment_probs = probabilities[:, self.entailment_id].tolist()

            # This corresponds to the max[e ∈ E] p(v|e) part of the formula
            max_plausibility_for_claim = max(entailment_probs) if entailment_probs else 0.0
            total_max_plausibility += max_plausibility_for_claim
            sub_scores[claim.claim_id] = max_plausibility_for_claim

        # This corresponds to the (1/|V|) * Σ[...] part of the formula
        final_score = total_max_plausibility / len(claims) if claims else 0.0
        return CriticResult(
            score=final_score, confidence=0.8,
            explanation=f"Average max NLI entailment score across {len(claims)} claims is {final_score:.3f}.",
            evidence={'claim_scores': sub_scores}, sub_scores=sub_scores
        )

2. Logic Critic

The Logic Critic assesses the structural coherence of the reasoning graph $G$. A narrative can have well-grounded claims but still be logically flawed.

From the Paper (Section 2.2): The ideal Logic Score is produced by a Graph Neural Network (GNN) trained to detect logical weaknesses:

$$ \text{Score}_L = f_{\text{GNN}}(G; \theta) $$

Training a full GNN is a major research project. For our implementation, we create a functional heuristic proxy for $f_{\text{GNN}}$ that uses graph-theoretic metrics to approximate logical coherence.

For a deep-dive into the state-of-the-art approach, see the research project on GNNs for Logical Reasoning.

Score_L (Heuristic Proxy)

Our heuristic-based LogicCritic uses a weighted average of three metrics to approximate what a trained GNN would learn:

• Orphan Score (Penalty for unsupported claims): Checks for claims that are not supported by any other claim. A high number of orphans suggests a collection of disconnected assertions, not a coherent argument.
• Coherence Score (Penalty for unfocused claims): Penalizes claims that are used to support too many other, potentially unrelated, points.
• Parsimony Score (Penalty for complexity): Rewards simplicity (Occam’s Razor) by penalizing overly dense, “spaghetti-like” argument graphs.

class LogicCritic(BaseCritic):
    def __init__(self, weight: float):
        super().__init__(CriticType.LOGIC, weight)

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        G = sno.reasoning_graph
        num_nodes = G.number_of_nodes()
        if num_nodes <= 1:
            return CriticResult(1.0, 1.0, "Graph is too simple to assess logic.", {}, {})

        # Heuristic 1: Penalize orphaned claims (unsupported assertions)
        # An orphan is a node with no incoming edges, excluding the root hypothesis.
        orphaned_nodes = [n for n, d in G.in_degree() if d == 0 and n != 'root']
        orphan_penalty = len(orphaned_nodes) / (num_nodes - 1) if num_nodes > 1 else 0
        orphan_score = 1.0 - orphan_penalty
        
        # Heuristic 2: Penalize unfocused claims (a single claim supporting too many others)
        avg_out_degree = sum(d for _, d in G.out_degree()) / num_nodes
        # Penalize if the average claim supports more than 3 others. This is a simple heuristic.
        coherence_score = max(0, 1.0 - (avg_out_degree / 3.0))

        # Heuristic 3: Penalize complexity (convoluted, "spaghetti" arguments) using graph density
        density = nx.density(G)
        parsimony_score = 1.0 - density

        # Our functional proxy for f_GNN is a weighted average of these heuristics.
        # These weights are internal to the critic and can be tuned.
        final_score = 0.5 * orphan_score + 0.3 * coherence_score + 0.2 * parsimony_score
        sub_scores = {'orphan_score': orphan_score, 'coherence_score': coherence_score, 'parsimony_score': parsimony_score}

        return CriticResult(
            score=final_score, confidence=0.9,
            explanation=f"Logic score based on graph structure heuristics: {final_score:.3f}",
            evidence={'num_orphans': len(orphaned_nodes), 'avg_out_degree': avg_out_degree, 'density': density},
            sub_scores=sub_scores
        )

3. Novelty-Parsimony Critic

This critic balances two competing virtues: the desire for new ideas (novelty) and the principle of simplicity (parsimony), also known as Occam’s Razor.

From the Paper (Section 2.2):

$$ \text{Score}_N = \alpha \cdot \min_i \|H - H_i\|_2 - \beta \cdot \frac{|E_G|}{|V|} $$

Formula Breakdown: Score_N

This formula is a simple linear combination of a reward and a penalty:

• α * min_i ||H - H_i||₂: This is the novelty reward.
  • ||H - H_i||₂: The Euclidean distance between the current SNO’s embedding (H) and the embedding of another SNO (H_i) in the population. A larger distance means the ideas are further apart, or more “novel.”
  • min_i: We find the distance to the closest (most similar) SNO in the entire population. This measures how much of a leap the new idea is making from the most related existing idea.
  • α: The alpha parameter is a weight that lets us control how much we care about novelty. A high α encourages more exploratory, “out-there” ideas.
• - β * (|E_G| / |V|): This is the parsimony penalty.
  • |E_G| / |V|: The ratio of edges to nodes in the reasoning graph. This is a simple measure of graph complexity or density. An argument with 10 claims and 30 relationships is more complex than one with 10 claims and 9 relationships.
  • β: The beta parameter weights this penalty. A high β strongly encourages simpler, more elegant arguments.

class NoveltyParsimonyCritic(BaseCritic):
    def __init__(self, weight: float, alpha: float, beta: float):
        super().__init__(CriticType.NOVELTY, weight)
        self.alpha = alpha
        self.beta = beta

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        context = context or {}
        sno_population = context.get('sno_population', [])
        population_embeddings = [s.hypothesis_embedding for s in sno_population if s.sno_id != sno.sno_id and s.hypothesis_embedding is not None]
        
        # --- Novelty Term Calculation ---
        if not population_embeddings or sno.hypothesis_embedding is None:
            # If this is the first SNO, it is maximally novel by definition.
            novelty_score = 1.0
            min_dist_str = "N/A (first SNO)"
        else:
            # Corresponds to the ||H - H_i||₂ part of the formula
            distances = [np.linalg.norm(sno.hypothesis_embedding - h) for h in population_embeddings]
            # Corresponds to the min_i part of the formula
            min_distance = min(distances) if distances else 0
            # Normalize the distance. Max possible distance for normalized vectors is 2.0.
            novelty_score = min_distance / 2.0
            min_dist_str = f"{min_distance:.3f}"

        novelty_term = self.alpha * novelty_score

        # --- Parsimony Term Calculation ---
        G = sno.reasoning_graph
        num_nodes = G.number_of_nodes()
        # Corresponds to the |E_G|/|V| part of the formula
        complexity_ratio = G.number_of_edges() / num_nodes if num_nodes > 0 else 0
        # Normalize penalty (assuming max complexity ratio is around 5 for a reasonable argument graph)
        parsimony_penalty = self.beta * min(1.0, complexity_ratio / 5.0)

        # Combine terms and clamp the final score to the valid [0, 1] range.
        raw_score = novelty_term - parsimony_penalty
        final_score = np.clip(raw_score, 0, 1)

        explanation = f"Score({final_score:.3f}) = α*Novelty({novelty_term:.3f}) - β*Parsimony({parsimony_penalty:.3f}). Min dist: {min_dist_str}."
        return CriticResult(
            score=final_score, confidence=0.9, explanation=explanation,
            evidence={'novelty_term': novelty_term, 'parsimony_penalty': parsimony_penalty},
            sub_scores={'novelty_score': novelty_score, 'complexity_ratio': complexity_ratio}
        )

Roadmap to a GNN-based Logic Critic

The heuristic-based LogicCritic is a functional and transparent starting point. However, the research proposal correctly identifies that a Graph Neural Network (GNN) is the state-of-the-art solution.

Why a GNN is the Next Step: Hand-coded heuristics can only capture simple structural flaws. A GNN, in contrast, can learn subtle, complex, and non-local patterns of faulty reasoning directly from data. By training on a dataset of valid and fallacious argument graphs, a GNN can learn to identify sophisticated weaknesses like:

• Missing Warrants: Implicit logical leaps between claims.
• Fallacies of Relevance: Arguments where the support is only superficially related to the conclusion.
• Complex Circular Reasoning: Logical loops that span multiple nodes and are hard to detect with simple cycle checks.

A GNN-based critic moves from a “rules-based” system to a “learning-based” system, dramatically increasing the sophistication and accuracy of the logic evaluation.

Conceptual GNN Implementation (PyTorch & PyG): Below is a conceptual skeleton of what a GNN-based LogicCritic might look like using PyTorch and the PyTorch Geometric (PyG) library, which is specialized for GNNs.

# You would need to install: pip install torch torch-geometric
import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv, global_mean_pool
from torch_geometric.data import Data

class GNNLogicModel(torch.nn.Module):
    """A simple Graph Convolutional Network (GCN) for graph classification."""
    def __init__(self, num_node_features, hidden_channels):
        super().__init__()
        self.conv1 = GCNConv(num_node_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, hidden_channels)
        # A linear layer for the final graph-level classification
        self.lin = torch.nn.Linear(hidden_channels, 1)

    def forward(self, x, edge_index, batch):
        # 1. Obtain node embeddings
        x = self.conv1(x, edge_index).relu()
        x = self.conv2(x, edge_index).relu()

        # 2. Global Pooling: Aggregate node features to get a graph-level embedding
        x = global_mean_pool(x, batch)

        # 3. Apply a final classifier to get a single score for the graph
        x = self.lin(x)

        # Apply sigmoid to get a score between 0 and 1
        return torch.sigmoid(x)

def convert_sno_to_graph_data(sno: StructuredNarrativeObject, embedding_model) -> Data:
    """Converts our NetworkX graph into a PyG Data object for the GNN."""
    G = sno.reasoning_graph

    # Create node features (e.g., from claim embeddings)
    node_features = []
    node_map = {node_id: i for i, node_id in enumerate(G.nodes())}
    for node_id in G.nodes():
        claim_content = G.nodes[node_id]['claim'].content
        # In a real implementation, you'd use pre-computed embeddings
        embedding = embedding_model.encode(claim_content)
        node_features.append(embedding)

    x = torch.tensor(np.array(node_features), dtype=torch.float)

    # Create edge index
    edge_list = [[node_map[u], node_map[v]] for u, v in G.edges()]
    edge_index = torch.tensor(edge_list, dtype=torch.long).t().contiguous()

    return Data(x=x, edge_index=edge_index)

# --- Conceptual Training Loop ---
# This would not run in the guide, but shows the process.
def train_gnn_critic(model, train_loader, optimizer, criterion):
    model.train()
    for data in train_loader: # train_loader yields batches of graph Data objects
        optimizer.zero_grad()
        out = model(data.x, data.edge_index, data.batch)
        # `data.y` would be the ground-truth label (0 for fallacious, 1 for valid)
        loss = criterion(out, data.y.unsqueeze(1).float())
        loss.backward()
        optimizer.step()

# --- The GNN-based Critic Class ---
class GNNLogicCritic(BaseCritic):
    def __init__(self, weight: float, model_path: str, embedding_model):
        super().__init__(CriticType.LOGIC, weight)
        self.model = GNNLogicModel(num_node_features=768, hidden_channels=64) # Example dimensions
        self.model.load_state_dict(torch.load(model_path))
        self.model.eval() # Set model to evaluation mode
        self.embedding_model = embedding_model

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        graph_data = convert_sno_to_graph_data(sno, self.embedding_model)

        with torch.no_grad():
            score = self.model(graph_data.x, graph_data.edge_index, torch.zeros(graph_data.num_nodes, dtype=torch.long)).item()

        return CriticResult(
            score=score,
            confidence=0.95, # Assuming a well-trained model
            explanation=f"GNN-based logical coherence score: {score:.3f}"
        )

This roadmap illustrates the clear, principled path from our initial heuristic-based critic to a much more powerful, learned system, which is a core theme of the CNS 2.0 research philosophy.

Contextual Evaluation: Dynamic Weight Adjustment

A key feature of CNS 2.0 is its adaptability. By adjusting the weights $w_i$ in the main reward formula, we can change the system’s “priorities” to suit different phases of knowledge discovery.

# --- Setup: Create a sample SNO and a pipeline ---
# This code assumes the classes from previous chapters are available.

# 1. Create a mock SNO. Let's imagine this is a very new, slightly underdeveloped idea.
#    We will manually set the scores each critic *would* produce for demonstration.
class MockCritic(BaseCritic):
    def __init__(self, critic_type, weight, mock_score):
        super().__init__(critic_type, weight)
        self.mock_score = mock_score
    def evaluate(self, sno, context=None):
        return CriticResult(score=self.mock_score, confidence=1.0, explanation="Mocked result")

# Our SNO is very novel (0.9) but has weak logic (0.4) and grounding (0.5)
pipeline = CriticPipeline()
pipeline.add_critic(MockCritic(CriticType.NOVELTY, 1.0, 0.9))
pipeline.add_critic(MockCritic(CriticType.LOGIC, 1.0, 0.4))
pipeline.add_critic(MockCritic(CriticType.GROUNDING, 1.0, 0.5))
sample_sno = StructuredNarrativeObject(central_hypothesis="A sample SNO for testing.")

# --- Phase 1: Exploration Mode ---
# We want to find new ideas, so we heavily weight novelty.
print("--- EVALUATING IN EXPLORATION MODE ---")
pipeline.adjust_weights({
    CriticType.NOVELTY: 0.8,   # High weight for new ideas
    CriticType.LOGIC: 0.1,     # Low weight for rigor
    CriticType.GROUNDING: 0.1  # Low weight for rigor
})
exploration_result = pipeline.evaluate_sno(sample_sno)
print(f"Final Trust Score (Exploration): {exploration_result['trust_score']:.4f}\n")

# --- Phase 2: Verification Mode ---
# Now, we shift to rigorously checking our ideas.
print("--- EVALUATING IN VERIFICATION MODE ---")
pipeline.adjust_weights({
    CriticType.NOVELTY: 0.1,    # Low weight for novelty
    CriticType.LOGIC: 0.45,     # High weight for logical soundness
    CriticType.GROUNDING: 0.45  # High weight for evidential support
})
verification_result = pipeline.evaluate_sno(sample_sno)
print(f"Final Trust Score (Verification): {verification_result['trust_score']:.4f}\n")

As the output shows, the same SNO is considered high-trust in exploration mode but fails the quality bar in verification mode. This ability to programmatically shift the system’s “values” is a practical tool for guiding the knowledge discovery process, making CNS 2.0 a powerful and flexible framework.

Try It Now: Evaluate an SNO with the Critic Pipeline

Goal: Build a working critic pipeline and evaluate the SNO from Chapter 2 in 10 minutes.

Prerequisites

• Completed Chapter 2 and created a complete SNO
• Virtual environment activated with all dependencies installed

Step 1: Save the Complete Critic Example

Note: This example includes simplified implementations of the critic classes for demonstration purposes. The GroundingCritic uses basic heuristics (evidence-to-claims ratio) rather than the full NLI model described in the main chapter. The LogicCritic uses NetworkX graph analysis rather than a trained GNN. This allows you to run the code immediately without training models, while understanding the core evaluation logic.

Create a file called evaluate_with_critics.py:

"""
Critic Pipeline Example: Evaluating SNO Quality
Demonstrates the multi-component critic pipeline evaluating an SNO.
"""

from sentence_transformers import SentenceTransformer
import networkx as nx
import numpy as np
from datetime import datetime
from dataclasses import dataclass
from typing import Optional, Set, Dict, Any, List
from enum import Enum
import uuid
import hashlib

print("="*70)
print("CNS 2.0 CRITIC PIPELINE DEMONSTRATION")
print("="*70)

# Step 1: Load model and recreate data structures from Chapter 2
print("\n[Step 1/5] Loading embedding model and data structures...")
model = SentenceTransformer('all-MiniLM-L6-v2')

class RelationType(Enum):
    SUPPORTS = "supports"
    CONTRADICTS = "contradicts"
    IMPLIES = "implies"
    WEAKENS = "weakens"
    EXPLAINS = "explains"

@dataclass
class EvidenceItem:
    content: str
    source_id: str
    doc_hash: Optional[str] = None
    confidence: float = 1.0

    def __post_init__(self):
        if self.doc_hash is None:
            self.doc_hash = hashlib.sha256(self.content.encode()).hexdigest()[:16]

    def __hash__(self):
        return hash(self.doc_hash)

    def __eq__(self, other):
        return isinstance(other, EvidenceItem) and self.doc_hash == other.doc_hash

@dataclass
class ClaimNode:
    claim_id: str
    content: str  # Using 'content' to match main Chapter 2 definition
    embedding: Optional[np.ndarray] = None
    confidence: float = 1.0

@dataclass
class ReasoningEdge:
    relation_type: RelationType
    strength: float = 1.0
    evidence_refs: Set[str] = None

class StructuredNarrativeObject:
    def __init__(self, central_hypothesis: str, sno_id: Optional[str] = None):
        self.sno_id = sno_id or str(uuid.uuid4())[:8]
        self.central_hypothesis = central_hypothesis
        self.hypothesis_embedding: Optional[np.ndarray] = None
        self.reasoning_graph = nx.DiGraph()
        self.evidence_set: Set[EvidenceItem] = set()
        self.trust_score: Optional[float] = None
        self.created_at = datetime.now()
        self.metadata: Dict[str, Any] = {}

    def compute_hypothesis_embedding(self, model):
        self.hypothesis_embedding = model.encode(self.central_hypothesis)
        return self.hypothesis_embedding

    def add_claim(self, claim_id: str, content: str, confidence: float = 1.0):
        claim = ClaimNode(claim_id=claim_id, content=content, confidence=confidence)
        self.reasoning_graph.add_node(claim_id, claim=claim)

    def add_reasoning_edge(self, source: str, target: str, relation: RelationType, strength: float = 1.0):
        edge = ReasoningEdge(relation_type=relation, strength=strength)
        self.reasoning_graph.add_edge(source, target, reasoning_edge=edge)

    def add_evidence(self, content: str, source_id: str, confidence: float = 1.0):
        evidence = EvidenceItem(content=content, source_id=source_id, confidence=confidence)
        self.evidence_set.add(evidence)
        return evidence.doc_hash

print("✓ Data structures ready")

# Step 2: Create a sample SNO (reusing Coffee example from Chapter 2)
print("\n[Step 2/5] Creating sample SNO...")
sno = StructuredNarrativeObject(
    central_hypothesis="Coffee consumption improves programming productivity through enhanced cognitive performance"
)

# Build reasoning graph
sno.add_claim("c1", "Caffeine blocks adenosine receptors", 0.95)
sno.add_claim("c2", "Adenosine causes drowsiness", 0.95)
sno.add_claim("c3", "Blocking adenosine increases alertness", 0.90)
sno.add_claim("c4", "Alertness improves sustained attention", 0.85)
sno.add_claim("c5", "Sustained attention is critical for programming", 0.90)
sno.add_claim("c6", "Therefore, coffee improves programming productivity", 0.80)

sno.add_reasoning_edge("c1", "c3", RelationType.SUPPORTS, 0.9)
sno.add_reasoning_edge("c2", "c3", RelationType.SUPPORTS, 0.9)
sno.add_reasoning_edge("c3", "c4", RelationType.IMPLIES, 0.85)
sno.add_reasoning_edge("c4", "c5", RelationType.SUPPORTS, 0.85)
sno.add_reasoning_edge("c5", "c6", RelationType.IMPLIES, 0.80)

# Add evidence
sno.add_evidence(
    "Caffeine is an adenosine receptor antagonist (Fredholm et al., 1999)",
    "doi:10.1016/S0163-7258(99)00010-6",
    0.95
)
sno.add_evidence(
    "Adenosine accumulation promotes sleep pressure (Porkka-Heiskanen et al., 1997)",
    "doi:10.1126/science.276.5316.1265",
    0.95
)
sno.add_evidence(
    "Caffeine improves sustained attention (Lieberman et al., 2002)",
    "doi:10.1016/S0091-3057(01)00666-5",
    0.90
)

sno.compute_hypothesis_embedding(model)
print(f"✓ Created SNO: {sno.sno_id}")
print(f"  - {len(sno.reasoning_graph.nodes)} claims")
print(f"  - {len(sno.reasoning_graph.edges)} reasoning edges")
print(f"  - {len(sno.evidence_set)} evidence items")

# Step 3: Define Critic Classes
print("\n[Step 3/5] Defining critic pipeline components...")

class CriticType(Enum):
    GROUNDING = "grounding"
    LOGIC = "logic"
    NOVELTY = "novelty"

@dataclass
class CriticResult:
    score: float  # 0.0 to 1.0
    confidence: float
    explanation: str
    details: Dict[str, Any] = None

class BaseCritic:
    def __init__(self, critic_type: CriticType, weight: float = 1.0):
        self.critic_type = critic_type
        self.weight = weight
        self.eval_count = 0

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        raise NotImplementedError

class GroundingCritic(BaseCritic):
    """Evaluates how well the SNO is supported by evidence"""
    def __init__(self, weight: float = 1.0):
        super().__init__(CriticType.GROUNDING, weight)

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        self.eval_count += 1

        # Simplified grounding check: ratio of claims to evidence
        num_claims = len(sno.reasoning_graph.nodes)
        num_evidence = len(sno.evidence_set)

        if num_claims == 0:
            return CriticResult(0.0, 1.0, "No claims to evaluate")

        # Calculate evidence coverage ratio
        evidence_ratio = min(1.0, num_evidence / num_claims)

        # Average confidence of evidence
        avg_confidence = np.mean([e.confidence for e in sno.evidence_set]) if sno.evidence_set else 0.0

        # Combined score
        score = 0.7 * evidence_ratio + 0.3 * avg_confidence

        return CriticResult(
            score=score,
            confidence=0.85,
            explanation=f"Evidence ratio: {evidence_ratio:.2f}, Avg confidence: {avg_confidence:.2f}",
            details={"evidence_count": num_evidence, "claim_count": num_claims}
        )

class LogicCritic(BaseCritic):
    """Evaluates the structural coherence of the reasoning graph"""
    def __init__(self, weight: float = 1.0):
        super().__init__(CriticType.LOGIC, weight)

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        self.eval_count += 1

        G = sno.reasoning_graph

        if len(G.nodes) == 0:
            return CriticResult(0.0, 1.0, "No reasoning graph")

        # Check for cycles (DAG should have none)
        has_cycle = not nx.is_directed_acyclic_graph(G)
        cycle_penalty = 0.5 if has_cycle else 0.0

        # Check connectivity (weakly connected is good)
        is_connected = nx.is_weakly_connected(G) if len(G.nodes) > 1 else True
        connectivity_score = 1.0 if is_connected else 0.5

        # Check for orphaned nodes
        orphans = [n for n in G.nodes if G.in_degree(n) == 0 and G.out_degree(n) == 0]
        orphan_penalty = len(orphans) / len(G.nodes)

        # Parsimony: penalize excessive complexity
        avg_degree = sum(dict(G.degree()).values()) / len(G.nodes)
        complexity_penalty = min(0.3, (avg_degree - 2) * 0.1) if avg_degree > 2 else 0.0

        score = connectivity_score - cycle_penalty - orphan_penalty - complexity_penalty
        score = max(0.0, min(1.0, score))

        return CriticResult(
            score=score,
            confidence=0.90,
            explanation=f"Connectivity: {connectivity_score:.2f}, Cycles: {has_cycle}, Orphans: {len(orphans)}",
            details={
                "is_dag": not has_cycle,
                "is_connected": is_connected,
                "orphan_count": len(orphans),
                "avg_degree": avg_degree
            }
        )

class NoveltyParsimonyCritic(BaseCritic):
    """Evaluates novelty while penalizing excessive complexity"""
    def __init__(self, weight: float = 1.0, existing_embeddings: List[np.ndarray] = None):
        super().__init__(CriticType.NOVELTY, weight)
        self.existing_embeddings = existing_embeddings or []

    def evaluate(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> CriticResult:
        self.eval_count += 1

        if sno.hypothesis_embedding is None:
            return CriticResult(0.0, 0.5, "No embedding computed")

        # Novelty: minimum distance to existing SNOs
        if self.existing_embeddings:
            similarities = [
                np.dot(sno.hypothesis_embedding, emb) /
                (np.linalg.norm(sno.hypothesis_embedding) * np.linalg.norm(emb))
                for emb in self.existing_embeddings
            ]
            max_similarity = max(similarities)
            novelty_score = 1.0 - max_similarity
        else:
            novelty_score = 0.8  # Default for first SNO

        # Parsimony: penalize graph complexity
        num_nodes = len(sno.reasoning_graph.nodes)
        num_edges = len(sno.reasoning_graph.edges)
        complexity_ratio = num_edges / num_nodes if num_nodes > 0 else 0
        parsimony_penalty = min(0.3, complexity_ratio * 0.1)

        score = 0.7 * novelty_score + 0.3 * (1.0 - parsimony_penalty)

        return CriticResult(
            score=score,
            confidence=0.75,
            explanation=f"Novelty: {novelty_score:.2f}, Complexity ratio: {complexity_ratio:.2f}",
            details={
                "novelty_score": novelty_score,
                "complexity_ratio": complexity_ratio,
                "compared_to_n": len(self.existing_embeddings)
            }
        )

class CriticPipeline:
    """Manages multiple critics and computes composite trust score"""
    def __init__(self):
        self.critics: Dict[CriticType, BaseCritic] = {}

    def add_critic(self, critic: BaseCritic):
        self.critics[critic.critic_type] = critic

    def evaluate_sno(self, sno: StructuredNarrativeObject, context: Optional[Dict] = None) -> Dict[str, Any]:
        """Evaluate SNO with all critics and compute trust score"""
        results = {}
        weighted_sum = 0.0
        total_weight = 0.0

        for critic_type, critic in self.critics.items():
            result = critic.evaluate(sno, context)
            results[critic_type.value] = {
                'score': result.score,
                'confidence': result.confidence,
                'explanation': result.explanation,
                'details': result.details
            }
            weighted_sum += result.score * critic.weight
            total_weight += critic.weight

        trust_score = weighted_sum / total_weight if total_weight > 0 else 0.0
        sno.trust_score = trust_score

        return {
            'trust_score': trust_score,
            'individual_scores': results
        }

print("✓ Critic classes defined")

# Step 4: Create pipeline and evaluate
print("\n[Step 4/5] Evaluating SNO with critic pipeline...")

pipeline = CriticPipeline()
pipeline.add_critic(GroundingCritic(weight=0.4))
pipeline.add_critic(LogicCritic(weight=0.3))
pipeline.add_critic(NoveltyParsimonyCritic(weight=0.3))

evaluation = pipeline.evaluate_sno(sno)

print(f"✓ Evaluation complete")
print(f"\n{'='*70}")
print(f"EVALUATION RESULTS")
print(f"{'='*70}")
print(f"\nOverall Trust Score: {evaluation['trust_score']:.4f}")
print(f"\nIndividual Critic Scores:")

for critic_name, result in evaluation['individual_scores'].items():
    print(f"\n  {critic_name.upper()} Critic:")
    print(f"    Score: {result['score']:.4f}")
    print(f"    Confidence: {result['confidence']:.2f}")
    print(f"    Explanation: {result['explanation']}")
    if result['details']:
        print(f"    Details: {result['details']}")

# Step 5: Demonstrate contextual evaluation
print(f"\n{'='*70}")
print(f"CONTEXTUAL EVALUATION DEMONSTRATION")
print(f"{'='*70}")

# Exploration mode: favor novelty
print(f"\n[Exploration Mode] - Favoring novel ideas")
exploration_pipeline = CriticPipeline()
exploration_pipeline.add_critic(GroundingCritic(weight=0.1))
exploration_pipeline.add_critic(LogicCritic(weight=0.1))
exploration_pipeline.add_critic(NoveltyParsimonyCritic(weight=0.8))

exp_eval = exploration_pipeline.evaluate_sno(sno)
print(f"Trust Score (Exploration): {exp_eval['trust_score']:.4f}")

# Verification mode: favor grounding and logic
print(f"\n[Verification Mode] - Favoring rigor and evidence")
verification_pipeline = CriticPipeline()
verification_pipeline.add_critic(GroundingCritic(weight=0.45))
verification_pipeline.add_critic(LogicCritic(weight=0.45))
verification_pipeline.add_critic(NoveltyParsimonyCritic(weight=0.1))

ver_eval = verification_pipeline.evaluate_sno(sno)
print(f"Trust Score (Verification): {ver_eval['trust_score']:.4f}")

print(f"\n{'='*70}")
print(f"✓ CRITIC PIPELINE DEMONSTRATION COMPLETE")
print(f"{'='*70}")
print(f"\nKey Insights:")
print(f"  • Same SNO evaluated differently based on context")
print(f"  • Exploration mode: {exp_eval['trust_score']:.4f} (emphasizes novelty)")
print(f"  • Verification mode: {ver_eval['trust_score']:.4f} (emphasizes rigor)")
print(f"  • This flexibility allows CNS 2.0 to adapt to different phases")
print(f"\nWhat you just built:")
print(f"  ✓ Complete critic pipeline with 3 specialized critics")
print(f"  ✓ Grounding critic (evidence coverage)")
print(f"  ✓ Logic critic (structural coherence)")
print(f"  ✓ Novelty-Parsimony critic (innovation vs complexity)")
print(f"  ✓ Contextual evaluation (dynamic weight adjustment)")
print(f"\nNext: Chapter 4 - Synthesis engine and chiral pair detection")
print(f"{'='*70}")