class UniverseGraph:
    """
    Universe = dynamic graph of computational nodes
    """
    def __init__(self):
        self.nodes = set()  # Computational entities
        self.edges = {}     # Information channels
        self.information_flow = {}
    
    def add_node(self, entity):
        """
        Any information-processing entity is a node:
        - Physical: atoms, particles, planets
        - Digital: R³ nodes, EVM nodes, IRC bots
        - Biological: cells, organisms
        - Emergent: clouds, weather systems
        """
        self.nodes.add(entity)
        
        # Connect to neighbors via information channels
        for neighbor in self.find_neighbors(entity):
            self.add_edge(entity, neighbor)

class InformationCost:
    """
    Information propagation has real cost
    """
    def __init__(self, graph):
        self.graph = graph
    
    def propagate_information(self, from_node, to_node, bits):
        """
        Send information through graph
        """
        # Find path through graph
        path = self.graph.find_path(from_node, to_node)
        
        # Cost = information traversing each edge
        cost = 0
        for edge in path:
            # Each edge traversal costs information bandwidth
            cost += bits * edge.information_capacity
        
        # Must pay this cost to propagate information
        return cost

# 1. Cannot be faked
# Information has Shannon entropy H = -Σ p(x)log p(x)
# Cannot create information without changing graph state

# 2. Cannot be printed
# Information must be computed/received
# Can't spontaneously appear

# 3. Universal
# Every node processes information
# Every interaction costs information bandwidth

# 4. Enforced by physics
# Graph structure limits information flow
# c = maximum information propagation rate

class ComputationCost:
    """
    Computation = graph state changes
    """
    def __init__(self, node):
        self.node = node
        self.graph = node.graph
    
    def compute(self, input_data, output_data):
        """
        Computation changes node state
        """
        # Input: information arrives at node
        self.node.state.update(input_data)
        
        # Processing: node changes internal state
        result = self.node.process(input_data)
        
        # Output: information propagates to neighbors
        for neighbor in self.node.neighbors:
            self.propagate_info(neighbor, result)
        
        # Cost: information spreading through graph
        # More neighbors = more information copies = more cost
        cost = len(self.node.neighbors) * shannon_entropy(result)
        
        return cost

# Modern CPU
cpu_node = GraphNode(
    neighbors=1000000000,  # Billions of transistors connected
    state_size=10**9,       # Billions of bits
    update_rate=3e9         # 3 GHz
)

# Each clock cycle:
# - Information propagates through transistor graph
# - State changes at billions of nodes
# - Heat = information spreading = entropy increase

operations_per_second = 3e9
information_per_op = 1  # bit flips
total_information = operations_per_second * information_per_op

# This information flow = the cost
# Manifests as power consumption (50-200W)

class StorageCost:
    """
    Storage = fighting information decay in dynamic graph
    """
    def __init__(self, node):
        self.node = node
        self.graph = node.graph
    
    def store(self, data, duration):
        """
        Store information in node state
        """
        # Graph is dynamic - edges change, nodes move
        # Information tends to spread/decay
        
        # Must continuously refresh to maintain
        refresh_cost = 0
        
        for t in range(duration):
            # Graph topology changes
            self.graph.evolve(dt=1)
            
            # Information corrupts due to topology changes
            corruption = self._measure_corruption(data)
            
            # Must refresh to fix corruption
            refresh_cost += self._refresh(data, corruption)
        
        return refresh_cost
    
    def _measure_corruption(self, data):
        """
        How much information lost due to graph changes
        """
        # Edges reconfigure - information paths change
        # Some bits get flipped by topology changes
        # Must detect and correct
        
        return corruption_bits

class CommunicationCost:
    """
    Communication = information propagating through graph edges
    """
    def __init__(self, graph):
        self.graph = graph
    
    def transmit(self, from_node, to_node, message):
        """
        Send message through graph
        """
        # Shannon entropy of message
        H = self._shannon_entropy(message)
        
        # Find path through graph
        path = self.graph.find_path(from_node, to_node)
        
        # Cost = information traversing each edge
        cost = 0
        for edge in path:
            # Information propagation through edge
            # Limited by edge capacity (bandwidth)
            
            if H > edge.capacity:
                # Message too large - must split
                chunks = ceil(H / edge.capacity)
                cost += chunks * edge.cost_per_bit
            else:
                cost += H * edge.cost_per_bit
        
        return cost
    
    def _shannon_entropy(self, message):
        """
        Information content (bits)
        """
        # H = -Σ p(x) log p(x)
        probs = self._symbol_probabilities(message)
        H = -sum(p * log2(p) for p in probs if p > 0)
        return H * len(message)

