1. Particles: coherent spheres of wave cells that heal and pollinate many atoms simultaneously before commit. This is the probability side: superposition, amplitudes, and interference describe where commits are likely to land.
2. Atoms: autonomous state machines that take particle inputs, process internal transitions, and expel particle outputs. This is the reality side: stable identities, state transitions, and emissions that anchor the Event Ledger.

• Space: the record of where commits occur, geometry built from reconciliation history.
• Time: the pacing of commit cadence α, emerging from synchronization intervals between local and global clocks.
• Mass: the fraction of budget locked into M (maintenance); inertia is resistance to changing that allocation.
• Energy: total budget C redistributed between T and M; E = ℏω bridges these shares to physical units.
• Maxwell’s laws: emergent transport rules over budgeted updates, not axioms but derived behavior.
• Doppler & redshift: pacing differences between emit and absorb commits, not stretching of pre-existing waves.
• Gravity & curvature: collective pacing gradients (α-fields) written by stable matter in the S-ledger.
• Dark matter: & scars pruning residues (D-field) from vetoed or failed collapse attempts.
• Relativity: budget conservation under motion vs. maintenance; time dilation and Lorentz symmetry as emergent bookkeeping.
• Quantum interference: phase-alignment statistics during commit synchronization (|ψ|² from beat frequencies).

The Event Ledger does more than timestamp commits, it actively re-synchronizes every worldline on each universal tick. In flight, a particle’s wave cells traverse regions with different α(x); GBSL continually re-phases them so their M-ticks and T-steps remain coherent. This global resync creates real “action at a distance”: particles drift toward heavier queue load (lower effective α) because the budget re-alignment biases their next admissible commits in that direction. Gravity is thus the macroscopic pattern of this queue-buffering pull, applied everywhere, even to particles in flight.

• Queue saturation self-limits sync: As local queues grow, reconciliation work increases and the effective pacing α(x) drops. This prevents queues from diverging, even in extreme wells or near black holes: the more backlog, the slower signals synchronize to it. The global tick never over-commits; congestion lowers local throughput and shapes the pull toward loaded regions.
• c as synchronization speed, not “motion through space”: In CBF, the constant c is the maximum rate at which independent commit streams can synchronize, not merely a lattice hop rate. Pure T-carriers (photons) operate at this sync ceiling: they propagate phase and timing at the fastest pace the Ledger can reconcile. Where α is smaller (gravity/media) or queues are saturated, the effective sync rate drops, so light appears slower without adding extra geometry.
• Budget-first unification: The global tick advances C and its split T + M everywhere. In pure SR, α(x)=1 and “time dilation” comes only from the T/M split (commit pacing). In gravity or media, α(x)<1 scales the entire budget, lowering all local rates, including the maximum sync rate experienced as the speed of signals.
• Operational rule (what the Ledger enforces): On each universal tick, the Ledger:
  1. advances all worldlines by their local α·C budget,
  2. reconciles phase (beat-matching) and conservation across candidates,
  3. commits events that clear the gates, writing them once,
  4. updates local α and queue state, setting next-tick sync capacity and biasing motion toward load.
  Observed “speed limits” are therefore limits of reconciliation throughput, not arbitrary kinematic axioms.

Each particle in CBF is built from a Vector Cellular Automaton (VCA), a field of probabilistic cells that move and update in lockstep rather than pixel-by-pixel. Every wave cell carries a direction vector, amplitude, and phase, and all cells move together per tick, where one tick is the time it takes light to travel a single γ-length step. Planck scale precision acts as the decimal resolution, not as visible pixels.

• Vector-based motion: Each cell holds a normalized direction and percentage weight rather than discrete pixel coordinates. This allows smooth propagation and sub-Planck precision without grid aliasing.
• Collective update: All wave cells move simultaneously per tick, maintaining a coherent front that can bend, split, or reform according to local field rules.
• Absorption and regeneration: Atoms do not absorb an entire wave, only the wave cells that reach them. Neighboring cells then regenerate new ones at 90° toward the absorbed site, following a computational form of Huygens’ principle. This produces natural diffraction and wave healing beyond slits or obstacles.
• Gamma length step: The universal tick distance (the γ-length) defines the discrete hop of light per update. It links propagation speed directly to the update rate, c = a / τ.

The Vector CA forms the structural layer for particles as oscillating wavefronts.

In CBF a particle is a propagating wavefront that offers discrete commit candidates to the Event Ledger. The universal split C = T + M sets its behavior: Translation T transports momentum and carries the oscillation/phase (ω, ω₀ for bound states), while Maintenance M pays for stability and binding. Photons in vacuum use M = 0 (pure phase transport in T); matter has M > 0 (upkeep cost).

• Wave–particle unification: One structure, two modes. The same wavefront exhibits wave behavior through direction diversification and phase transport, and particle behavior when a discrete outcome is committed by the Event Ledger.
• Interference as commit statistics: The temporal gate compares phases across diversified directions. When phases align, the commit rate rises; the observed pattern follows |ψ|² as an emergent frequency of successful commits, not an assumed axiom.
• Diffraction reshapes momentum: An aperture fans out propagation directions, creating a distribution of momentum vectors k̂. Each direction carries its phase, forming a downstream field of candidate commits.
• Superposition and pruning: Multiple candidate locations coexist as eligible branches until the Ledger selects one. Non-selected branches are pruned and write scars to the D-field that can influence future statistics, but they do not contribute mass. Only stable atomic commits source the gravitational S-field.

The Vector CA model shows that even one photon can occupy both paths of a double-slit setup before the Event Ledger records a result. Each wave cell advances per tick, regenerating neighbors when they drift apart, forming two diverging lobes that gradually interfere. No energy is duplicated — only offers are multiplied. The photon’s total budget C = T + M remains constant while probability density redistributes through time.

• Temporal buffering: As the wavefront advances, each tick adds new collapse candidates to the Ledger. None resolve immediately because the temporal gate still detects phase drift.
• Spreading interference: During the delay, both slit paths contribute phases θᵢ = kᵢ·r − ωt. Their overlap creates alternating regions of constructive and destructive commit probability. This interference pattern is the visible footprint of the Ledger’s reconciliation clock.
• Delayed commit: Only after many ticks — when a detector atom finally aligns in phase and passes the temporal, spatial, and directional gates — does a single commit occur. All unchosen branches are instantly invalidated, pruning the rest of the wave.

The CA run reveals that “interference” and “collapse” are sequential, not competing, processes. The wavefront spreads because commits are waiting; it stops spreading because one finally wins. What looks like probabilistic mystery in standard quantum mechanics is, in CBF, simply the timing behavior of a finite reconciliation engine.

In CBF, interference is the statistical footprint of how phases from a diffracted wavefront are reconciled by the Event Ledger. Diffraction is generated by the Vector CA update: wave cells propagate, heal, and regenerate neighbors (Huygens in CA form), which creates a position-dependent phase landscape. The temporal gate compares phases from the available directions; alignment raises the successful commit rate. The observed pattern follows |ψ|² as an emergent frequency of commits, not an assumed axiom.

• Single-slit pattern: Wave cells across the aperture arrive at a detector location with phases θ_i = k_i·r − ωt. The Ledger’s temporal gate compares these phases and sets the local commit rate. Constructive regions commit more often; destructive regions commit less often.
• Double-slit pattern: Two principal bundles of wave cells (one from each slit) supply directions with different path lengths. Same reconciliation rule, finer fringe spacing from the slit separation. The mechanism is diffraction-set phases, Ledger-set commit statistics.
• N-slit and arbitrary apertures: Any aperture geometry works the same way. Sum the contributing directions produced by the Vector CA diffraction, then let the temporal gate set commit frequencies. Patterns are just maps of commit density.
• Photons vs matter: For photons M = 0 in vacuum, so outcomes depend purely on phase transport. For matter M > 0, local hazard and scatter increase pruning in the D-field, reducing visibility near lossy media without adding mass to the S-field.

Net result: diffraction writes the phase landscape, the Ledger reads it. Interference patterns are where commits land often, not where waves “mystically” overlap. This keeps interference inside the C = T + M accounting and the Ledger’s selection rules.

In CBF, spatial superposition is not multiple realities existing at once, but multiple pending absorptions. Each wave cell can be partially absorbed by several atoms before one commits through the Event Ledger. The remaining unabsorbed cells keep propagating with their T-borne phase and amplitude; M is not the oscillator, it is the maintenance/binding budget.

• Pollination mechanism: Wave cells “offer” energy and phase information to many nearby atoms. Only one atom finalizes the commit; the rest record pruning traces in the D-field.
• Absorption as decision: Collapse occurs when the temporal gate and spatial gate jointly accept one absorption path as consistent.
• After collapse: All other offers expire, pruning their local branches but enriching the D-field with new statistical bias for future commits.

In this picture, superposition is not metaphysical — it is bookkeeping of uncommitted absorption attempts. Once one path is accepted, the system transitions from probability space to recorded reality.

In CBF, collapse does not destroy or duplicate energy. The total compute budget C = T + M remains constant from emission to commit. What changes is where that energy becomes real: the Event Ledger transfers the accumulated offers from many wave cells into a single absorber atom once all gates align.

