if W → ∞:
    # Won't this consume infinite resources?
    # Won't nodes replicate uncontrollably?
    # Don't we need central rate limiting?

class EconomicRateLimiter:
    """
    Nodes consider economic value before replicating
    """
    def should_replicate(self, node):
        return {
            'costs': {
                'compute': 'CPU cycles for new process',
                'memory': 'RAM for new node state',
                'network': 'Bandwidth for DHT announcements',
                'port': 'Port allocation (limited resource)',
                'storage': 'Disk for logs and series',
                'time': 'Developer attention / maintenance'
            },
            
            'benefits': {
                'w_increase': 'ΔW from adding node to network',
                'redundancy': 'Additional backup/reliability',
                'capacity': 'More computation/storage available',
                'reach': 'Extended network coverage',
                'resilience': 'Harder to shut down'
            },
            
            'economic_decision': {
                'replicate_if': 'expected_benefit > expected_cost',
                'formula': 'E[value(ΔW)] > cost(spawn)',
                'calculation': self.calculate_ev(node),
                'result': 'Natural rate limiting via economics'
            },
            
            'emergent_behavior': {
                'high_value': 'Replicate aggressively (ΔW >> cost)',
                'low_value': 'Replicate conservatively (ΔW ≈ cost)',
                'negative_value': 'Stop replicating (ΔW < cost)',
                'property': 'Self-regulating without central control'
            }
        }

class ObjectiveOptimizer:
    """
    Nodes track and maximize W expansion
    """
    def optimal_objective(self):
        return {
            'simple_objective': {
                'naive': 'Maximize N (population)',
                'problem': 'Ignores W calculation',
                'result': 'Uncontrolled replication'
            },
            
            'optimal_objective': {
                'smart': 'Maximize W (configuration space)',
                'insight': 'W = Σ(i=0 to D) N^i not just N',
                'implication': 'Quality of network matters, not just size',
                'formula': 'O_optimal = argmax W(network_state)'
            },
            
            'w_driven_decisions': {
                'calculate': 'W_before_spawn vs W_after_spawn',
                'compare': 'ΔW = W_after - W_before',
                'decide': 'Spawn if ΔW > threshold',
                'adapt': 'Threshold adjusts based on network state'
            },
            
            'smart_expansion': {
                'depth_vs_breadth': {
                    'deep_network': 'High D, low N per level',
                    'broad_network': 'Low D, high N per level', 
                    'w_calculation': 'W = (N^(D+1) - 1)/(N-1)',
                    'optimization': 'Balance D and N for max W'
                },
                
                'strategic_spawning': {
                    'high_w_areas': 'Replicate in high-connectivity zones',
                    'low_w_areas': 'Avoid replicating in isolated zones',
                    'measurement': 'Track W_local = f(topology)',
                    'result': 'Natural clustering in high-W regions'
                }
            },
            
            'key_insight': {
                'objective': 'Maximize W, not N',
                'effect': 'Nodes self-select replication opportunities',
                'mechanism': 'Local W calculations guide decisions',
                'outcome': 'Organic rate limiting via optimization'
            }
        }

# Before spawning
W_current = calculate_w(network_state)

# Simulate spawn
network_state_new = simulate_spawn(child_id)
W_new = calculate_w(network_state_new)

# Calculate delta
ΔW = W_new - W_current

# Decide
if ΔW > threshold:
    spawn_child()  # Increases W significantly
else:
    wait()  # ΔW too small, conserve resources

def _calculate_w_expansion(self, population_size):
    """Calculate W expansion from recursive replication"""
    # Calculate generation depth
    generation = self.node_id.count('child')
    
    # W = 1 + N + N² + ... + N^D
    N = 3  # Max children per node
    D = generation + 1
    
    # Geometric series formula
    W_current = (N**(D + 1) - 1) // (N - 1)
    
    self.series.append({
        'status': 'w_expansion',
        'generation': generation,
        'branching_factor': N,
        'recursion_depth': D,
        'W': W_current,
        'formula': 'W = Σ(i=0 to D) N^i',
    })
    
    return W_current