class RateLimiter:
    """
    Rate limiters control information flow through node
    """
    def __init__(self, node):
        self.node = node
        self.graph = node.graph
        
        # Information budgets
        self.limiters = {
            'economic': self._storage_info_budget(),
            'objective': self._value_vs_info_budget(),
            'w_tracking': self._computation_info_budget(),
            'topology': self._network_info_budget()
        }
    
    def should_respond(self, intent):
        """
        Should node process this information?
        """
        # Estimate information cost
        info_cost = self._estimate_info_cost(intent)
        
        # Check against budgets
        for limiter_name, budget in self.limiters.items():
            if info_cost > budget.remaining():
                # Would exceed information budget
                return False
        
        return True
    
    def _estimate_info_cost(self, intent):
        """
        How much information bandwidth would response cost?
        """
        # 1. Computation: processing intent
        compute_info = self._compute_complexity(intent)
        
        # 2. Communication: sending response
        response_size = self._estimate_response_size(intent)
        comm_info = self._shannon_entropy(response_size)
        
        # 3. Storage: caching for future
        storage_info = response_size * self.node.storage_info_rate
        
        # Total information flow
        return compute_info + comm_info + storage_info

class EconomicLimiter:
    """
    Limits information stored in node state
    """
    def __init__(self, node):
        self.node = node
        self.max_storage_info = node.storage_capacity
    
    def current_usage(self):
        """
        How much information currently stored?
        """
        # All chunks stored = information in node state
        total_bits = sum(len(chunk) * 8 for chunk in self.node.chunks.values())
        
        # Shannon entropy of stored data
        storage_info = self._calculate_entropy(self.node.chunks)
        
        return storage_info
    
    def remaining_budget(self):
        """
        How much more information can we store?
        """
        return self.max_storage_info - self.current_usage()
    
    def should_store(self, chunk):
        """
        Should we accept this chunk?
        """
        # Information cost of storing chunk
        chunk_info = len(chunk) * 8  # bits
        
        # Would it exceed budget?
        if chunk_info > self.remaining_budget():
            return False  # Not enough information capacity
        
        return True

class WTrackingLimiter:
    """
    Limits computational information processing
    """
    def __init__(self, node):
        self.node = node
        self.computation_budget = node.compute_capacity
        self.recent_work = []
    
    def record_computation(self, work_done):
        """
        Track recent computational information processing
        """
        self.recent_work.append({
            't': time.time(),
            'info_processed': work_done.information_bits
        })
        
        # Prune old records
        cutoff = time.time() - 3600  # 1 hour window
        self.recent_work = [w for w in self.recent_work if w['t'] > cutoff]
    
    def remaining_budget(self):
        """
        How much computation bandwidth left?
        """
        recent_total = sum(w['info_processed'] for w in self.recent_work)
        return self.computation_budget - recent_total
    
    def should_compute(self, intent):
        """
        Should we process this computation?
        """
        # Estimate information processing required
        compute_info = self._estimate_compute_bits(intent)
        
        if compute_info > self.remaining_budget():
            return False  # Would exceed compute information budget
        
        return True

class ObjectiveLimiter:
    """
    Compare value vs information cost
    """
    def __init__(self, node):
        self.node = node
    
    def should_respond(self, intent):
        """
        Is response worth the information cost?
        """
        # Estimate value of responding
        value = self._estimate_value(intent)
        
        # Estimate information cost
        info_cost = (
            self._compute_info_cost(intent) +
            self._communication_info_cost(intent) +
            self._storage_info_cost(intent)
        )
        
        # Compare
        if info_cost > value:
            return False  # Not worth the information bandwidth
        
        return True
    
    def _estimate_value(self, intent):
        """
        What do we gain from responding?
        """
        # Value = future information benefit
        # - Building reputation (future intents from requester)
        # - Data exchange (learning from response)
        # - Network position (becoming known for this data)
        
        return estimated_future_information_gain