• Phased arrivals from two paths: Cells from the left and right slits carry phases θ_i = k_i·r − ωt. Due to different path lengths they reach a given absorber at different times. The atom integrates these arrivals in its T channel (phase accumulation), while M provides binding/stability. Where phases reinforce, commit probability rises; where they cancel, it falls, producing the bright and dark fingers.
• Energy hand-off: When the commit occurs, the absorber’s maintenance channel takes on the stored amplitude, while the remaining wave cells lose the equivalent share of translation credit. No energy is created or lost; it is re-budgeted inside the global Ledger.
• Why the pattern persists statistically: Each photon run deposits one commit at one detector site, but over many runs the frequency of commits at each site matches the local history of phase alignment. The bright and dark bands are the long-term record of how often absorbers reached phase agreement.

The “fringe” is therefore not a standing wave in space but a ledger-based record of how phases from unequal paths synchronize at each absorber. Conservation is exact: total C is constant, only its destination changes when the commit finalizes.

In CBF, measurement is not an extra mechanism but a natural outcome of how the Event Ledger reconciles its own gates. A commit occurs only when all relevant reconciliation gates agree: temporal, spatial, and directional. When these three align, the Ledger records a physical measurement and prunes the uncommitted branches.

1. Physical measurement — gate alignment: Each wave cell carries phase, position, and direction data. The temporal gate checks phase coincidence, the spatial gate enforces momentum conservation for placement, and the directional gate ensures angular consistency. When all three agree, the commit is accepted and the corresponding atoms absorb the wave cell. This single act collapses not just the local CA structure but every competing absorber in the Ledger. Interference disappears because all other offers are trimmed from the D-field, and sometimes a new particle (photon, recoil electron, etc.) is generated to balance energy.
2. The role of M in measurement: For any collapse to register, at least one participant must carry nonzero M to provide the maintenance budget required for event formation. Pure T-only entities such as photons have no self-sustaining state and cannot measure or be measured by one another. Two photons can cross paths, interfere in the D-field, and exchange phase information, but without M there is no ledger event, no bounce, and no record. Measurement therefore demands a matter-based participant that can hold state and pay the cost of collapse.
3. Informational measurement — the higher gate: The Informational Gate is the Ledger’s semantic layer. It monitors global consistency and acts only when a collapse carries informational weight. When triggered, it prunes every history path that conflicts with the newly known outcome, preserving coherence between what has been recorded and what can still occur. This gate explains phenomena such as the quantum erasure experiment, where removing or restoring knowledge changes which branches remain viable even after the physical event.

All four gates belong to the same Ledger hierarchy: three operational gates resolve physical consistency, the informational gate resolves interpretive consistency. Together they define when a possibility becomes an event and when an event becomes part of shared reality.

In CBF, the rule P(r) ∝ |ψ|² is not postulated. It emerges naturally from how the Event Ledger records commits when wave-cell phases coincide within a finite window. Each tick of the simulation defines a global coincidence window δτ where arriving phases are compared by the temporal gate. Aligned arrivals raise the local commit rate; misaligned ones fail to commit and are pruned.

• Commit-frequency view: During each global tick the Ledger sums all contributing wave-cell amplitudes e^iθᵢ within the window δτ. The resulting commit rate follows λ(t) ∝ |Σᵢ e^iθᵢ|² — a direct count of phase-aligned events.
• Time-averaged probability: Over many ticks, regions where phases align frequently (constructive interference) produce more commits, while regions where they drift out of phase (destructive interference) produce fewer. The observed intensity map becomes the long-term average of commit density.
• Statistical emergence: The Ledger does not contain |ψ|²; it generates it statistically through repeated phase alignment. Bright fringes, particle counts, and detector probabilities all follow from beat-matching frequency, reproducing the Born rule without circular definition.

The Born rule is therefore a bookkeeping outcome of the temporal and spatial reconciliation process, not a fundamental axiom. Probability is how often reality commits, not how often it tries.

In CBF, every wave cell maintains a time-to-live (TTL) — not a counter but a measure of how much amplitude or coherence remains before collapse becomes inevitable. TTL drains continuously through the local Material Coupling Field (MCF) via loss, absorption, and scattering. As amplitude falls, the wave’s chance of commit drops until the Ledger prunes the path.

• Decoherence mechanism: TTL expresses the local entropy budget. High-loss materials (metals, liquids) deplete TTL quickly; low-loss regions (vacuum, noble gases) allow it to persist. Collapse probability rises naturally as TTL nears zero, reproducing environmental decoherence.
• D-field scars: Each fading branch leaves a residual pruning weight in the D-field. These records don’t alter new wavefronts directly but store a statistical memory of past collapses and dissipation zones.
• Dark-matter connection: Large-scale clusters of D-field scars behave gravitationally through stability-weighted sourcing (η), explaining the persistent lensing offsets seen in phenomena like the Bullet Cluster.

The TTL system makes the Ledger self-pruning. Instead of deleting branches by rule, coherence decays smoothly as amplitude drains through the MCF, keeping the simulation bounded and physically realistic.

In CBF, a barrier is a region with high Material Coupling Field (MCF) loss and altered phase velocity. Each wave cell carries amplitude and a direction vector and updates via the Vector CA. T carries oscillation and phase advance. The TTL is a continuous amplitude or entropy budget that drains as dA/dt ∝ −A·h(x,ω), where h is the local loss kernel from the MCF.

• Inside the barrier: High h(x,ω) drains TTL quickly, so amplitude decays with distance. Effective decay matches the familiar ψ(x) ≈ e^−κx, with κ set by the cumulative loss along the path. There is no borrowing of energy. The budget in T continues to advance phase while amplitude shrinks.
• Healing and re-routing: The Vector CA regenerates neighbors when cells separate too far and creates new neighbors at 90° toward recent absorptions (Huygens principle in CA form). In an irregular or thin barrier, some amplitude laterally diffuses into micro corridors with lower h. The front bends around dense spots and reforms beyond the barrier if TTL is not fully depleted.
• Commit beyond the barrier: On the far side, surviving cells can still satisfy the Event Ledger gates. The temporal gate checks phase coincidence, the spatial gate reconciles momentum and placement, and the directional gate enforces angular consistency. If all three align, one absorber atom commits and the others are pruned.
• Mapping to the textbook picture: The standard e^−κx attenuation inside a barrier corresponds to TTL drain from the MCF. The so-called escape energy is the portion of the budget that remains in T and can still translate rather than dissipate. No nonlocal penetration is required.
• Predictions from CBF: Tunneling probability depends on microstructure, not only barrier height. Porosity, grain boundaries, and path length variance change the effective loss integral and the availability of lateral healing paths. CA simulations with high but nonuniform h(x,ω) reproduce increased transmission where micro corridors exist.

Summary: tunneling is the survival of re-routed, low-TTL amplitude through connected regions of lower MCF loss, followed by a standard Ledger commit once phases, placement, and direction agree. The pattern is statistical because phase alignment controls commit frequency, not because energy is borrowed.

In CBF, decoherence is the process where candidate branches are removed because they can no longer satisfy the Event Ledger gates. Some loss comes from the continuous TTL drain through the Material Coupling Field (MCF), but pruning also occurs whenever phase, placement, or direction stop lining up.

• Gate-driven pruning: Branches are pruned when any operational gate fails: temporal (phase drift), spatial (momentum or placement inconsistency), directional (angular misalignment). These branches leave records in the D-field.
• TTL vs pruning: TTL reduces amplitude continuously via dA/dt ∝ −A·h(x,ω). Pruning is the discrete outcome where a low-amplitude or misaligned branch finally fails a gate and is removed from eligibility.
• Coherence length and time: Finite phase noise and loss set a coherence time τ_c and length L_c. When path differences exceed these scales, more branches fail the temporal gate and interference visibility drops. In CBF the visibility factor is controlled by the survival of phase-aligned arrivals and the integral of h(x,ω) along the paths.
• D-ledger memory: Pruned branches write weights to the D-ledger. These do not add mass to the S-field but store phase-space history that can bias future commit statistics in the same environment.
• Experimental handles: Increasing temperature, density, or disorder raises h(x,ω) in the MCF, shortens τ_c, and reduces fringe visibility. Which-way marking shifts failure from TTL drain to gate mismatch, again reducing visibility without requiring collapse at the source.

Net picture: TTL drains coherence continuously. The Ledger prunes branches discretely when gates fail. What remains eligible can still interfere. What is pruned contributes only a D-field record.

In CBF, every causal update divides into two parts: T for translation and oscillation, and M for internal maintenance—the local clock. Their sum, C, is fixed for all systems. This is the computational form of relativity: time and motion are two sides of one invariant budget.

• Time as maintenance: The M share measures how often a system can perform internal updates per global tick. A stationary observer with M = 1 uses their entire causal budget for internal maintenance and experiences the fastest possible local time. A moving observer redirects some of that budget into T for translation, leaving less for M and thus fewer internal updates per tick—slower local time.
• Frame pacing hierarchy: Higher-velocity frames have smaller M shares, so their local clocks tick more slowly relative to lower-velocity frames. In other words, motion borrows from time. This hierarchy underlies the standard observation that moving clocks run slow when compared to stationary ones.
• Unit causal vector: The normalization T² + M² = 1 keeps the total causal budget constant. Increasing T (motion) automatically decreases M (time flow). The familiar Lorentz factor γ = 1/√(1 − v²/c²) is recovered directly from this balance.
• Normalized geometry: The pair (T, M) acts as a computational analogue of a Minkowski 4-vector. The invariant interval arises because every frame preserves its total budget C, not because of pre-existing spacetime curvature.
• No preferred frame: Each observer defines rest as M = 1, T = 0 within their own causal budget. Motion is purely relative—a reallocation of compute shares between translation and maintenance, not motion through an absolute background.
• Observable outcome: Time dilation, kinetic energy, and rest energy all follow from how the Event Ledger reconciles commits under this conservation rule. The relativity principle emerges automatically because every frame enforces the same C = T + M constraint.