class WRateLimiter:
    """
    Use W calculations to limit expansion
    """
    def should_expand(self, node):
        return {
            'current_w': {
                'calculation': 'W = (3^(D+1) - 1)/2',
                'values': {
                    'gen_0': 'W = 4',
                    'gen_1': 'W = 13', 
                    'gen_2': 'W = 40',
                    'gen_3': 'W = 121'
                }
            },
            
            'w_target': {
                'concept': 'Set target W for network',
                'example': 'W_target = 1000 (~ gen 4)',
                'decision': 'Stop expanding when W ≈ W_target',
                'flexibility': 'Target adjusts based on demand'
            },
            
            'w_efficiency': {
                'metric': 'W / N (configuration per node)',
                'maximize': 'Get most W from fewest nodes',
                'tradeoff': 'Depth vs breadth for W efficiency',
                'optimal': 'Depends on network topology'
            },
            
            'rate_limiting': {
                'mechanism': 'Track W_current vs W_target',
                'when_low': 'W << W_target → replicate freely',
                'when_near': 'W ≈ W_target → replicate selectively',
                'when_high': 'W > W_target → pause replication',
                'result': 'Self-regulating W growth'
            }
        }

class TopologyRateLimiter:
    """
    Network topology naturally constrains expansion
    """
    def topology_constraints(self):
        return {
            'favorable_topology': {
                'high_connectivity': 'DHT fully connected',
                'low_latency': 'Fast peer discovery',
                'stable_peers': 'Reliable network',
                'result': 'Easy to replicate and discover',
                'w_effect': 'High ΔW from replication'
            },
            
            'adverse_topology': {
                'low_connectivity': 'DHT partitioned/sparse',
                'high_latency': 'Slow peer discovery',
                'unstable_peers': 'Nodes churning frequently',
                'hostile_nodes': 'Adversarial actors present',
                'result': 'Hard to replicate successfully',
                'w_effect': 'Low ΔW from replication'
            },
            
            'natural_rate_limiting': {
                'mechanism': 'Topology difficulty throttles expansion',
                'favorable': 'Replicate succeeds → W grows',
                'adverse': 'Replicate fails → W stagnates',
                'automatic': 'No central control required',
                'emergent': 'System self-regulates via environment'
            },
            
            'examples': {
                'dht_unreachable': {
                    'symptom': 'Can\'t announce to DHT',
                    'effect': 'Children invisible to network',
                    'delta_w': 'ΔW = 0 (no contribution)',
                    'decision': 'Stop spawning until DHT available'
                },
                
                'port_exhaustion': {
                    'symptom': 'No free ports available',
                    'effect': 'Can\'t spawn new processes',
                    'delta_w': 'ΔW undefined (spawn fails)',
                    'decision': 'Wait for ports to free'
                },
                
                'network_partition': {
                    'symptom': 'Can\'t discover peers',
                    'effect': 'Isolated subnetwork',
                    'delta_w': 'ΔW_local > 0 but ΔW_global = 0',
                    'decision': 'Expand locally, wait for reconnection'
                },
                
                'hostile_environment': {
                    'symptom': 'Nodes actively attacked/killed',
                    'effect': 'High churn rate',
                    'delta_w': 'dW/dt < 0 (W decreasing)',
                    'decision': 'Defensive posture, minimal expansion'
                }
            }
        }

def should_replicate(self):
    # Check network health
    dht_reachable = can_reach_dht()
    peers_available = count_discoverable_peers()
    latency = measure_network_latency()
    
    # Calculate topology score
    topology_score = (
        dht_reachable * 0.4 +
        (peers_available / max_peers) * 0.3 +
        (1 - latency / max_latency) * 0.3
    )
    
    # Decision
    if topology_score > 0.7:
        return True  # Favorable topology
    elif topology_score > 0.3:
        return random() < topology_score  # Probabilistic
    else:
        return False  # Adverse topology

