# Post 816 approach
class Perspective:
    def observe(self, universe_state):
        """What physically reaches this node"""
        visible = {}
        
        for entity in universe_state:
            # Physical propagation limit
            distance = self._distance(entity.position)
            time_delay = distance / c  # Hardcoded light speed!
            
            if time_delay <= entity.age:
                visible[entity] = entity
        
        return visible

class Perspective:
    def __init__(self, node_id):
        self.node_id = node_id
        self.universe_map = {}  # This node's computed imagination
        self.network_position = None
        self.computation_capacity = None
    
    def compute_observable(self, network_topology):
        """
        What can this node compute/imagine?
        
        Not: What physically reaches it
        But: What it can model from network position
        """
        observable = {}
        
        for other_node in network_topology.nodes:
            # Can this node compute/imagine other_node's state?
            if self.can_model(other_node, network_topology):
                # Add to universe map (imagination)
                observable[other_node.id] = self.compute_state(other_node)
        
        # This is node's "imagination" of universe
        self.universe_map = observable
        return observable

# Universe doesn't exist as single ground truth
# Each node computes its own universe map
# "Reality" = collection of all node imaginations

class Node:
    """
    Node with computational perspective
    """
    def __init__(self, node_id):
        self.id = node_id
        self.universe_map = {}  # My imagination of universe
        self.local_state = {}   # My actual state
        self.connections = []   # Edges to other nodes
    
    def compute_universe_map(self, network):
        """
        Compute/imagine universe from my perspective
        
        This is active computation, not passive observation
        """
        # Start with self
        self.universe_map[self.id] = self.local_state
        
        # Compute states of connected nodes
        for neighbor in self.connections:
            if self.can_reach(neighbor, network):
                # Imagine neighbor's state
                imagined_state = self.imagine_state(neighbor)
                self.universe_map[neighbor.id] = imagined_state
        
        # Compute states of nodes at distance 2
        for neighbor in self.connections:
            for neighbor2 in neighbor.connections:
                if self.can_reach(neighbor2, network):
                    imagined_state = self.imagine_state(neighbor2)
                    self.universe_map[neighbor2.id] = imagined_state
        
        # Continue until computation limit reached
        # OR network topology doesn't allow further reach
        
        return self.universe_map

def can_model(self, target_node, network):
    """
    Can this node compute/imagine target node?
    
    Depends on:
    1. Network topology (connectivity path)
    2. Computation capacity (resources)
    3. Data availability (information flow)
    """
    # Check 1: Network path exists?
    path = network.find_path(self, target_node)
    if not path:
        return False  # Not connected in network
    
    # Check 2: Path length within computation range?
    if len(path) > self.max_computation_depth:
        return False  # Too far in network topology
    
    # Check 3: Sufficient data to model?
    required_data = self.estimate_data_needed(target_node)
    available_data = self.get_available_data(target_node, network)
    if available_data < required_data:
        return False  # Insufficient information
    
    # Can model!
    return True

# Node A directly connected to Node B
node_A.can_model(node_B, network)
# → True (direct connection, easy to imagine)

# Node A connected to B, B connected to C
node_A.can_model(node_C, network)
# → Maybe (depends on computation capacity)

# Node A and Node Z in different network clusters
node_A.can_model(node_Z, network)
# → False (no path in network topology)

# Passive - wait for photons to arrive
def observe_physical(entity):
    light_from_entity = wait_for_photons(entity)
    return process_light(light_from_entity)

# Active - compute what entity must be like
def imagine_computational(entity, network):
    """
    Don't wait for information to arrive
    Compute what entity state should be
    Based on network position and relationships
    """
    # Gather available data
    local_data = get_data_from_connections(entity)
    
    # Compute likely state
    if has_direct_connection(entity):
        # High confidence imagination
        imagined_state = compute_from_direct_data(local_data)
    else:
        # Lower confidence - must infer through network
        imagined_state = infer_from_indirect_data(local_data, network)
    
    return imagined_state

time_delay = distance / c  # c = 299,792,458 hardcoded!

def compute_information_delay(source_node, target_node, network):
    """
    How "far" is target in computational terms?
    
    Not physical distance / c
    But network hops + computation time
    """
    # Network topology distance
    path = network.find_path(source_node, target_node)
    network_distance = len(path)
    
    # Computation time per hop
    computation_time = network_distance * time_per_hop
    
    # Information delay emerges from network structure
    # Not from hardcoded physical constant
    return computation_time

# If nodes happen to compute at certain rate,
# and network has certain topology,
# emergent "speed limit" might appear
# But it's not fundamental - it's emergent from structure

