Chapter 1: Introduction to CNS 2.0

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