This view defines time as a process rate rather than a coordinate. A system that spends more of its budget moving spends less maintaining itself, so its proper time advances more slowly. Later sections on Time Dilation from Budget Shift and Beat Matching extend this idea to show how different frames reconcile their clocks through shared commit timing.

In CBF, every system obeys the causal budget C = T + M. T represents motion and oscillation; M represents internal maintenance (local time). To maintain conservation, their magnitudes form the Pythagorean constraint C² = T² + M². This replaces spacetime geometry with causal bookkeeping but produces identical results.

• From budget to Lorentz: Start with the invariant C² = T² + M². Normalize C = 1 to represent one full causal tick. Then M = √(1 − T²). Identifying T = v/c (motion as a fraction of light-speed budget) gives M = √(1 − v²/c²). This is exactly 1/γ(v), the Lorentz time-dilation factor. Time dilation therefore follows algebraically from the same conservation rule, not from geometry.
• Interpretation: Each system divides its fixed budget between translation and maintenance. At rest, T = 0 and M = 1 (all effort goes to internal updates). As motion increases, T consumes more of the total, leaving less for M, so internal ticks slow. The equation M = √(1 − v²/c²) is just that trade expressed numerically.
• Reciprocal observation: Each observer measures their own M = 1, but sees the other’s clock reduced by 1/γ. This symmetry appears because every frame applies the same C² = T² + M² normalization independently. No absolute background is required.
• Time symmetry as emulation: The Lorentz factor γ itself is an emulation—a numeric balancing act ensuring both frames conserve the same total budget C. The genuine mechanism of symmetry restoration happens later through beat matching and queue buffering in the Ledger, where commit timing across frames is reconciled into a consistent history (see Beat Matching and Frame Syncing).

In summary, plugging the budget law into the Lorentz factor shows that relativistic time dilation is not geometric—it is the visible shadow of how motion trades causal bandwidth against local time.

Once C² = T² + M² is multiplied by physical units, the CBF budget becomes the familiar energy–momentum relation. T represents translational activity (momentum flow); M represents internal maintenance (rest mass energy). The squared invariance simply states that both draw from one conserved causal resource.

• From causal to physical units: Attach Planck’s constant through E = ℏω and p = ℏk. With c = a/τ as the lattice speed, multiplying the normalized identity T² + M² = 1 by (ℏ/τ)² yields E² = (pc)² + (mc²)². This connects causal geometry directly to the physical constants of SR.
• Translation → Momentum: The T share drives spatial propagation. Its phase rate maps to momentum p = ℏk, with higher translation share giving larger wavevector magnitude. Motion is momentum viewed as budget flow through space.
• Maintenance → Mass: The M share sustains bound oscillation at frequency ω₀. Identifying ℏω₀ = mc² ties the internal update rate directly to rest energy. Mass is thus the cost of keeping a local state active between commits.
• Total energy: Combining both shares gives E² = (ℏck)² + (ℏω₀)² = (pc)² + (mc²)², which follows automatically from the CBF invariant. Rest energy is the M-term; kinetic energy emerges from the T-term as motion reallocates budget.
• Interpretation: Energy and momentum are not primitive forces—they are accounting labels on causal flow. The equation simply asserts that whatever portion of C goes into motion (T) reduces what remains for maintenance (M), keeping the total invariant across all frames.

The result is that the famous relativistic energy law is not postulated in CBF. It falls out naturally once the budget rule is expressed in physical units: mass is maintenance cost, momentum is translation share, and energy is their combined tally.

In CBF, a bound state at rest has T carrying a baseline oscillation rate ω₀ while M funds the upkeep that keeps that oscillation viable. The intrinsic energy scale follows directly: E₀ = ℏω₀ = mc². Mass is the maintenance cost required to keep the baseline T-phase running.

• Rest energy from M (and T-phase): At v = 0, T = 0 for translation and M = 1 for maintenance. The bound state’s internal T-phase advances at ω₀, giving E₀ = ℏω₀. Here M is the budget that sustains the structure whose T-phase defines ω₀.
• Compton frequency: The rest “heartbeat” of matter is f₀ = E₀/h = mc²/h. It is the baseline advance of the bound T-phase when all budget is available to M for stability (rest frame).
• Moving energy: When v > 0, more budget flows to T (translation), leaving less for M. The total energy reads E = γ mc² = γ ℏω₀, with γ coming from the invariant C² = T² + M². Kinetic energy is the extra tally from shifting budget into translation.
• Interpretation: Mass is maintenance cost, energy is the tally, momentum is translation share. The familiar equivalence E₀ = mc² is the unit-scaled statement that sustaining the baseline T-phase consumes a fixed maintenance budget per tick.

This makes E₀ = mc² a bookkeeping identity inside the budget law rather than a separate postulate: keep ω₀ running, pay with M, and the rest energy follows as ℏω₀.

In CBF, motion changes the local maintenance rate M, so clocks at different velocities tick at different frequencies f_M = f₀/γ(v). The Event Ledger buffers interactions until both sides reach a compatible phase and then records a joint commit. The operational “waiting” is what shows up as time dilation.

• Frequency mismatch: Distinct velocities produce distinct M-rates. The Ledger compares the running phases with its temporal gate and only commits when the phase difference is inside tolerance.
• Maintenance-channel directionality (M_ch): The M_ch term is the channel maintenance share relevant for cross-frame alignment. It captures how difficult it is to reconcile timelines when the interaction has a preferred direction relative to the relative velocity vector. Larger M_ch means stronger directional penalty for misalignment.
• Commit delay from beats and direction: Let Δf_M be the difference between the frames’ maintenance frequencies and θ the angle between the relative velocity vector and the Ledger’s synchronization direction n̂. The directional reconciliation time is
  τ_commit = τ₀ + 1 / [ f₀ ( |Δf_M| + M_ch (1 − cos θ) ) ].
  Larger |Δf_M| or larger angular penalty M_ch(1 − cos θ) both increase the wait for acceptable phase alignment.
• Confidence gating vs streaming: The Ledger can reconcile in batches (wait for a threshold then commit) or by micro-alignment (continuous small commits). Both modes yield the same Lorentz symmetry after reconciliation.
• Twin paradox in CBF: The frame with smaller M accrues fewer internal updates. On reunion, beat matching aligns event order and the shared history reflects the lower tick count of the high-velocity frame. No acceleration story is required.
• Time symmetry clarified: Beat matching explains when synchronized commits happen. The reciprocal “both slow” appearance is completed by queue buffering, where slow-M frames accumulate backlogs that make the other appear delayed as well.

Net effect: the Event Ledger converts frequency and directional mismatches into controlled commit delays. When phases converge, a joint event is recorded and all inconsistent candidates are pruned in the D-ledger.

In CBF, each frame runs its own causal loop of translation (T) and maintenance (M). Frames with smaller M (higher velocity) can process fewer internal commits per global tick, so they begin to queue unresolved events in the Ledger. This backlog is the computational origin of relativistic time symmetry.

• Queue depth ρ_q: The number of pending commits grows roughly as ρ_q ∝ (1/M) − 1. Higher velocity (smaller M) → larger ρ_q. Lower velocity frames drain their queues quickly and thus appear to “age” faster.
• Perceived reciprocity: Each frame measures the other through its own buffered queue. A sees B’s delayed commits and concludes “B’s time runs slow.” B sees A’s delayed commits in its own buffer and concludes the same. The reciprocity arises because both observe through asynchronous queues, not because spacetime itself is symmetric.
• Ledger reconciliation: When the queues empty—through beat matching—both histories merge into one ordered ledger. The shared record shows that the low-M frame accumulated fewer internal commits, matching the standard time-dilation result.
• Operational meaning of γ: The Lorentz factor is the steady-state ratio between queue depths: γ ≈ 1 + ρ_q. It is not a geometric constant but a measure of how far a frame’s buffer lags behind the global commit cycle.

Together, beat matching and queue buffering explain why time dilation looks symmetric even though only one process is happening: slower-M frames simply fall behind in commit processing. The Event Ledger converts those backlogs into a consistent, shared timeline once reconciliation completes.

• Commit locality: Every commit is a real position in the Ledger, but its apparent position depends on the observer’s pacing field α(x). The Ledger fixes where and when a collapse occurs; the observer’s α-slice determines where that event appears in their projection of space.
• Extending beat-matching: Phase alignment (beat-matching) synchronizes internal M oscillations, but moving systems must also align their T advances so that motion remains consistent across frames. The observer reprojects incoming commits by re-synchronizing both M and T, ensuring that what is simultaneous in their pacing remains causally ordered in the Ledger.
• Why this appears as contraction: Systems with less M have fewer commits per tick but greater translation between each. When reprojected through a higher-M observer’s α-slice, these sparse commits line up along the direction of motion, making the object appear compressed even though no atomic positions have changed. The “flattening” is purely geometric, a side effect of aligning both T and M for causal agreement.
• Spatial relativity summarized: Time alignment keeps events in order; space alignment keeps motion continuous. Both must reconcile for a collapse to appear consistent to all observers. What each frame sees as distance or contraction is just its own projection of where the Ledger’s commits fit within its α-paced now.

