Computational Horizons: Section 2 - Theoretical Framework

Draft v0.1 - 2026-01-07

---

2. Theoretical Framework

We formalize computation, quantum mechanics, and spacetime constraints within a unified graph-theoretic model.

2.1 The Weighted Graph Model

Definition 1 (Computational Graph): A computational graph is a tuple G = (N, E, w, TTL) where:

• N is a set of nodes (states)
• E ⊆ N × N is a set of directed edges (transitions)
• w: E → ℂ is a complex weight function (amplitudes)
• TTL ∈ ℕ is the time-to-live budget (maximum hops)

Definition 2 (Path): A path p from node a to node b is a sequence of edges (e₁, e₂, ..., eₖ) where:

• e₁ starts at a
• eₖ ends at b
• Each edge ends where the next begins

Definition 3 (Path Weight): The weight of a path p is the product of its edge weights:

w(p) = ∏ᵢ w(eᵢ)

Definition 4 (Path Length): The length |p| of a path is the number of edges traversed.

2.2 The Fetch Operation

A fetch is a query-response operation from an observer O to a target state T.

Definition 5 (Fetch): A fetch F(O, T) consists of:

• Outbound phase: Message travels from O to T via path p_out
• Resolution: T produces a definite value v
• Inbound phase: Response travels from T to O via path p_in

Definition 6 (Fetch Cost): The cost of a fetch is:

• Hop cost: |p_out| + |p_in| (must not exceed TTL)
• Energy cost: E ≥ k_B T ln(2) per irreversible bit operation (Landauer's principle)

Definition 7 (Round-Trip Weight): The probability amplitude for a successful fetch is:

A(F) = w(p_out) · w(p_in)

For quantum systems where p_in reverses p_out:

w(p_in) = w(p_out)* (complex conjugate)

Therefore:

A(F) = w(p_out) · w(p_out)* = |w(p_out)|²

This is the Born rule, derived from round-trip geometry.

2.3 TTL as Resource Constraint

Axiom 1 (Finite TTL): Every fetch operation has a finite hop budget TTL. If |p_out| + |p_in| > TTL, the fetch fails (packet dropped).

Axiom 2 (Landauer Cost): Each hop dissipates at least k_B T ln(2) energy. The total energy budget E_max implies:

TTL_max = E_max / (k_B T ln(2))

Theorem 1 (TTL Bound): For a system with total energy E_max at temperature T, the maximum number of computational steps is bounded by:

N_steps ≤ E_max / (k_B T ln(2))

This connects hop count to thermodynamic resources.

2.4 Complexity Classes in Graph Terms

Definition 8 (P-Reachable): A target T is P-reachable from O if there exists a path p with |p| = O(poly(n)) where n is the input size.

Definition 9 (NP-Reachable): A target T is NP-reachable from O if there exists a path p with |p| = O(2^poly(n)).

Theorem 2 (TTL Separation): For any polynomial TTL budget, there exist NP targets that are unreachable (packet dropped before arrival).

Proof sketch: If TTL = O(poly(n)) and the shortest path to T has length O(2^n), then for sufficiently large n, |p| > TTL. □

2.5 Quantum States as Unresolved Pointers

Definition 10 (Superposition): A quantum state |ψ⟩ is an unresolved pointer to multiple nodes:

|ψ⟩ = Σᵢ αᵢ |nᵢ⟩

where αᵢ = w(path from reference to nᵢ).

The state is not "in multiple nodes simultaneously" but rather "uncommitted to which node will be resolved upon fetch."

Definition 11 (Measurement): A measurement is a fetch operation that forces resolution. The probability of outcome nⱼ is:

P(nⱼ) = |αⱼ|² = αⱼ · αⱼ*

This follows from Definition 7 (round-trip weight).

2.6 Decoherence as Route Divergence

Definition 12 (Coherence): Two paths p₁ and p₂ are coherent if they share edges. Coherent paths can interfere.

Definition 13 (Decoherence): Decoherence occurs when environmental interactions cause paths to diverge—to no longer share edges.

Theorem 3 (Decoherence Suppresses Interference): If paths p₁ and p₂ to outcomes n₁ and n₂ have no shared edges, their contributions to probability are additive (no interference terms):

P(n₁ or n₂) = |α₁|² + |α₂|²

rather than:

P(n₁ or n₂) = |α₁ + α₂|² = |α₁|² + |α₂|² + 2Re(α₁*α₂)

Proof sketch: Interference requires path overlap. After decoherence, paths have diverged and cannot interfere. □

2.7 Entanglement as Shared Pointer

Definition 14 (Entanglement): Two systems A and B are entangled if they share a pointer to the same unresolved node.

Theorem 4 (Entanglement Correlation): When A is measured (fetch resolves the shared node), B's subsequent measurement returns a correlated result because the node is already resolved.

This is not action at a distance—it's cache coherence. The shared node was resolved once; both systems see the resolved value.

2.8 Spacetime Horizons as TTL Boundaries

Definition 15 (Horizon): A horizon is a surface where TTL for outbound messages approaches zero.

Inside a horizon, any fetch to outside would require:

|p_out| + |p_in| > TTL_available

Messages cannot escape—not because they're destroyed, but because they're unreachable within routing constraints.

Conjecture 1 (Holographic Encoding): Information about internal states is encoded in edge weights on the horizon boundary, consistent with the holographic principle.

2.9 The Unified Picture

Concept	Graph Interpretation
State	Node
Transition	Edge
Amplitude	Edge weight
Measurement	Fetch (round-trip)
Born rule
Superposition	Unresolved pointer
Collapse	Forced resolution
Decoherence	Path divergence
Entanglement	Shared pointer
P complexity	Polynomial path length
NP complexity	Exponential path length
Horizon	TTL → 0 boundary

---

Provenance

• Status: Draft v0.1
• Parent: computational-horizons-paper-outline

North

slots:
- context:
  - Previous section
  slug: computational-horizons-section-1
- context:
  - Section sequence
  slug: computational-horizons-section-1

East

slots:
- slug: computational-horizons-section-3
  context:
  - Next section

South

slots:
- context:
  - Section sequence
  slug: computational-horizons-section-3