class EmergentProperties:
    """
    What emerges from computational perspective
    """
    def measure_apparent_speed_limit(self, network):
        """
        Network might have emergent "speed limit"
        Based on:
        - Node computation rates
        - Network topology
        - Information propagation patterns
        
        NOT fundamental constant
        """
        # Measure how fast information spreads
        propagation_times = []
        
        for node_pair in network.sample_pairs():
            time = compute_information_delay(node_pair[0], node_pair[1], network)
            distance = network_hops(node_pair[0], node_pair[1])
            propagation_times.append(time / distance)
        
        # Average gives emergent "speed"
        emergent_speed = sum(propagation_times) / len(propagation_times)
        
        # This might look like "constant"
        # But it's emergent from network structure
        # Change network → changes "constant"
        return emergent_speed

# Network with 5 nodes
network = Network()

node_A = Node('A')
node_B = Node('B')
node_C = Node('C')
node_D = Node('D')
node_E = Node('E')

# Connections (edges)
network.connect(node_A, node_B)
network.connect(node_B, node_C)
network.connect(node_C, node_D)
network.connect(node_A, node_E)

# Topology:
#     E
#    /
#   A - B - C - D

node_A.compute_universe_map(network)

# Result:
node_A.universe_map = {
    'A': {...},  # Self (complete knowledge)
    'B': {...},  # Direct connection (high confidence)
    'E': {...},  # Direct connection (high confidence)
    'C': {...},  # Distance 2 (medium confidence)
    'D': {...},  # Distance 3 (low confidence)
}

# Node A can imagine all nodes
# But confidence decreases with network distance

node_D.compute_universe_map(network)

# Result:
node_D.universe_map = {
    'D': {...},  # Self (complete knowledge)
    'C': {...},  # Direct connection (high confidence)
    'B': {...},  # Distance 2 (medium confidence)
    'A': {...},  # Distance 3 (low confidence)
    'E': {...},  # Distance 4 (very low confidence)
}

# Node D can imagine all nodes
# But Node E is far in network topology
# So imagination of E is low confidence

node_E.compute_universe_map(network)

# Result:
node_E.universe_map = {
    'E': {...},  # Self (complete knowledge)
    'A': {...},  # Direct connection (high confidence)
    'B': {...},  # Distance 2 (medium confidence)
    'C': {...},  # Distance 3 (low confidence)
    # D might be beyond computation limit!
}

# Node E is leaf node
# Can't imagine as much as central nodes

class UniverseMap:
    """
    Node's computed imagination of universe
    Each entry has confidence score
    """
    def __init__(self, observer_node):
        self.observer = observer_node
        self.entries = {}  # node_id → (state, confidence)
    
    def add_node(self, node_id, imagined_state, network_distance):
        """
        Add node to map with confidence score
        
        Confidence degrades with network distance
        """
        # Self: perfect knowledge
        if node_id == self.observer.id:
            confidence = 1.0
        
        # Direct neighbors: high confidence
        elif network_distance == 1:
            confidence = 0.9
        
        # Distance 2: medium confidence
        elif network_distance == 2:
            confidence = 0.7
        
        # Distance 3: low confidence
        elif network_distance == 3:
            confidence = 0.5
        
        # Distance 4+: very low confidence
        else:
            confidence = max(0.1, 1.0 / network_distance)
        
        self.entries[node_id] = (imagined_state, confidence)
    
    def get_confidence(self, node_id):
        """How confident is imagination of this node?"""
        if node_id in self.entries:
            return self.entries[node_id][1]
        return 0.0  # Not in map

# Node A imagines universe
universe_map = UniverseMap(node_A)

universe_map.add_node('A', node_A.local_state, distance=0)
# Confidence: 1.0 (perfect - self)

universe_map.add_node('B', imagined_B_state, distance=1)
# Confidence: 0.9 (high - direct neighbor)

universe_map.add_node('D', imagined_D_state, distance=3)
# Confidence: 0.5 (low - far in network)

# Query confidence
print(universe_map.get_confidence('A'))  # 1.0
print(universe_map.get_confidence('B'))  # 0.9
print(universe_map.get_confidence('D'))  # 0.5

class DynamicUniverseMap:
    """
    Universe map that updates over time
    As network topology changes
    """
    def __init__(self, observer_node):
        self.observer = observer_node
        self.map = {}
        self.last_update = 0
    
    def update(self, network, current_time):
        """
        Recompute universe map
        
        Called when:
        - Network topology changes
        - Node receives new data
        - Periodic refresh
        """
        # Clear old entries that are too stale
        self.prune_stale_entries(current_time)
        
        # Recompute reachable nodes
        for node in network.nodes:
            if self.observer.can_model(node, network):
                imagined_state = self.observer.imagine_state(node)
                distance = network.distance(self.observer, node)
                confidence = self.compute_confidence(distance)
                
                self.map[node.id] = {
                    'state': imagined_state,
                    'confidence': confidence,
                    'last_updated': current_time
                }
        
        self.last_update = current_time
    
    def prune_stale_entries(self, current_time):
        """Remove entries that are too old"""
        stale_threshold = 100  # time units
        
        for node_id in list(self.map.keys()):
            if current_time - self.map[node_id]['last_updated'] > stale_threshold:
                del self.map[node_id]  # Too stale - remove