In CBF, both motion and maintenance are expressed as update rates: the T-channel advances phase per spatial tick (wavevector k), and the M-channel advances phase per temporal tick (frequency ω). Planck’s constant ℏ acts as the universal exchange rate that turns these discrete tick rates into physical quantities: E = ℏω and p = ℏk. The same conversion constant applies to both photons (pure T-channel) and matter (mixed T+M), showing that quantum behavior is simply the unit-scaled language of the causal budget.

• Universal exchange rate: ℏ maps “ticks per update” to joules and newton-seconds. It is not a separate physical field—just the translation key between causal clock cycles and measurable energy. Because the same ℏ applies to both channels, photons and matter obey one accounting rule under the same constant.
• Photons (pure T-channel): For light, M = 0, so all causal activity is translational. The T-phase oscillates at frequency f or angular rate ω = 2πf, giving E = ℏω. In the photoelectric effect, this energy transfers directly to an absorber’s M-channel, raising its maintenance energy by the same amount.
• Matter waves (mixed T+M): Bound systems maintain an internal oscillation frequency ω₀ = mc²/ℏ (the Compton frequency). The same ℏ converts that maintenance rate to rest energy E₀ = ℏω₀ = mc², proving that both mass energy and photon energy share the same tick-to-joule conversion.
• Matter-wave interferometry: Experiments that measure interference fringes in atom or neutron beams determine ℏ indirectly by tracking phase accumulation at the rest frequency f₀ = mc²/h. These confirm that the same constant governs both the maintenance oscillations of matter and the translational phase of light.
• Bridge meaning: ℏ is the interface constant between causal simulation space and observed physics. It translates internal update rates into measurable energy, momentum, and frequency, turning the discrete causal budget C = T + M into the continuous field equations of quantum mechanics.

In this view, Planck’s constant is not a fundamental mystery. It is the scaling factor that lets a computationally discrete universe express itself in continuous physical units. The same ℏ ties photons, electrons, and all matter to one causal accounting system.

The α-field defines how much of the global causal cycle C is realized locally each tick. When α(x) drops below one, less of the available T + M budget is executed per global step. Proper time slows because every update must now span more global ticks to complete the same maintenance work.

• Budget contraction: The pacing field scales the active causal budget as C_local = α(x) · C. Where α(x) < 1, both motion and internal ticking consume a smaller causal share per step. Time dilation is simply this contraction of execution rate.
• Energy balance: Local energy E = ℏω scales with α(x). A lower α slows internal oscillations, giving redshift directly from reduced causal throughput.
• Velocity independence: Motion and gravity are unified by pacing: special-relativistic slowdown comes from shifting T↔M within a constant α, while gravitational slowdown comes from α itself shrinking the whole C budget.
• Relation to queue density: α ≈ 1/(1 + ρ_q) (see Gravity is queue buffering). The deeper the queue, the smaller the fraction of the global tick realized locally.
• Observable time dilation: Any redshift, delay, or clock differential is a direct readout of α differences: Δt_obs/Δt_ref = 1/α. Experiments like Pound–Rebka and GPS clock offsets measure this pacing contraction.

The α-field therefore enforces time dilation by throttling the available causal budget itself. Later, Curvature as time dilation shows how these pacing gradients appear as geometry to observers.

In CBF, C is the invariant causal speed that governs the total T + M budget. The local pacing field α(x) rescales that causal rate within gravity wells or dense materials. It represents the fraction of the global tick that a region experiences as proper time.

• Lapse function α(x): α(x) = dτ/dt gives the ratio of local proper-time progression per global tick. When α(x) < 1, fewer maintenance updates occur locally, producing gravitational time dilation.
• Isotropic Schwarzschild scaling: In a static spherical field, α(r) = (1 − GM/(2rc²)) / (1 + GM/(2rc²)) and ψ(r) = 1 + GM/(2rc²). These dual scalars reproduce the Schwarzschild metric in isotropic coordinates.
• Dual-scalar formalism: α(x) controls temporal pacing, ψ(x) controls spatial scaling. Their coupled evolution replaces Einstein curvature: α²ψ⁴ = constant expresses causal pacing conservation across space and time.
• Event horizon: As α → 0, local commits asymptotically stall relative to distant observers. From the inside, clocks still advance; externally, they appear frozen. This limit defines the computational horizon where Ledger synchronization halts.
• Continuity and locality: Although α(x) varies smoothly, all updates are still locally computed. Curvature in GR corresponds to gradients of α and ψ in CBF—continuous pacing, not continuous space.

Thus α(x) translates the universal causal rate C into local commit cadence. Variations in α(x) and ψ(x) explain gravitational redshift, time dilation, and apparent curvature as pacing effects, not geometric warping.

In CBF, the α-field is not a geometric property of spacetime, but the visible record of how efficiently regions process commits in the Event Ledger. When local demand for maintenance (M) exceeds the available causal budget (C), pending updates accumulate as a queue buffer. This backlog directly lowers α(x): fewer commits per global tick means slower proper time.

• Definition: Queue density ρ_q = (pending commits)/(processed commits). The local pacing ratio is α(x) ≈ 1 / (1 + ρ_q). A deeper queue (larger ρ_q) yields a smaller α—slower local time.
• Mass and load: Matter consumes budget through its internal maintenance channel (M). Dense or highly active regions generate more collapse events and therefore longer queues. The surrounding α-field records this load imbalance.
• Feedback loop: Lower α further slows processing, reinforcing queue buildup. The Ledger stabilizes the system by distributing commit pacing smoothly, producing continuous α(x) gradients.
• Observable effects: Clocks near massive bodies show α < 1 (slower pacing), while clocks far away have α ≈ 1 (normal pacing). The gravitational potential Φ corresponds to the queue imbalance: Φ ∝ (1 − α).
• Unified principle: The same rule applies across scales: microscopic decoherence queues produce local α variations in materials, while astronomical queue networks produce gravitational fields.

Queue buffering is the α-field. Gravity, redshift, and time dilation are all manifestations of this single pacing variable: α(x) = dτ/dt = 1/(1 + ρ_q). The next section, Curvature as time dilation, shows how these pacing gradients appear geometrically to observers.

In CBF, curvature emerges from gradients in the α-field, which itself arises from queue buffering inside the Event Ledger. Where α(x) varies, commit pacing differs from place to place: slower regions accumulate longer queues, faster regions process more events. The smooth interpolation between these pacing rates forms what observers interpret as spacetime curvature.

• Pacing gradient as curvature: The gradient ∇α(x) defines the local slope of proper time. Neighboring regions update at slightly different rates, so synchronization requires continual re-vectorization of motion. GR’s curvature tensor is the macroscopic record of this pacing field.
• Geodesic reinterpretation: In GR, a free body follows a path that maximizes proper time. In CBF, the same effect arises because motion follows the route of minimal commit cost, keeping phase alignment across α(x) gradients: δ∫α(x)‖v‖dt = 0.
• Unified with GR metrics: The dual-scalar fields α(r) = (1 − GM/2rc²)/(1 + GM/2rc²) and ψ(r) = 1 + GM/2rc² reproduce Schwarzschild geometry exactly, but without invoking a curved substrate. Space and time appear curved because α and ψ vary smoothly due to queue load balancing.
• Local flatness preserved: Each small region still executes commits in flat causal order; only pacing ratios differ. The illusion of curvature arises from comparing neighboring commit speeds, not from bent trajectories in a true manifold.
• Gravity as pattern, not force: Mass does not pull on space; it merely slows local commit rates. The resulting α(x) map guides motion as if curvature existed, reproducing every classical GR effect from time dilation alone.

In summary, curvature is the large-scale expression of how the queue-buffered α-field redistributes the causal budget across space. Time dilation is not a side effect of curvature—curvature is the observable imprint of time dilation.

In CBF, nothing actually acts across distance. What we call “gravitational influence” is the Event Ledger continuously stabilizing the causal budget so that all regions remain synchronized. This regulation principle is the Global Budget Synchronization Law (GBSL): the sum of all local pacing changes must still satisfy the global invariant ∑(αC) = constant.

• Feedback loop: When any region’s α drops, its commit rate slows, causing queues to deepen locally. The GBSL redistributes causal credit across the Ledger so that the global average pacing stays fixed. This automatic adjustment produces smooth α(x) gradients instead of sharp discontinuities.
• Why gravity feels instantaneous: Changes in α(x) do not propagate through space at finite speed. They are registered through Ledger synchronization—the same global commit cycle that defines simultaneity. Once a region’s pacing changes, the global update enforces new relative α values everywhere at the next tick. To observers, this looks like instantaneous adjustment of the gravitational field.
• Local causality preserved: Although the global budget is rebalanced every tick, individual commits remain strictly local. No superluminal messages occur; only the bookkeeping of available causal credit is shared across the network.
• Emergent stability: The GBSL prevents runaway collapse or singular pacing. If one area accumulates excess queue density ρ_q, its α lowers, drawing extra causal credit from neighboring regions until equilibrium is restored. This continuous balancing is why gravity forms smooth fields rather than discrete jumps.
• Global coherence: The entire α-map is a live consensus of pacing rates. The Ledger enforces this coherence so that proper time remains globally consistent and energy is conserved under the relation C² = T² + M².

The GBSL therefore unites local queue buffering with global gravitational stability. What seems like “action at a distance” is really the Event Ledger keeping every region’s pacing budget synchronized to the same causal cycle.