class TopologyLimiter:
    """
    Limits network information flow
    """
    def __init__(self, node):
        self.node = node
        self.graph = node.graph
        self.max_network_info = self._calculate_max_bandwidth()
    
    def _calculate_max_bandwidth(self):
        """
        Total information capacity of network connections
        """
        total_bandwidth = 0
        for neighbor in self.node.neighbors:
            edge = self.node.edges[neighbor]
            # Each edge has information capacity
            total_bandwidth += edge.information_capacity
        
        return total_bandwidth
    
    def current_usage(self):
        """
        How much network information flow currently?
        """
        # Measure information flowing through edges
        current_info_flow = 0
        for neighbor in self.node.neighbors:
            edge = self.node.edges[neighbor]
            current_info_flow += edge.current_information_rate
        
        return current_info_flow
    
    def should_send(self, message):
        """
        Should we send this message?
        """
        # Information content of message
        message_info = self._shannon_entropy(message)
        
        # Would it exceed network capacity?
        if self.current_usage() + message_info > self.max_network_info:
            return False  # Network saturated
        
        return True

class PureFluxInformation:
    """
    Pure flux = continuous information flow through graph
    """
    def __init__(self, node):
        self.node = node
        self.graph = node.graph
    
    def push_intent(self, intent):
        """
        Push = send information (immediate return)
        """
        # Calculate information content
        intent_info = self._shannon_entropy(intent)
        
        # Broadcast through graph edges
        for neighbor in self.node.neighbors:
            edge = self.node.edges[neighbor]
            
            # Information propagates through edge
            # At rate limited by edge capacity (like c for light!)
            edge.transmit(intent_info)
        
        # Append to local series
        self.node.series.append({
            't': time.time(),
            'event': 'info_pushed',
            'bits': intent_info
        })
        
        # Return immediately - no blocking!
        return
    
    def _on_p2p_response(self, data):
        """
        Async handler: information arrived
        """
        # Just append - information flowing in
        self.node.series.append({
            't': time.time(),
            'event': 'info_received',
            'data': data,
            'bits': self._shannon_entropy(data)
        })

class UniversalCurrency:
    """
    Why information is the only honest currency
    """
    def try_to_cheat(self):
        """
        Can we fake information?
        """
        # Try to send information without having it
        try:
            self.send_info_not_possessed()
        except InformationError:
            # Can't send what you don't have!
            # Graph structure enforces this
            return "Cannot fake information"
        
        # Try to print information from nothing
        try:
            self.create_information_from_nothing()
        except EntropyError:
            # Information must come from computation/reception
            # Can't spontaneously appear
            return "Cannot print information"
        
        # Try to exceed edge capacity
        try:
            self.send_infinite_information()
        except BandwidthError:
            # Graph edges have limited capacity
            # Like c for light!
            return "Cannot exceed bandwidth"

# Traditional currencies
gold = Currency(
    can_be_faked=False,      # Needs assay
    can_be_printed=True,     # Mine more
    universal=False,         # Civilization-specific
    enforced_by='consensus'  # Social agreement
)

bitcoin = Currency(
    can_be_faked=False,      # Cryptography
    can_be_printed=True,     # Mine more (until cap)
    universal=False,         # Only in Bitcoin network
    enforced_by='consensus'  # Network majority
)

# Information as currency
information = Currency(
    can_be_faked=False,      # Shannon entropy objective
    can_be_printed=False,    # Must compute/receive
    universal=True,          # All nodes process info
    enforced_by='physics'    # Graph structure itself
)

class MoneyWithInformation:
    """
    Multi-currency, but information settles everything
    """
    def mint(self, currency, amount):
        """
        Mint currency (pure flux)
        """
        # Push intent to DHT
        self.dht.push_intent({
            'intent': 'mint_money',
            'currency': currency,
            'amount': amount
        })
        
        # Information cost of this operation:
        info_cost = (
            # 1. Computing the mint intent
            self._compute_info() +
            
            # 2. Broadcasting through graph
            self._broadcast_info() +
            
            # 3. Storing in series
            self._storage_info()
        )
        
        # Someone pays this information cost
        # Usually the minter (their bandwidth/compute/storage)
        
        # Currency is abstract layer
        # Information is settlement layer
        
        return info_cost