# Initial network
network = Network()
# A - B - C

node_A.universe_map.update(network, t=0)
# Map: {A, B, C}

# Network changes - new connection
network.connect(node_A, node_C)
# A - B - C
#  \_____/

node_A.universe_map.update(network, t=10)
# Map: {A, B, C} but C confidence increased!
# (Direct connection now)

# Network changes - node added
node_D = Node('D')
network.connect(node_C, node_D)

node_A.universe_map.update(network, t=20)
# Map: {A, B, C, D}
# D newly imaginable

# Must hardcode constants
c = 299792458  # Speed of light (hardcoded!)
G = 6.674e-11  # Gravitational constant (hardcoded!)

# Must assume continuous space
position = [x, y, z]  # Continuous coordinates

# Must propagate through medium
photon_travels_through_space()

# Single "ground truth" universe
universe_state = {...}  # One reality

# No hardcoded constants
# Network topology determines "speed limits"

# Discrete network structure
node_connections = [...]  # Graph edges

# Computation creates "propagation"
node.compute_imagination()

# Multiple perspectives, no ground truth
node_A.universe_map != node_B.universe_map  # Different imaginations

class ComputationalPerspective:
    """
    Node's perspective as computed imagination
    
    Extends Post 816 Perspective class
    But computational not physical
    """
    def __init__(self, node_id, computation_capacity=10):
        self.node_id = node_id
        self.universe_map = {}
        self.computation_capacity = computation_capacity
        self.confidence_scores = {}
    
    def compute_observable(self, network):
        """
        Compute universe map from this node's position
        
        NOT: Check physical light cones
        BUT: Compute what can be imagined from network position
        """
        observable = {}
        
        # BFS through network up to computation limit
        visited = {self.node_id}
        queue = [(self.node_id, 0)]  # (node_id, distance)
        
        while queue and len(observable) < self.computation_capacity:
            current_id, distance = queue.pop(0)
            current_node = network.get_node(current_id)
            
            # Add to observable map
            if distance <= self.computation_capacity:
                # Imagine state of this node
                imagined_state = self.imagine_node(current_node, distance, network)
                confidence = self.compute_confidence(distance)
                
                observable[current_id] = imagined_state
                self.confidence_scores[current_id] = confidence
                
                # Add neighbors to queue
                for neighbor in current_node.connections:
                    if neighbor.id not in visited:
                        visited.add(neighbor.id)
                        queue.append((neighbor.id, distance + 1))
        
        self.universe_map = observable
        return observable
    
    def imagine_node(self, node, distance, network):
        """
        Imagine what node's state is
        Based on available data and network position
        """
        if distance == 0:
            # Self - perfect knowledge
            return node.local_state
        
        elif distance == 1:
            # Direct neighbor - query directly
            return node.local_state  # High confidence
        
        else:
            # Indirect - must infer through network
            # Gather data from intermediate nodes
            data = self.gather_indirect_data(node, network)
            
            # Compute likely state
            imagined_state = self.infer_state_from_data(data)
            
            return imagined_state
    
    def compute_confidence(self, network_distance):
        """Confidence degrades with network distance"""
        if network_distance == 0:
            return 1.0
        else:
            return 1.0 / (network_distance ** 0.5)
    
    def gather_indirect_data(self, target_node, network):
        """Gather data about target from intermediate nodes"""
        # Find path to target
        path = network.find_path(self.node_id, target_node.id)
        
        # Collect data along path
        data = []
        for node_id in path:
            node = network.get_node(node_id)
            data.append(node.local_state)
        
        return data
    
    def infer_state_from_data(self, data):
        """Infer target state from indirect data"""
        # Simple inference: average of path states
        # More sophisticated: ML model, pattern matching, etc.
        return sum(data) / len(data)  # Simplified

class Perspective:
    def __init__(self, observer_id, position, velocity):
        self.id = observer_id
        self.position = position
        self.velocity = velocity

class ComputationalPerspective(Perspective):
    """
    Extends Perspective with computational imagination
    """
    def __init__(self, observer_id, network_position, computation_capacity):
        # Instead of physical position/velocity
        # Use network position and computation capacity
        self.id = observer_id
        self.network_position = network_position
        self.computation_capacity = computation_capacity
        self.universe_map = {}
    
    def observe(self, network):
        """
        Override physical observation with computational
        
        Post 816: Check light cones
        Post 838: Compute universe map
        """
        return self.compute_observable(network)