A particle is a coherent sphere of wave cells sharing a common internal frequency ω₀. Each cell still obeys its local α(x), so across a gradient the near side commits more slowly than the far side. The Event Ledger continuously reconciles these differences, ensuring the entire packet stays frame-locked so it is not torn apart as it moves through the pacing field.

• In-flight reconciliation: The Ledger performs micro-commits that reassign small amounts of T from faster cells to slower ones, maintaining a shared phase and conserving C² = T² + M². These tiny transfers happen every tick, preventing phase drift within the particle.
• Directional refraction: The cumulative effect of this re-vectorization satisfies d k̂ / dt ∝ −∇α(x); wave cells bend toward lower α just as light bends toward higher refractive index n = 1/α.
• GBSL coupling: The Global Budget Synchronization Law links all local reconciliations to the same global tick. Each particle’s in-flight frame correction references the same global pacing cycle that maintains gravitational coherence. This keeps every particle’s internal clock consistent with the larger α-field, even while moving through gradients.
• Frame self-sync: Because GBSL provides a universal commit cadence, particles can maintain internal phase alignment autonomously. No collisions or discrete events are needed, Ledger synchronization alone keeps them coherent in flight.
• Unified behavior: Photons and matter both follow α-gradients under the same synchronization rule. What differs is their maintenance share (M = 0 for photons, M > 0 for matter), not their gravitational logic.
  Note: Everything bends because α(x) scales the local causal budget C. However, anything requiring M bends more, because its internal maintenance slows motion, giving the Global Budget Synchronization Law more time to frame-sync it into the surrounding pacing field.

The Event Ledger’s in-flight reconciliation ensures that each particle remains internally phase-locked, while the Global Budget Synchronization Law ensures that all particles stay compatible with the same universal pacing field. Together they make gravity, motion, and coherence part of a single synchronization process.

When an object is held in a gravitational gradient, any incoming T from external or internal particles is stored in M as vibrations. We call this potential energy. Extra T can circulate through the lattice, but it accumulates from the bottom up due to queue buffering where α(x) is smaller. Because the Global Budget Synchronization Law continually re-vectorizes particles toward lower α, most of the stored translation ends up aimed downward.

• Bottom-up storage: Lower atoms tick more slowly (smaller α), so their commits lag and they absorb more T as local M vibration. The lattice records this as a vertical gradient of queued maintenance.
• Release and push: When the constraint is removed, the stored downward-aimed T is allowed to act. The object is pushed toward a more stable pacing configuration along the α-gradient, converting vibration back into motion.
• Feedback loop: As the object descends, it enters regions of even smaller α. The imbalance grows and re-vectorization strengthens. The cycle continues until aerodynamic drag establishes terminal velocity or the object reaches the ground.
• Lattice bookkeeping: Throughout the fall, atoms exchange small T↔M adjustments to maintain coherence while following the pacing field. Details of these transfers are in Atomic energy transfer: T↔M in the lattice.

Macroscopic acceleration is therefore budget flow made visible: holding stores translation as maintenance from the bottom up, releasing lets that budget drive motion down the α-field until a new steady state is reached.

In CBF, curvature and gravity arise from queue buffering: α(x) controls commit pacing, ψ(x) controls spatial reconciliation. When massive systems (like binary stars) shift rapidly, their local queue densities cannot instantly re-equilibrate. The excess pacing stress propagates outward through the Event Ledger as a self-healing wave of α and ψ oscillations—the gravitational wave.

• Ledger dynamics: Time-dependent α(x,t) and ψ(x,t) represent oscillations in commit cadence and spatial credit. Their coupling forms a discrete wave equation equivalent to the GR transverse-traceless modes (+ and ×).
• Propagation at c: Because all commits share the same causal budget C, pacing ripples move at that same speed. In frequency space, the dispersion relation ω² = c²k² arises directly from balanced T↔M exchange between neighboring queue cells.
• Energy cost: Maintaining a gravitational wave consumes causal budget: queue density must oscillate coherently. The required effort scales with the square of the amplitude and frequency, ⟨E⟩ ∝ (∂α/∂t)² ∝ ω²h², reproducing the Isaacson energy flux without importing GR’s tensor machinery.
• Detection mechanism: In an interferometer such as LIGO, mirrors sit in separated ledger nodes. As the α-field oscillates, their local commit clocks drift in and out of phase, changing the count of laser ticks between them. The measured strain ΔL/L ≈ h/2 is a direct readout of queue cadence modulation.
• Consistency with observation: Observed events (GW150914, GW170817, etc.) show h ≈ 10⁻²¹ and |v_GW − c|/c < 10⁻¹⁵, precisely the propagation speed and amplitude expected from CBF’s pacing-field model. Two orthogonal polarization modes arise naturally from the bidirectional re-vectorization of the α and ψ ledgers.

In CBF, gravitational waves are not distortions of a static spacetime metric but rhythmic redistributions of commit pacing in the Event Ledger. They reveal that even spacetime’s smoothest background is a living computation—one that rings when mass moves.

In CBF, every atom is an autonomous node that receives, processes, and re-emits causal budget through its internal M and T channels. When a particle is absorbed, its translation share T cannot move the atom as a whole because the lattice constraints prevent net motion. Instead, that translation is converted into local maintenance work—M vibration.

• Absorption: A passing particle deposits its T budget into an atom’s internal oscillation. The atom’s M share rises, storing energy as lattice vibration (heat).
• Confinement: Because atoms in a solid share bonds, they cannot translate freely. Each atom passes a small portion of its increased M to its neighbors, distributing the absorbed energy through the lattice as phonon-like oscillations.
• Release: When vibration exceeds the stability threshold, the atom ejects a new particle. The stored maintenance converts back into translation—M → T. The emitted particle carries the original wave’s phase signature (birth-frame T+M ratio).
• Photon “birth”: Even though photons have no ongoing M, they inherit an effective “birth budget” from the parent atom: its last oscillation defines the photon’s ω = (T+M)/ℏ. Thus photons still encode the causal energy of their source’s final maintenance tick.
• Bond breaking: If T influx is excessive, local α(x) cannot keep up, and the Ledger redistributes budget by dissolving the bond. The atom detaches or ejects a particle, releasing stored energy and restoring pacing equilibrium.

This T↔M exchange is the atomic foundation of thermodynamics and radiation in CBF. Vibration corresponds to queued maintenance, emission corresponds to the release of that queue as new translation, and all of it obeys the same global pacing enforced by the Global Budget Synchronization Law.

When atoms release stored M vibration, that causal budget re-enters the translation channel T. The Event Ledger records these transfers as directed translation flows—continuous chains of commits that move through space at the universal rate C. These flows form what classical physics calls the electromagnetic field.

• Emission as T-pulse: Each atomic release injects a quantized packet of T into the surrounding α-field. The packet expands as coherent wave cells that carry phase and polarization from the parent atom’s final oscillation.
• Propagation rule: The wavefront advances according to the local pacing α(x) and material coupling MCF(x, ω). α sets speed (c = a/τ), MCF adds delay, loss, and refraction—together reproducing the discrete form of Maxwell’s equations.
• Field continuity: Because every atom is both a sender and receiver of T, the lattice forms a continuous translation network. The alternating surplus and deficit of T between neighbors appears as the oscillating electric and magnetic components (E and B).
• Energy flow: The causal flux S = E×B/μ₀ is simply the rate at which translation budget moves through the Ledger per global tick. Conservation of C ensures ∇·S + ∂u/∂t = 0, matching the Poynting theorem.
• Charge and current: Persistent asymmetry in T↔M exchange defines charge density. A moving imbalance—atoms giving and taking T out of phase—creates the macroscopic current J, which sustains larger-scale α and ψ gradients interpreted as electromagnetic fields.
• Photon as T-carrier: A free photon is a region where T propagation is detached from any single atom. Its internal phase tracks the original atom’s maintenance tick, allowing energy and information to travel through the network losslessly until re-absorbed.

Electromagnetism in CBF is therefore not a separate force but the translation layer of the same causal budget. Waves, light, and radiation are the visible motion of T credit moving between atoms under the pacing constraints of α(x) and the coupling rules of MCF(x, ω). The next sections expand these discrete updates into the familiar continuous Maxwell form.

In CBF, the electromagnetic field is simply how the translation share (T) and maintenance share (M) distribute and exchange across the Event Ledger. Every ledger node carries a local snapshot of how much causal budget is in motion (T) versus held as tension or storage (M). What classical physics calls “E” and “B” are two complementary views of that same flow.

• Electric field E: The directional pressure of translation credit between neighboring nodes. It shows how strongly local T wants to move or redistribute. Large E means translation budget is unevenly loaded and is seeking equilibrium.
• Magnetic field B: The rotational memory of maintenance coupling—the stored swirl of M that resists straight-line translation. B represents how T-flows loop back through the ledger to preserve total balance.
• Poynting vector S: The net flux of translation credit, S = E × B / μ₀ in conventional form. It tracks the direction and rate at which causal budget moves through the network. In CBF, this is literally the per-tick motion of T across connected ledger cells.
• Energy density u: The instantaneous maintenance cost of sustaining the field pattern, u ∝ (E² + B²). It is the portion of M locked into local oscillation rather than free translation.

E and B are therefore bookkeeping views of one conserved quantity—the causal budget C. Where translation accumulates, we see electric potential; where translation circulates, we see magnetic structure. The field is not a medium in space but the evolving pattern of T↔M exchange recorded in the Ledger.

