class TraditionalLLM:
    """
    Traditional text generation
    
    Problem: No structure, just weights
    """
    def __init__(self):
        self.weights = load_weights()  # Billions of parameters
        self.training_corpus = None    # Opaque
        self.context_window = 4096     # Fixed limit
    
    def generate(self, prompt):
        """
        Generate from weights
        
        No visibility into:
        - Where knowledge came from
        - Which concepts are related
        - What domains are relevant
        - Why this response
        """
        # Black box forward pass
        tokens = self.tokenize(prompt)
        logits = self.forward(tokens)
        response = self.sample(logits)
        
        return response  # Hope it's good!

class GraphLLM:
    """
    Text generation from graph structure
    
    Benefits: Visible structure, explainable, scalable
    """
    def __init__(self, graph):
        self.graph = graph  # From Post 823
        self.universal_words = None
        self.domain_graph = None
    
    def generate(self, prompt, max_tokens=100):
        """
        Generate using graph structure
        
        Process:
        1. Parse prompt → extract key words
        2. Query graph → find relevant nodes
        3. Gather context → traverse links
        4. Assemble response → use structure
        5. Generate → with rich context
        """
        # Step 1: Parse prompt
        key_words = self.extract_keywords(prompt)
        
        # Step 2: Find nodes in graph
        relevant_nodes = []
        for word in key_words:
            node = self.find_node(word)
            if node:
                relevant_nodes.append(node)
        
        # Step 3: Gather context from graph
        context = self.gather_context(relevant_nodes)
        
        # Step 4: Generate with context
        response = self.generate_with_context(prompt, context)
        
        return {
            'response': response,
            'source_nodes': relevant_nodes,
            'domains': context['domains'],
            'confidence': self.calculate_confidence(context)
        }

def find_node(self, word, graph):
    """
    Find word node in graph
    
    Returns node with full history
    """
    # Direct lookup
    word_node = graph.get_node(f"word:{word}")
    
    if word_node:
        return {
            'word': word,
            'type': word_node['type'],
            'series': word_node['series'],  # Evolution history
            'links': word_node['links'],    # Domain connections
            'frequency': len(word_node['series']),
            'universality': self.calculate_universality(word_node)
        }
    
    return None

def calculate_universality(self, word_node):
    """
    How many domains is this word connected to?
    
    Universal words = connected to many domains
    """
    domain_links = [
        link for link in word_node['links']
        if link['to'].startswith('domain:')
    ]
    
    total_domains = len(self.get_all_domains())
    connected_domains = len(domain_links)
    
    return connected_domains / total_domains

# Query "system"
system_node = find_node("system", graph)

# Returns:
{
    'word': 'system',
    'frequency': 247,  # Appeared 247 times
    'universality': 0.85,  # In 85% of domains
    'domains': [
        {'name': 'math', 'weight': 45},
        {'name': 'physics', 'weight': 38},
        {'name': 'programming', 'weight': 52},
        {'name': 'biology', 'weight': 31},
        # ... 17 domains total
    ]
}

def gather_context(self, relevant_nodes, graph, depth=2):
    """
    Gather context by traversing graph
    
    Start from relevant nodes, follow links
    """
    context = {
        'words': {},
        'domains': {},
        'relationships': [],
        'universal_concepts': []
    }
    
    for node in relevant_nodes:
        # Add this node
        context['words'][node['word']] = node
        
        # Follow links (depth=1)
        for link in node['links']:
            linked_node = graph.get_node(link['to'])
            
            if linked_node['type'] == 'domain':
                # Add domain context
                domain_name = linked_node['name']
                if domain_name not in context['domains']:
                    context['domains'][domain_name] = {
                        'node': linked_node,
                        'words': [],
                        'weight': 0
                    }
                
                context['domains'][domain_name]['words'].append(node['word'])
                context['domains'][domain_name]['weight'] += link['weight']
            
            elif linked_node['type'] == 'word':
                # Related word
                context['relationships'].append({
                    'from': node['word'],
                    'to': linked_node['name'],
                    'weight': link['weight']
                })
                
                # If universal, add to concepts
                if linked_node.get('universality', 0) > 0.6:
                    context['universal_concepts'].append(linked_node['name'])
        
        # Follow links (depth=2)
        if depth > 1:
            for link in node['links']:
                linked_node = graph.get_node(link['to'])
                # Recurse with depth-1
                sub_context = self.gather_context([linked_node], graph, depth-1)
                # Merge sub_context into context
                self.merge_contexts(context, sub_context)
    
    return context

# Query: "How do systems evolve?"
key_words = ["system", "evolve"]

# Find nodes
nodes = [find_node(w, graph) for w in key_words]

# Gather context (depth=2)
context = gather_context(nodes, graph, depth=2)