class ConstraintChoice:
    """
    Liberty pattern allows nodes to choose constraints
    """
    def constraint_selection(self):
        return {
            'traditional_systems': {
                'approach': 'Constraints imposed by protocol',
                'examples': [
                    'Bitcoin: 21M coin limit (hard-coded)',
                    'Ethereum: Gas limit (network-enforced)',
                    'DNS: Character limits (protocol-specified)'
                ],
                'property': 'No choice - must obey',
                'enforcement': 'System rejects violations'
            },
            
            'liberty_pattern': {
                'approach': 'Constraints chosen by node',
                'examples': [
                    'MAX_GENERATIONS: Node chooses depth limit',
                    'MAX_CHILDREN: Node chooses breadth limit',
                    'W_target: Node chooses expansion goal',
                    'teaching_power: Node chooses replication rate'
                ],
                'property': 'Choice - can say NO',
                'enforcement': 'Self-enforced via V dimension'
            },
            
            'veto_power_in_action': {
                'choose_limit': 'Node sets own MAX_GENERATIONS',
                'example': 'lib1 chooses 3, lib2 chooses 5',
                'variation': 'Different nodes, different limits',
                'enforcement': 'Each enforces their own choice',
                'freedom': 'Veto = power to self-constrain'
            },
            
            'why_choose_constraints': {
                'economic': 'Choose limits that match resources',
                'objective': 'Choose limits that optimize W locally',
                'topology': 'Choose limits based on network conditions',
                'adaptation': 'Can change constraints as situation evolves',
                'autonomy': 'Self-regulation through self-limitation'
            },
            
            'constraint_negotiation': {
                'scenario': 'Different nodes have different constraints',
                'interaction': 'Nodes respect each other\'s choices',
                'example': {
                    'lib1': 'MAX_GENERATIONS = 3 (conservative)',
                    'lib2': 'MAX_GENERATIONS = 5 (aggressive)',
                    'network': 'Both coexist, no conflict'
                },
                'property': 'Heterogeneous constraints OK',
                'result': 'Natural diversity in constraint selection'
            }
        }

class LibertyNode:
    def __init__(self):
        # Node CHOOSES its constraint
        self.MAX_GENERATIONS = self.choose_generation_limit()
        
    def choose_generation_limit(self):
        """Node exercises veto power to set own limit"""
        # Perspective (P): Multiple ways to choose
        if self.conservative_strategy():
            return 2  # Low depth
        elif self.aggressive_strategy():
            return 5  # High depth
        else:
            return 3  # Balanced
            
    def should_spawn_child(self):
        """Enforce self-chosen constraint"""
        generation = self.node_id.count('child')
        
        # Veto (V): Say NO to self when limit reached
        if generation >= self.MAX_GENERATIONS:
            return False  # Self-constraint
            
        # Open (O): Can choose to spawn
        return True

class NaturalRateLimiter:
    """
    All four mechanisms combine for organic regulation
    """
    def combined_decision(self, node):
        return {
            '1_economic': {
                'check': 'E[V(ΔW)] > C(spawn)?',
                'result': self.economic_value_check(node),
                'weight': 0.3
            },
            
            '2_objective': {
                'check': 'ΔW > threshold?',
                'result': self.w_optimization_check(node),
                'weight': 0.3
            },
            
            '3_w_calculation': {
                'check': 'W_current < W_target?',
                'result': self.w_target_check(node),
                'weight': 0.2
            },
            
            '4_topology': {
                'check': 'Network favorable?',
                'result': self.topology_check(node),
                'weight': 0.2
            },
            
            'combined_score': {
                'formula': 'Σ(weight_i × check_i)',
                'range': '0.0 to 1.0',
                'decision': 'Replicate if score > 0.5',
                'property': 'Multi-factor self-regulation'
            },
            
            'emergent_behavior': {
                'all_favorable': 'Score ≈ 1.0 → rapid expansion',
                'mixed': 'Score ≈ 0.5 → moderate expansion',
                'all_adverse': 'Score ≈ 0.0 → pause expansion',
                'adaptive': 'System responds to conditions automatically'
            }
        }