In CBF, the electromagnetic field does not require separate axioms. The familiar Maxwell equations appear automatically once we require that every ledger node and its neighbors conserve total causal budget: translation credit cannot disappear, and maintenance storage cannot accumulate untracked. Each equation is simply a different view of that same accounting rule applied to local flows of T and M.

• Faraday’s law (∇×E = −∂B/∂t): When translation budget circulates in a loop (changing E), it drains or builds the local maintenance swirl (B). A shift in T flow forces a re-allocation of M storage, so field circulation and field change are inseparable bookkeeping entries.
• Ampère–Maxwell law (∇×B = μ₀J + ∂E/∂t): When maintenance circulation (B) varies, the Ledger records that energy either as a current of moving translation (J) or as changing electric pressure (E). Magnetic swirl converts back into linear translation flow—M→T exchange in action.
• Gauss’s law (∇·E = ρ/ε₀): A local surplus of translation credit appears as charge density ρ. Whenever T flows outward faster than it is replenished, the Ledger marks a positive charge; inward flow marks a deficit. Charge is just translation imbalance, not a separate substance.
• No magnetic charge (∇·B = 0): Maintenance circulation always closes on itself. Every stored rotation of M is internally reconciled by the Ledger, leaving no free end to act as a magnetic monopole.

Together these four relations form the bookkeeping core of electromagnetism: the Event Ledger enforces that all exchanges between T and M balance perfectly per tick. Classical Maxwell equations are simply the continuous-limit shorthand for that causal conservation.

In CBF, spin is not an abstract quantum number but the internal phase rhythm of the maintenance channel M. Since M carries the local time share of the budget, any rotation within it produces a periodic translation response in T. The alternation between stored spin (in M) and outward translation (in T) is what classical physics observes as electric and magnetic field rotation.

• Spin as bound oscillation: A particle’s intrinsic spin represents the internal rotation of its M state. When M rotates by 180°, T flips direction; a full 360° rotation restores the original T orientation only after two M half-cycles. This produces the characteristic ½-spin symmetry—two turns per full T oscillation.
• T-M resonance: Each tick, part of the maintenance rotation releases translation credit, which propagates outward as E, while returning T flow rebuilds the internal M rotation as B. The ongoing exchange sustains self-propagating waves at the causal speed C.
• Field rotation: Because spin and translation are out of phase by 90°, their alternation naturally forms orthogonal components. The E and B fields are simply the visible projection of this T↔M rotation within the pacing field.
• Photons as spin-free propagation: For ω₀ = 0, there is no maintenance rotation to store energy; all budget remains in translation. The result is pure wave motion—linear dispersion ω = ck with no rest frame.

Spin in M is therefore the hidden clock of all oscillation. Every field wave, photon, and particle oscillation is the visible trace of T following M’s internal rotation schedule. The quantum-mechanical ½-spin rule emerges naturally from this two-tick budget alternation between stored and translated states.

In CBF, every event node keeps its own internal record of translation (T) and maintenance (M) credits. The potentials (φ, A) of classical electromagnetism are simply the running totals of these accounts—the local “balance sheets” that track how much causal budget has been committed or reserved.

• Re-labeling freedom: Changing the potential by (A, φ) → (A + ∇χ, φ − ∂χ/∂t) is equivalent to renaming internal ledger columns. It doesn’t alter any observable transfers because physical effects depend only on differences in credit, not absolute labels. The Ledger always settles by deltas, not totals.
• Observable invariants: Quantities such as E = −∂A/∂t − ∇φ and B = ∇×A describe the measurable flow and storage of budget between nodes. They remain unchanged under any re-labeling, which is why experiments only ever detect field differences (E, B, S), not the bookkeeping itself.
• Local autonomy: Each node can adjust its internal phase reference (the χ field) independently, allowing neighboring regions to stay synchronized without sharing full account histories. This distributed autonomy makes the CBF update scheme naturally gauge-invariant, since only exchanges at the ledger boundary are visible.
• Numerical view: Finite-difference or cellular implementations that work directly with E and B operate on these measurable flows. No hidden potential data are needed—the simulation is gauge-free by construction, because it tracks causal budget directly.

Gauge invariance in CBF is therefore not an abstract symmetry but an accounting property: the universe conserves what flows between nodes, not how each node names its internal columns. The redundancy protects causal continuity, ensuring that only physically shared commitments affect reality.

In CBF, conservation is enforced locally by the Event Ledger: what leaves a region as translation T either enters a neighbor as T or is recorded as increased maintenance M in matter via the MCF. This local balance yields the Poynting relations without any separate global constraint.

• Fields as accounts: The electric field tracks T-pressure, the magnetic field tracks rotational M-memory. The energy density is the maintenance being carried by the field pattern, u ∝ E² + B², and the flux of translation credit is the Poynting vector S = E × B / μ₀.
• Differential balance: Local conservation reads ∂u/∂t + ∇·S = − J·E. The term J·E is the ledger entry that converts field translation into atomic maintenance through the MCF (T → M work on matter).
• Integral balance: Over a volume, d/dt ∫ u dV + ∮ S·dS = − ∫ J·E dV. Increase of stored field maintenance plus outward translation flow equals the work delivered to charges.
• Ledger view: Each tick, the Ledger reconciles these three terms so that the total C-budget is unchanged. No hidden reservoirs are allowed: any decrease in field u or outward S must appear as added M in matter, or vice versa.
• Discrete implementation: Cellular and finite-difference updates that track E, B, and J directly conserve to machine precision, since they apply the same add and subtract operations the Ledger uses on T and M.

Poynting’s theorem in CBF is simply the statement that the field’s translation account and matter’s maintenance account are reconciled locally each tick. Energy conservation is causal budget conservation.

In CBF, the same C = T + M law governs both matter and field. Charged particles are ledger nodes that trade translation credit with the surrounding T-field. Each exchange updates both sides of the ledger: a field loses or gains T exactly as the particle’s maintenance or motion changes.

• Current source J: Represents the ongoing flow of translation budget between matter and field. When charges move, they inject or extract T into the field, appearing as the source term in the Ampère–Maxwell balance.
• Charge density ρ: A standing imbalance in T credit. Local excess creates an outward E divergence (repulsion); deficit produces inward pull (attraction).
• Lorentz steering: Spatial gradients in E and B redirect a particle’s translation share. Acceleration is not a force but a redistribution of T across directions while keeping total C constant.

The Lorentz force law and charge-current continuity are therefore bookkeeping consequences of the same event-by-event exchanges already managed by the Event Ledger.

The Material Coupling Field describes how a region’s composition, density, and structure influence wave propagation. Instead of labeling “metal,” “glass,” or “vacuum,” CBF computes MCF directly from the per-cell properties that affect T↔M exchange.

• Definition: MCF(x, ω) = { n′(x, ω), loss(x, ω), absorb(x, ω), scatter(x, ω) }. Each term encodes how much translation amplitude is delayed, drained, or redirected by local maintenance coupling.
• TTL linkage: TTL drains through MCF as dA/dt ∝ −A·h(x, ω), where h increases with frequency. High-loss regions shorten wave survival, low-loss regions extend it.
• Attenuation and refraction: The real part n′ changes phase speed (bending, delay); the imaginary part (loss, absorb) depletes amplitude. Together they explain how light slows in water, tunnels through thin barriers, or fades in metal without needing additional forces.
• Dark-matter scar link: Dissipated power E²·loss(x, ω) leaves a trace in the D-field, marking where wave activity once pruned history.

The MCF is thus the macroscopic bridge between quantum-level matter–field exchanges and large-scale wave behavior. It defines how environments guide, bend, or extinguish translation budget, all under the same CBF accounting rule.

In CBF, ω₀ is the baseline maintenance frequency in the M channel that keeps a bound state coherent. Photons have ω₀ = 0 (no bound maintenance), matter has ω₀ > 0. This single knob removes conditional logic: species differ by parameter, not by rule.

• Unified dispersion: On the causal lattice the update gives ω² = c²k² + ω₀². For photons (ω₀ = 0): ω = ck. For matter (ω₀ > 0): propagation is dispersive with a rest frequency set by ω₀.
• Energy–momentum bridge: With ℏ as the units bridge: E = ℏω, p = ℏk, and E² = (pc)² + (mc²)² where mc² = ℏω₀. Rest energy is the cost of maintaining the bound M-rotation at ω₀.
• Spin and the internal clock: The maintenance rotation at ω₀ sets the Compton rate f₀ = ω₀/2π = mc²/h. In CBF, spin lives in M and drives out-of-phase oscillation in T; half-spin behavior appears as two M half-turns per full T orientation cycle.
• Same rule, different regimes: Photons are pure translation flow (M=0) with phase carried in T. Massive quanta keep a nonzero baseline in M, which slows motion and enables rest frames. Both follow the same C-budget update.
• Implementation simplicity: Simulation uses one stencil and one parameter. Switching ω₀ continuously morphs between photon-like and matter-like behavior, avoiding species-specific branches.
• Measurement link: The observed “mass” is the ledger’s maintenance cost: increase ω₀ and you raise rest energy, tighten spin timing, and reduce available T share for motion at fixed budget.

A single maintenance frequency parameter, ω₀, ties together dispersion, E–p (energy–momentum) relations, spin timing, and the photon–matter divide. CBF does not add forces or cases, it assigns one budgeted clock to each species and lets the Event Ledger do the rest.

