# Create virtual environment
python -m venv cns-env

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

# On Windows:
cns-env\Scripts\activate

# 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

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

"""
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)

python first_sno.py

hypothesis = "Coffee improves programming productivity"

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

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

# 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}")

pip install torch

pip install sentence-transformers

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

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

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

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

# 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

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

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]}")

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

# --- 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]

# --- 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.")

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
}

# 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))

"""
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/")

python test\_chapter1.py

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

    @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

"""
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)

python build_complete_sno.py

"""
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)

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
        )

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
        )

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}
        )

# 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}"
        )

# --- 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")

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