# Returns:
{
    'words': {
        'system': {...},
        'evolve': {...}
    },
    'domains': {
        'biology': {'weight': 45, 'words': ['system', 'evolve']},
        'physics': {'weight': 38, 'words': ['system']},
        'programming': {'weight': 31, 'words': ['system', 'evolve']}
    },
    'relationships': [
        {'from': 'system', 'to': 'structure', 'weight': 23},
        {'from': 'system', 'to': 'function', 'weight': 18},
        {'from': 'evolve', 'to': 'adapt', 'weight': 15}
    ],
    'universal_concepts': ['structure', 'function', 'process']
}

def generate_with_context(self, prompt, context, llm):
    """
    Generate text using graph context
    
    Context guides generation for better quality
    """
    # Build enriched prompt
    enriched_prompt = self.build_enriched_prompt(prompt, context)
    
    # Generate with LLM
    response = llm.generate(enriched_prompt)
    
    return response

def build_enriched_prompt(self, prompt, context):
    """
    Enrich prompt with graph context
    
    Add:
    - Relevant domains
    - Universal concepts
    - Related words
    """
    # Start with original
    enriched = f"Question: {prompt}\n\n"
    
    # Add domain context
    if context['domains']:
        enriched += "Relevant domains:\n"
        for domain, info in sorted(
            context['domains'].items(), 
            key=lambda x: x[1]['weight'], 
            reverse=True
        )[:3]:  # Top 3 domains
            enriched += f"- {domain} (relevance: {info['weight']})\n"
        enriched += "\n"
    
    # Add universal concepts
    if context['universal_concepts']:
        enriched += "Key concepts:\n"
        for concept in context['universal_concepts'][:5]:
            enriched += f"- {concept}\n"
        enriched += "\n"
    
    # Add relationships
    if context['relationships']:
        enriched += "Related concepts:\n"
        for rel in sorted(
            context['relationships'], 
            key=lambda x: x['weight'], 
            reverse=True
        )[:5]:
            enriched += f"- {rel['from']} → {rel['to']}\n"
        enriched += "\n"
    
    enriched += "Answer based on this context:"
    
    return enriched

# Original prompt
prompt = "How do systems evolve?"

# With graph context
enriched_prompt = """
Question: How do systems evolve?

Relevant domains:
- biology (relevance: 45)
- physics (relevance: 38)
- programming (relevance: 31)

Key concepts:
- structure
- function
- process
- adaptation
- entropy

Related concepts:
- system → structure
- system → function
- evolve → adapt
- evolve → change
- structure → organization

Answer based on this context:
"""

# Generate
response = llm.generate(enriched_prompt)

# Traditional LLM
response = llm.generate("Explain networks")
# → Generic answer, no domain context

# Graph-based
context = gather_context(["networks"], graph)
# → Discovers: computer networks (40%), social networks (30%), neural networks (30%)
response = llm.generate(enriched_prompt)
# → Asks for clarification or covers all three

# Traditional LLM
# No visibility into concept relationships

# Graph-based
universal = find_universal_concepts(graph)
# → ['system', 'structure', 'function', 'process', 'relation']
# → Can emphasize these in generation
# → Better coherence across domains

# Traditional LLM
# Black box connections

# Graph-based
related = find_related_words("evolution", graph)
# → ['adapt', 'change', 'selection', 'fitness', 'mutation']
# → Visible structure guides generation
# → Can explain reasoning

# Traditional LLM
# No confidence (just generates)

# Graph-based
confidence = calculate_confidence(context)
# → High if many strong links
# → Low if sparse connections
# → Can refuse to answer if confidence < threshold