• Continuous field, discrete history: The EM field oscillates continuously, but the Ledger only records successful commit events where amplitude crosses the detection threshold. These commits appear as photon detections.
• Energy per commit: Each commit corresponds to one full T↔M exchange cycle carrying energy ΔE = ℏω, linking Planck’s constant directly to commit quantization.
• Photon statistics: The observed quantum discreteness follows from commit sampling frequency, not from a quantized field substrate. The field itself remains a continuous causal budget flow.

• Spin-1 (photon): A full T↔M oscillation corresponds to one complete rotation of the causal budget vector. The field returns to its original phase after 2π, yielding integer spin.
• Spin-½ (fermions): Bound systems require two complete T↔M exchanges (a 4π rotation) to return to their original internal state, producing the half-integer spin symmetry of electrons and protons.
• Polarization as projection: Linear and circular polarization represent fixed phase relationships between T and M components along orthogonal lattice axes. The Ledger tracks these orientations as conserved quantum numbers.

• No hidden variable factorization: If outcomes were predetermined at emission with local realism (P(a,b|λ) = P(a|λ)·P(b|λ)), the Bell–CHSH inequality |E(θ_A,θ_B) − E(θ_A,θ_B')| + |E(θ_A',θ_B) + E(θ_A',θ_B')| ≤ 2 would always hold. CBF reproduces the quantum result 2√2 by relaxing factorization through global commit optimization.
• Emission stores constraints, not values: At emission, only the conservation rule is written: ⟨S₁ + S₂⟩ = 0 for a spin singlet, or ⟨E₁ + E₂⟩ = E_total for energy balance. No actual spin or energy values exist yet—just the constraint link between records.
• Measurement as joint reconciliation: Each detector logs a local pre-commit independently. The Ledger then reconciles both entries in their shared causal future, selecting outcomes that satisfy all stored conservation constraints. The correlation appears instantaneous only because the commit occurs globally, not locally.

• Local inputs, shared ledger: Each detector contributes its local measurement basis (θ_A, θ_B) and marginal expectation p_A(a) = p_B(b) = ½. The Ledger enforces a single conservation record ⟨a·n̂_A + b·n̂_B⟩ = 0 while reconciling all pending commits in the same global tick.
• Constraint-driven optimization: The SCG searches for a joint distribution P\*(a,b|θ) that minimizes global commit tension—equivalently, maximizes reconciliation stability—under normalization and conservation. This is mathematically identical to maximizing entropy over the set of allowed causal histories.
• Result for a spin-½ singlet: The self-consistent solution is P*(a,b|θ) = ¼(1 − ab cos θ), giving correlation E(θ) = −cos θ. For the standard CHSH settings (0°, 45°, 22.5°, 67.5°), the Ledger’s joint reconciliation saturates the Tsirelson bound, S = 2√2, without invoking superluminal communication.
• Interpretation: The SCG is the computational structure that replaces “spooky action.” Entangled outcomes are resolved together in a single causal commit step, preserving locality at the rule level while enforcing global coherence through the Ledger’s shared constraint space.

• Marginal independence: For all detector settings, the local distribution remains uniform: Σ_b P*(a,b | θ) = ½. Alice’s local outcomes are unaffected by Bob’s basis θ_B; no usable signal can appear in her stream alone.
• Correlation requires reconciliation: The observable correlation E(θ) = Σ ab P*(a,b | θ) = −cos θ appears only once both datasets are combined in a classical channel. This comparison step happens below the lightspeed limit and after both sides have individually committed their local events.
• SCG timing rule: The Ledger performs reconciliation at a commit time t_SCG > max(t_A + |x_SCG − x_A|/c, t_B + |x_SCG − x_B|/c). In other words, the Simultaneous Commit Group is resolved only in the joint causal future of both measurements—making faster-than-light signaling impossible by construction.
• Ledger-level causality: Constraint updates propagate through the Ledger as dependency resolutions, not as physical signals. Each region’s commit queue updates once required inputs arrive within light-cone limits. What appears as “instant correlation” is simply the outcome of synchronized commits, not superluminal communication.

• Constraint at emission: When an entangled pair is created, the Ledger records only a global rule such as ⟨S₁ + S₂⟩ = 0 or ⟨E₁ + E₂⟩ = E_total. No outcomes exist yet—only the dependency both future commits must satisfy.
• Independent local commits: Alice’s detector and Bob’s detector each register their outcomes independently. These commits enter the Ledger as provisional entries without referencing one another.
• SCG reconciliation: At the next permissible synchronization point (inside the shared causal future), the Simultaneous Commit Group re-evaluates both entries, verifying whether the pair (a, b) satisfies all stored conservation constraints. If not, the Ledger adjusts commit weights until global consistency is reached.
• Why “instantaneous” correlations appear: From an external frame the results seem simultaneous, but the underlying process is deferred reconciliation. The Ledger guarantees eventual constraint closure across its causal graph, just as queue buffering ensures time symmetry in motion. No information leaves either light cone—only dependency satisfaction propagates.

• GHZ and W states: For three-particle GHZ or W configurations, the Ledger records parity or amplitude conservation rules across all emitters. During reconciliation, the SCG evaluates joint outcome combinations and accepts only those that satisfy global parity (even-sum) or amplitude-balance constraints. The resulting tripartite correlations violate local realism while preserving causal order.
• Cluster states and scaling: Extending to N entangled sites produces an N-node SCG operating over the same causal field. Computational load increases with N, but the underlying rule never changes: all commits resolve through one shared constraint surface inside the joint light-cone volume.
• Unified mechanism: No new physics is required—only wider synchronization. Entanglement at any scale remains a consequence of the Ledger’s global constraint propagation, not of hidden channels between particles.

• Two-path setup: When both paths remain indistinguishable, the Event Ledger keeps multiple candidate branches active. Their overlapping phases beat-match through the temporal gate, producing the interference pattern.
• Which-path marking: Tagging a photon’s path adds informational metadata to each branch. The Informational Gate detects this and prunes incompatible branches before reconciliation, removing cross-term interference.
• Erasure: If that information is deleted before the global commit, the Ledger re-enables both branches. The interference pattern returns because phase comparisons are once again permitted at commit time.
• CBF interpretation: No retrocausality is needed—only deferred reconciliation. The final commit occurs when all informational, spatial, and temporal gates align. Whether interference or particle-like behavior appears depends entirely on what information remains in the Ledger’s causal context at that moment.

• Analog binary: Each wave cell carries fractional shares with T + M = 1 and 0 ≤ T,M ≤ 1. The value represents how much budget is currently allocated to motion (T) versus upkeep (M).
• SR encoding: With the invariant T² + M² = 1, reallocations of T and M are interpreted by the Ledger as the computational form of the Minkowski interval. Changing the T/M split encodes local velocity, curvature, and time dilation.
• Gravitational execution: Coordinated SR bits across a particle’s wave-cell lattice execute to bend or accelerate the trajectory toward the local α-field. The Event Ledger performs this via synchronized reallocation to keep all wave cells in the same frame. This can be thought of as SR bit execution.
• Atomic clockwork: In atoms, SR bits maintain near-steady equilibria: local T↔M trades keep bound structures coherent and timed. The same budget logic that bends free trajectories also drives internal timing for stable matter.

• Precision floor, not pixel size: The Planck length ℓ_P acts like a floating-point epsilon for coordinates and phase. It defines the minimum resolvable difference, not the simulation cell size.
• Working lattice vs precision layer: The update grid has spacing a and tick τ with c = a/τ (see C = T + M). Planck precision sits underneath this lattice so phase and positions can be represented with far finer resolution than a.
• Smooth wave transport: Photons advance at c with continuous phase. Over many cells the phase update accumulates as θ(x + λ) = θ(x) + 2π, maintained by sub-Planck numeric precision so no stair-step artifacts appear.
• No blockiness requirement: A larger working stride a does not imply jagged fields, because the wave cell state carries high-precision phase and direction. This is analogous to sub-pixel antialiasing: coarse pixels, fine math.
• What not to infer: Planck here is numeric precision, not a physical cell size or hidden pixel grid. The operative step for photon transport is the integer γ-length; Planck enters only as decimal accuracy for phase and coordinates. Do not read this as a second lattice or a new force. It is a precision budget used by the Event Ledger to reconcile smooth commits.

• Finite-state logic: An atom maintains a discrete set of internal states. Each state encodes a stable M allocation and allowed T↔M trades. Inputs are captured wave-cell commits, outputs are emitted quanta when rules enable release.
• Electron shells as states: Bound electrons inhabit discrete maintenance budgets (energy levels). Downward transitions convert surplus M to T and emit a photon. Upward transitions consume incoming T to raise M.
• Nuclear stability and decay: In CBF, atomic decay follows the TTL-drain rule. Each missed or failed internal collapse slightly reduces the atom’s effective survival probability (η = λ_keep / (λ_keep + λ_fail)). When TTL falls below threshold, the atom can no longer maintain its bound configuration. The Ledger reconciles the imbalance by emitting new particles—transferring excess M back into T as decay radiation. These local TTL drains also write persistent weights into the D-ledger, explaining the Bullet Cluster lensing offset through stability-weighted gravity sourcing.
• Chemistry as budget reallocation: Bonds form when shared configurations lower total upkeep, pushing the system toward a smaller net M. Inside matter, that M is stored as lattice vibration (phonon-like maintenance). Exothermic reactions convert freed M into T as emitted oscillations (heat/photons or bulk kinetic motion). Endothermic reactions pull in T to raise M, increasing internal vibration to stabilize new bonds. This matches the CBF rule that stored vibration in M becomes propagating oscillation in T when released.
• Why packets inflate outside and compress inside: In free flight, low local loss and gentle α(x) gradients let the packet spread so multiple atoms see viable phases. Near or inside matter, the MCF increases loss and scattering, draining TTL and funneling the packet into allowed atomic modes. The Ledger permits only branches consistent with the atom’s current state.
• Measurement inside the atom: Capture is a local commit that selects one branch of the inflating packet. The atom writes a new state to the Ledger, emits or withholds an output quantum according to its rules, and prunes alternatives through deferred reconciliation.

