Chapter 1: Introduction to CNS 2.0

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