class GraphGenerativeAI:
    """
    Complete graph-based text generation
    
    From Post 823 graph → Better generation
    """
    def __init__(self, graph, base_llm):
        self.graph = graph
        self.base_llm = base_llm
        self.cache = {}
    
    def answer(self, question, min_confidence=0.7):
        """
        Answer question using graph context
        """
        # Step 1: Parse question
        key_words = self.extract_keywords(question)
        
        # Step 2: Find nodes
        nodes = [self.find_node(w) for w in key_words if self.find_node(w)]
        
        if not nodes:
            return {
                'answer': "I don't have context for this question.",
                'confidence': 0.0,
                'source': 'no_nodes_found'
            }
        
        # Step 3: Gather context
        context = self.gather_context(nodes, depth=2)
        
        # Step 4: Calculate confidence
        confidence = self.calculate_confidence(context)
        
        if confidence < min_confidence:
            return {
                'answer': f"Low confidence ({confidence:.2f}). Need more context.",
                'confidence': confidence,
                'source': 'insufficient_context'
            }
        
        # Step 5: Build enriched prompt
        enriched = self.build_enriched_prompt(question, context)
        
        # Step 6: Generate
        response = self.base_llm.generate(enriched)
        
        # Step 7: Return with metadata
        return {
            'answer': response,
            'confidence': confidence,
            'source_nodes': [n['word'] for n in nodes],
            'domains': list(context['domains'].keys()),
            'universal_concepts': context['universal_concepts'],
            'explanation': self.explain_reasoning(context)
        }
    
    def calculate_confidence(self, context):
        """
        Confidence from graph structure
        
        High confidence when:
        - Many strong links
        - Multiple domains
        - Universal concepts present
        """
        # Domain coverage
        domain_score = min(len(context['domains']) / 5.0, 1.0)  # 5+ domains = 1.0
        
        # Link strength
        total_weight = sum(d['weight'] for d in context['domains'].values())
        link_score = min(total_weight / 100.0, 1.0)  # 100+ weight = 1.0
        
        # Universal concepts
        universal_score = min(len(context['universal_concepts']) / 3.0, 1.0)  # 3+ concepts = 1.0
        
        # Weighted average
        confidence = (
            domain_score * 0.4 +
            link_score * 0.4 +
            universal_score * 0.2
        )
        
        return confidence
    
    def explain_reasoning(self, context):
        """
        Explain why this answer (transparency)
        """
        explanation = []
        
        # Domains used
        explanation.append(
            f"Drew from {len(context['domains'])} domains: " +
            ", ".join(context['domains'].keys())
        )
        
        # Concepts used
        if context['universal_concepts']:
            explanation.append(
                f"Used universal concepts: " +
                ", ".join(context['universal_concepts'][:3])
            )
        
        # Confidence
        confidence = self.calculate_confidence(context)
        explanation.append(f"Confidence: {confidence:.0%}")
        
        return " | ".join(explanation)

ai = GraphGenerativeAI(graph, llm)

result = ai.answer("What is a hash function in cryptography?")

# {
#   'answer': "A hash function in cryptography is a one-way function that...",
#   'confidence': 0.92,
#   'source_nodes': ['hash', 'function', 'cryptography'],
#   'domains': ['cryptography', 'computer-science', 'mathematics'],
#   'universal_concepts': ['function', 'security', 'algorithm'],
#   'explanation': "Drew from 3 domains: cryptography, computer-science, mathematics | Used universal concepts: function, security, algorithm | Confidence: 92%"
# }

result = ai.answer("Explain networks")

# Graph detects multiple domains:
# - computer networks (40%)
# - social networks (30%)
# - neural networks (30%)

# {
#   'answer': "Networks can refer to several concepts. In computer science, networks are..., in social science, networks are..., in AI, neural networks are...",
#   'confidence': 0.85,
#   'domains': ['computer-science', 'social-science', 'ai'],
#   'explanation': "Multiple domains detected | Provided comprehensive answer"
# }

result = ai.answer("What is quantum chromodynamics?")

# No nodes found for "chromodynamics"
# {
#   'answer': "Low confidence (0.12). Need more context.",
#   'confidence': 0.12,
#   'source': 'insufficient_context'
# }

# Better than hallucinating!

traditional_problems = {
    'context_window': '4K-32K tokens max',
    'memory': 'All in weights (billions of params)',
    'updates': 'Retrain entire model',
    'storage': '100GB+ model file',
    'inference': 'Expensive GPU required'
}

graph_benefits = {
    'context_window': 'Unlimited (traverse graph)',
    'memory': 'Distributed nodes (add incrementally)',
    'updates': 'Add nodes/links (no retraining)',
    'storage': '~500KB graph + small LLM',
    'inference': 'CPU sufficient (graph traversal cheap)'
}

# Add new knowledge
new_domain = create_node('domain', 'quantum-physics')
new_words = ['qubit', 'superposition', 'entanglement']

for word in new_words:
    word_node = create_node('word', word)
    create_link(word_node, new_domain, weight=1)
    graph.append(word_node)

# Done! No retraining needed
# Next query can use quantum physics context

class HybridAI:
    """
    Graph for context + LLM for generation
    
    Combines structure + fluency
    """
    def __init__(self, graph, llm):
        self.graph = graph
        self.llm = llm
    
    def answer(self, question):
        """
        Hybrid generation
        
        1. Graph finds context (structure)
        2. LLM generates text (fluency)
        """
        # Graph provides structure
        context = self.query_graph(question)
        
        # LLM provides fluency
        response = self.llm.generate_with_context(question, context)
        
        return {
            'answer': response,
            'reasoning': self.graph.explain(context),
            'confidence': self.graph.confidence(context)
        }

def query_distributed_graph(word, r3_network):
    """
    Query graph stored in R³
    
    From Post 823: Each node = series in R³
    """
    # Load word node from R³
    word_node = r3_network.load(f"node:word:{word}")
    
    # Load linked domains (parallel)
    domain_links = word_node['links']
    domains = r3_network.load_parallel([
        link['to'] for link in domain_links
    ])
    
    # Build context
    context = {
        'word': word_node,
        'domains': domains,
        'confidence': calculate_confidence_from_links(domain_links)
    }
    
    return context