• Cosmic origin of T: The first causal imbalance at the Big Bang released the universe’s initial T budget. Every event since—including cooking a meal, shining a light, or radiating heat—uses that same T, passed through countless re-commits. The infrared photons leaving an oven decades ago are still propagating through space, waiting for a future commit.
• Heat as T overflow: When a particle or lattice absorbs more T than it can stabilize as M vibration, the excess is expelled as radiated T: photons, phonons, or conduction currents. This keeps the local C = T + M budget balanced while spreading entropy outward.
• Equilibrium as M saturation: Once all accessible M-storage sites (vibrational states) are filled, further T input is re-emitted immediately. This defines thermodynamic equilibrium—no more net conversion between T and M.
• Statistical law from commit history: There are more ways to spread T across many quanta than to confine it in one. The Event Ledger therefore records more distributed commits than concentrated ones. The second law is simply the statistical bias toward many small T commits rather than few large ones.
• TTL and irreversibility: Each failed attempt to store T as M drains TTL and leaves a pruning trace in the D-ledger. These scars accumulate, making perfect reversal impossible and giving rise to macroscopic irreversibility.

• Free atoms (gases, plasmas): Incoming photons or particles deposit T directly into atomic translation. Each absorption event adds momentum to the atom’s vector, increasing its kinetic energy. Hot air in an oven moves faster because infrared (IR) photons from the walls collapse into free atoms, boosting their T share.
• Bound atoms (solids, liquids): Atoms locked in a lattice cannot freely translate, so absorbed T is redirected into M vibration. The lattice bonds push back, converting translational impulse into oscillatory motion—vibration, phonons, and eventually thermal emission.
• Heat transfer as T–M exchange: The interface between free and bound regions (for example, air hitting a hot metal surface) mediates the swap between T motion and M vibration. IR emission from the metal is simply the re-release of T once local M exceeds its stable range.
• Feedback stability: Because M vibration increases with temperature, hotter regions emit T more readily, automatically damping runaway heating. This self-regulation makes the oven and the universe thermodynamically stable.

• Local rule: Each H₂O molecule follows the same update: if its instantaneous T_i exceeds the bonding M_i, it detaches. Clusters of such molecules mark vapor pockets—regions where translation dominates.
• Solid → liquid → gas ladder: In solids, almost all budget sits in M (bond vibration). In liquids, some T converts to local sliding motion. In gas, T dominates—free translation. Boiling marks the point where ⟨T⟩ ≳ M_bond on average, triggering global percolation of free motion.
• Heating mechanism: Infrared photons add small ΔT impulses to molecules. The hydrogen-bond network resists via M, storing vibration until local T kicks momentarily align, producing collective pushes outward. These transient coherent bursts nucleate vapor bubbles.
• Statistical interpretation: “Phase locking” here does not mean laser-like coherence but temporary directional bias—local queue synchronization where random thermal kicks reinforce instead of cancel. Classical nucleation is recovered automatically: stochastic exceedance of local T > M_bond.
• Pressure dependence: External pressure adds an opposing M term. Greater ambient confinement means molecules must accumulate more T before detaching, shifting the boiling point upward exactly as in the Clausius-Clapeyron relation.
• Queue-buffering view: Each bond acts like a queue balancing incoming T impulses. When too many arrive before local reconciliation, the queue overflows—M cannot keep up—so the excess commits as a new free-motion packet (a vapor molecule).

• Inertia as queued synchronization: When a force is applied, the update wave must propagate through the body before all regions share the new frame. During this brief queue-buffering period, part of the causal budget remains in M-mode. The resistance felt while this synchronization completes is the experience of inertia.
• Friction as gradient synchronization: At a boundary between two systems (such as a surface contact), neighboring updates run at slightly different local paces α(x). Their partial misalignment converts a portion of T into M, observed macroscopically as heat and drag. Friction is therefore a spatial gradient in frame-sync, not a separate force.
• Common origin: Both inertia and friction describe how quickly the causal network of updates re-aligns after a change in motion. Perfect synchronization would mean loss-free translation; imperfect sync produces resistance and dissipation.
• Unified view: In the CBF picture, motion, resistance, and heating are all timing behaviors of the same Event Ledger. Energy does not vanish—it shifts between T (coherent translation) and M (local vibration) as the system seeks a stable global frame.

• Emission: At the emitter, part of the atom’s internal M vibration converts to translational T as a photon is released. The photon’s oscillation represents that T+M exchange viewed in the emitter’s frame: the field alternates between stored and propagated energy. Its wavefront begins at that instant with no prior interference memory.
• Absorption: When a photon is absorbed, its propagation cycle ends. The incoming T transfers into the absorber’s M vibration, raising its internal energy state. The wavefront collapses completely, leaving no residual phase information—future emissions start anew.
• In-flight frame synchronization: After launch, the particle’s wavefront remains coupled to the Event Ledger. The Ledger continuously frame-syncs the packet so all wave cells stay in one clock, using the Global Budget Synchronization logic and the local α(x) pacing field to re-vectorize gently across gradients. This prevents the packet from tearing itself apart, preserves coherence where TTL allows, and explains smooth bending in α-gradients for both photons and matter.
• Scattering and reflection: A reflection or scattering event terminates the incoming wavefront and launches a new one from the interaction point. The new direction, frequency, and polarization depend on the local Material Coupling Field, but all prior interference links are erased. Only the new wave’s parameters continue forward.
• Collisions and particle creation: When energetic particles collide, their combined T+M budgets may reorganize into entirely new bound configurations. Each product’s wavefront begins fresh, defined by its own conserved quantities. This process underlies pair creation, secondary emission, and all re-radiation phenomena.
• Physical meaning: A “new particle” in CBF means a new, locally-synchronized wavefront whose phase history starts at the interaction site. Old coherence is gone; new coherence begins. That reset is why reflection destroys interference between incident and reflected light, and why emission events appear spontaneous yet remain fully causal.

• Wave stencil: Each update uses a second-order leapfrog scheme: ψₜ₊₁ = 2ψₜ − ψₜ₋₁ + (cτ/a)² ∇²ψₜ − (ω₀τ)² ψₜ. This reproduces the Klein-Gordon relation ω² = c²k² + ω₀².
• Calibration: Choosing c = a / τ ensures photons propagate exactly one lattice cell per tick, matching the causal budget rule where full T is spent on translation.
• Numerical stability: The Courant limit c τ / a ≤ 1 coincides with the CBF causal limit— no information outruns the Ledger tick.
• Continuous limit: As a, τ → 0 with a/τ = c fixed, the stencil recovers the continuous relativistic wave equation. Thus, smooth physics emerges naturally from discrete causal bookkeeping.

• S-Ledger: Updated only by long-lived atomic collapses. Its entries carry effective TTL-weighted stability η = λ_keep / (λ_keep + λ_fail). This weighting explains lensing offsets such as the Bullet Cluster—hot plasma with short TTL contributes weakly.
• D-Ledger: Updated by all collapses, including transient or failed ones. It stores pruning scars that bias future event selection but exert no direct gravitational mass. These scars act as a dark-matter-like halo guiding future probability flow.
• Interaction rule: Every collapse writes first to the D-Ledger (local pruning) and, if stable, to the S-Ledger (mass and curvature update). Thus pruning precedes commitment, ensuring global coherence.
• Unified conservation: The total causal budget C = T + M is conserved across both ledgers— D handles short-term entropy management, S stores long-term spacetime curvature.

Conceptually, the S-Ledger behaves like an active cache rather than a permanent record. It retains only those atomic configurations that remain relevant to the current worldline, allowing spacetime curvature and α-field pacing to be computed from the “working set” of stable matter. The deeper D-Ledger acts more like long-term storage, preserving pruning scars and causal residues that no longer participate in active events but still bias future collapses. The Event Ledger itself functions as the processor—reconciling updates and committing only what survives into the S-cache.

• Invisible propagation: Between events, particles exist only as causal potentials distributed across the lattice. Photons, electrons, and atoms all traverse as unrendered probability carriers until the Ledger commits a collapse at an interaction site.
• Reality as a commit log: The physical universe is the set of successful collapses—the record of what actually happened. Everything else, the uncommitted branches and failed paths, is bookkeeping inside the D-Ledger’s pruning field.
• Perception as collapse interpretation: Every human sense—sight, sound, touch, taste, smell—depends on collapse events. Photons collapse on retinal molecules, pressure waves collapse in the cochlea, molecular impacts collapse in olfactory and tactile receptors. Conscious awareness is the interpretation layer that reads these collapse chains and reconstructs a continuous narrative.
• Consciousness as observer interface: The brain acts as a causal query engine, drawing meaning from collapse sequences that reach its neural lattice. It does not generate collapses by will, but filters and binds them into coherent worldlines of experience.
• Unified ontology: There are no static objects—only ongoing collapse relationships managed by the Event Ledger. Energy, mass, fields, and awareness all arise from the same act of reconciliation between potential and commitment.