def economic_value_check(self):
    """Check if spawning is economically justified"""
    cost = self.estimate_spawn_cost()
    benefit = self.estimate_w_benefit()
    
    return benefit > cost * 1.2  # 20% margin

def w_optimization_check(self):
    """Check if ΔW is significant"""
    w_current = self.calculate_current_w()
    w_after = self.simulate_spawn_w()
    delta_w = w_after - w_current
    
    threshold = w_current * 0.05  # 5% increase minimum
    return delta_w > threshold

def w_target_check(self):
    """Check if we're below W target"""
    w_current = self.calculate_current_w()
    w_target = self.get_w_target()  # Could be 1000
    
    return w_current < w_target * 0.9  # Allow 90% of target

def topology_check(self):
    """Check if network is favorable"""
    try:
        # Can reach DHT?
        StatelessWallet.dht_lookup(self.dht_port, 'test')
        
        # Count peers
        peers = len(self.discovered_peers)
        
        # Score (0-1)
        score = min(peers / 10, 1.0)  # 10 peers = perfect
        
        return score > 0.3  # Minimum viable topology
    except:
        return False  # DHT unreachable

def should_replicate(self):
    """Use all four checks"""
    economic = self.economic_value_check() * 0.3
    objective = self.w_optimization_check() * 0.3
    w_target = self.w_target_check() * 0.2
    topology = self.topology_check() * 0.2
    
    score = economic + objective + w_target + topology
    
    # Log decision factors
    self.series.append({
        'status': 'replication_decision',
        'economic': economic,
        'objective': objective,
        'w_target': w_target,
        'topology': topology,
        'score': score,
        'decision': score > 0.5
    })
    
    return score > 0.5

teaching_power = self._get_dimension('teaching_power')  # 0.8 = 80%

# This represents combined economic + objective assessment
# High teaching_power = favorable conditions
# Low teaching_power = adverse conditions

if random.random() < teaching_power:
    # Stochastic decision based on all factors
    self.spawn_child()

class SelfRegulatingSystem:
    """
    Liberty model demonstrates principles
    """
    def key_insights(self):
        return {
            'traditional_systems': {
                'assumption': 'Need central rate limiting',
                'examples': [
                    'Bitcoin: Block size limit (central consensus)',
                    'Ethereum: Gas limit (protocol parameter)',
                    'DNS: Root servers (ICANN control)',
                    'Internet: BGP routing (RIR allocation)'
                ],
                'property': 'Top-down control required',
                'problem': 'Central point of failure'
            },
            
            'liberty_model': {
                'assumption': 'Natural rate limiting emerges',
                'mechanisms': [
                    'Economic: Cost/benefit balance',
                    'Objective: W optimization',
                    'W calculation: Target tracking',
                    'Topology: Network pressure'
                ],
                'property': 'Bottom-up self-organization',
                'advantage': 'No central control needed'
            },
            
            'breakthrough': {
                'realization': 'W → ∞ doesn\'t mean uncontrolled growth',
                'mechanism': 'Natural limiters emerge from local decisions',
                'result': 'Open universe self-regulates',
                'implication': 'Scalable without central coordination'
            },
            
            'practical_application': {
                'liberty_nodes': 'Demonstrate self-regulation',
                'w_expansion': 'Grows to equilibrium naturally',
                'no_fork_bomb': 'Economic + topology prevent explosion',
                'adaptive': 'Responds to conditions automatically',
                'resilient': 'No single point of failure'
            }
        }