Skip to main content

Chapter 58
de Broglie Wavelength and Momentum Feedback

Quantum Coherence and Boundary Systems
Author: Mark Anthony Higgins
© Mark Anthony Higgins 11 October 2025
Revised Date: 23 February 2026
Audio Overview
Flow Algebra
flow "de Broglie Wavelength and Momentum Feedback" v1.0


# ---------- PURPOSE ----------
# Encodes the de Broglie relation λ = h/p and the feedback that boundaries impose on phase.
# Boundaries (ring/box/slit) enforce phase continuity, quantising k and p via curvature feedback.
# IB measures phase coherence; IB < 1 introduces fringe loss / imperfect quantisation.

# ---------- PARAMETERS ----------
params:
  units: "SI"
  h: real  = 6.62607015e-34       # Planck constant [J·s]
  ħ: real  = 1.054571817e-34      # reduced Planck [J·s]
  m: positive                      # particle mass [kg]
  v: real?                         # particle speed [m/s] (nonrelativistic regime)
  p: real?                         # momentum [kg·m/s] (if not given, p = m v)
  E: real?                         # total energy [J] (if not given, E = p^2/2m)
  L: positive?                     # characteristic length (ring circumference or box length) [m]
  boundary: enum("free","ring","box","slit") = "free"
  n: integer?                      # mode index for quantisation (n = 0,±1,±2,… for ring; n = 1,2,… for box)
  IB: 0.0..1.0 = 1.0               # coherence index (fringe/phase integrity)
  aperture: positive?              # slit width for diffraction [m]
  dt: positive?                    # timestep [s]
  λ_leak: nonnegative = 0.0        # coherence leak rate [s^-1]

# ---------- STATE ----------
state Wave:
  λ: real                          # de Broglie wavelength [m]
  k: real                          # wave-number [1/m]
  ω: real                          # angular frequency [rad/s]
  vp: real                         # phase velocity [m/s]
  vg: real                         # group velocity [m/s]
  quant_error: real                # mismatch to boundary condition
  phase_integral: real             # ∮ p·dl (Bohr–Sommerfeld) [J·s]
  allowed_k: real?                 # nearest quantised k
  fringe_visibility: real          # interference contrast ~ IB
  regime: str                      # "free","quantised","diffracting","decohering"

# ---------- INVARIANTS ----------
invariants:

  # Momentum / energy closure (nonrelativistic by default)
  if params.p is undefined and params.v is defined:
    params.p = params.m * params.v
  if params.E is undefined and params.p is defined:
    params.E = params.p^2 / (2*params.m)

  # de Broglie relations
  Wave.λ = params.h / (params.p or 1e-99)
  Wave.k = 2π / Wave.λ                 # also k = p/ħ
  Wave.ω = (params.E or 0) / params.ħ  # E = ħω

  # Velocities (nonrelativistic)
  Wave.vg = params.p / params.m                    # group velocity
  Wave.vp = (params.E or 0) / (params.p or 1e-99)  # phase velocity

  # Boundary feedback → quantisation (choose rule by boundary)
  if params.boundary == "ring" and params.L is defined:
    # periodicity: k_n = 2π n / L
    Wave.allowed_k = 2π * (params.n or round(Wave.k * params.L / (2π))) / params.L
    Wave.quant_error = abs(Wave.k - Wave.allowed_k)
    Wave.phase_integral = (params.p or 0) * (params.L)          # ≈ n h target
  elif params.boundary == "box" and params.L is defined:
    # hard walls: k_n = nπ / L, λ_n = 2L/n
    Wave.allowed_k = (π * (params.n or round(Wave.k * params.L / π))) / params.L
    Wave.quant_error = abs(Wave.k - Wave.allowed_k)
    Wave.phase_integral = 2 * (params.p or 0) * (params.L)      # round-trip action ~ n h
  elif params.boundary == "slit" and params.aperture is defined:
    # diffraction scale (first minimum): sin θ ≈ λ/aperture
    Wave.quant_error = 0
    Wave.phase_integral = 0
  else:
    Wave.quant_error = 0
    Wave.phase_integral = 0

  # Coherence → visibility
  Wave.fringe_visibility = params.IB

  # Coherence decay (optional)
  if params.λ_leak > 0 and params.dt is defined:
    params.IB = clamp(params.IB - params.λ_leak * (1 - params.IB) * params.dt, 0, 1)
    Wave.fringe_visibility = params.IB

  # Regime tag
  if params.boundary in ["ring","box"] and params.L is defined:
    Wave.regime = "quantised"
  elif params.boundary == "slit" and params.aperture is defined:
    Wave.regime = "diffracting"
  elif params.IB < 1:
    Wave.regime = "decohering"
  else:
    Wave.regime = "free"

# ---------- TRANSFORMS ----------
transforms:

  set_velocity:
    comment: "Update p via p = m v (nonrelativistic)."
    params.v += Δv
    params.p  = params.m * params.v
    # refresh λ,k via invariants

  enforce_boundary_feedback:
    comment: "Snap k to nearest allowed mode to satisfy phase continuity."
    if Wave.allowed_k is defined:
      Wave.k = Wave.allowed_k
      params.p = params.ħ * Wave.k
      Wave.λ = 2π / Wave.k
      params.E = params.p^2 / (2*params.m)
      Wave.quant_error = 0

  open_slit:
    comment: "Switch to diffracting regime with a given aperture."
    params.boundary = "slit"
    params.aperture = new_aperture

  decay_coherence:
    comment: "Reduce IB (fringe visibility) via leakage."
    params.IB = clamp(params.IB - 0.01 * (1 - params.IB), 0, 1)
    Wave.fringe_visibility = params.IB

  restore_coherence:
    comment: "Small feedback restoration of coherence."
    params.IB = clamp(params.IB + 0.01 * (1 - params.IB), 0, 1)
    Wave.fringe_visibility = params.IB

# ---------- MONITORS ----------
monitors:
  de_broglie_consistency:
    assert abs(Wave.k - (params.p or 0)/params.ħ) <= 1e-9 or params.p is undefined
    comment: "k = p/ħ and λ = h/p consistent."

  boundary_condition:
    if params.boundary in ["ring","box"] and params.L is defined:
      assert Wave.quant_error <= 1e-9
      comment: "Phase continuity satisfied (quantised mode)."

  coherence_bounds:
    assert 0 <= params.IB <= 1

# ---------- SCENES ----------
scenes:

  free_particle:
    given params:
      m: 9.11e-31
      v: 1.0e5
      boundary: "free"
      IB: 1.0
    expect:
      Wave.regime = "free"
      comment: "Unbounded motion — λ = h/p sets phase scale; no quantisation."

  ring_quantisation:
    given params:
      m: 9.11e-31
      v: 2.0e5
      L: 1.0e-6
      boundary: "ring"
      IB: 1.0
    enable:
      - enforce_boundary_feedback
    expect:
      Wave.regime = "quantised"
      Wave.quant_error = 0
      comment: "Periodic boundary enforces k_n = 2π n / L → p_n = ħ k_n."

  box_modes:
    given params:
      m: 9.11e-31
      v: 1.0e5
      L: 5.0e-9
      boundary: "box"
      n: 3
      IB: 1.0
    enable:
      - enforce_boundary_feedback
    expect:
      Wave.regime = "quantised"
      comment: "Hard-wall box: k_n = nπ/L, λ_n = 2L/n; momentum locked to mode."

  single_slit_diffraction:
    given params:
      m: 9.11e-31
      v: 5.0e4
      boundary: "slit"
      aperture: 100e-9
      IB: 0.9
    expect:
      Wave.regime = "diffracting"
      Wave.fringe_visibility ≈ 0.9
      comment: "Angular spread set by λ/aperture; IB controls fringe contrast."

  decohering_beam:
    given params:
      m: 9.11e-31
      v: 8.0e4
      boundary: "free"
      IB: 0.7
      λ_leak: 0.02
      dt: 1.0
    enable:
      - decay_coherence
    expect:
      Wave.regime = "decohering"
      Wave.fringe_visibility ↓
      comment: "Environmental coupling reduces IB — momentum spread broadens."

# ---------- NOTES ----------
notes:
  - **de Broglie:**  
    \[
    \lambda = \frac{h}{p},\qquad k = \frac{2\pi}{\lambda} = \frac{p}{\hbar},\qquad
    E = \frac{p^2}{2m},\quad \omega = \frac{E}{\hbar}.
    \]
  - **Velocities (nonrelativistic):**  
    \[
    v_g = \frac{d\omega}{dk} = \frac{p}{m},\qquad
    v_p = \frac{\omega}{k} = \frac{E}{p} = \frac{p}{2m}.
    \]
  - **Boundary Quantisation:**  
    Ring: \(k_n = 2\pi n/L\) (periodic).  
    Box: \(k_n = n\pi/L,\ \lambda_n = 2L/n\) (nodes at walls).  
    Bohr–Sommerfeld (heuristic): \(\oint p\,dl = n h\).
  - **Diffraction Scale:** First minimum \(\sin\theta \approx \lambda / a\) for slit width \(a\).
  - **Coherence Law:**  
    \[
    \dot{I_B} = -\lambda_{\text{leak}}(1 - I_B)
    \]
    controls fringe visibility / mode purity.
  - **Interpretation (HST–Flow):** Boundaries act as **phase feedback loops**: they accept only those \(k\) that close the loop coherently.  
    High \(I_B\) → sharp modes / fringes; low \(I_B\) → broadened momentum distribution and washed patterns.
Overview

When matter moves, it does not carry a wave; it is the wave — a self-referential curvature loop whose wavelength arises from the feedback between motion and phase continuity.
The de Broglie relation,

\[ \lambda = \frac{h}{p} \]

is therefore not a conversion between momentum and wavelength, but a boundary feedback law: the geometry that phase must adopt for coherence to remain closed through motion.

Every boundary — whether a ring, box, or slit — enforces this closure by allowing only those curvatures whose phases fit seamlessly upon returning.
Momentum becomes quantised because the boundary demands self-agreement of phase.


🔹 1. Classical Form — Matter Waves and Quantisation

Classically, a particle of momentum p=mvp = m v is associated with a wavelength

\[ \lambda = p\,h \]

When this wave is confined by a boundary of length LL, coherence can survive only if an integer number of wavelengths fits within that boundary:

\[ n\lambda = 2L \;(\text{box}), \qquad n\lambda = L \;(\text{ring}) \]

Hence,

\[ p_n = n\frac{h}{2L} \quad \text{or} \quad \frac{n h}{L} \]

Quantisation arises not from discrete energy “packets” but from the phase-closure requirement imposed by the geometry that contains the wave.


🔸 2. Coherence Interpretation — Feedback Loops of Motion

In the HST framework, the de Broglie wavelength measures the curvature feedback length — the spatial period required for a particle’s internal phase to re-align with its boundary conditions.
Each full loop of curvature corresponds to one phase rotation of 2π2\pi.
The feedback condition,

\[ \oint p\,dl = n h \]

ensures that curvature memory remains coherent over the full loop.
A change in momentum changes the loop’s curvature and therefore its wavelength — a reciprocal relationship ensuring that the total phase across one cycle remains 2πn2\pi n.

The boundary thus acts as a coherence mirror: momentum determines wavelength, wavelength determines how phase closes, and closure defines which momenta are permitted.


🔹 3. Momentum Feedback — Boundary as Phase Controller

A wave traversing a ring or box continually reflects or wraps around, comparing its current phase with its origin.
Any mismatch produces interference — constructive for closed phases, destructive for non-integer multiples.
The only stable solutions are those where curvature realigns perfectly, satisfying

\[ k_n = \frac{2\pi n}{L}\;(\text{ring}), \qquad k_n = \frac{n\pi}{L}\;(\text{box}) \]

These discrete knk_n values represent standing curvature patterns — phase-locked feedback loops.
Momentum quantisation is therefore boundary-enforced coherence: each allowed state is a mode of stable recursion.


🔸 4. Diffraction and Coherence Loss

When a wave passes through an open boundary (slit or aperture), feedback becomes partial.
The boundary no longer enforces strict phase closure, so curvature spills outward, producing a diffraction pattern.
The angular spread obeys:

\[ \sin\theta \approx \frac{\lambda}{a} \]

where aa is the slit width.
Here, the coherence index IBI_B quantifies how well phase remains aligned:

  • IB=1I_B = 1: sharp fringes, full coherence.
  • IB<1I_B < 1: blurred fringes, partial coherence.
  • IB→0I_B \to 0: diffuse pattern, coherence memory lost.

As IBI_B falls, the momentum distribution broadens — a signature of open-boundary feedback.


🔹 5. Dynamic Coherence Law — Phase Integrity Through Motion

The persistence of wave coherence follows the same universal law:

\[ \dot{I_B} = -\lambda_{\text{leak}} (1 - I_B) \]

Boundaries with high reflectivity (λleak≈0\lambda_{\text{leak}} \approx 0) maintain standing waves indefinitely;
open apertures (λleak>0\lambda_{\text{leak}} > 0) allow phase information to leak away.
The de Broglie wave therefore evolves according to the degree of feedback closure imposed by its environment.


🔸 6. Unified Coherence Framework — Phase Quantisation as Boundary Memory

From the HST–Flow perspective, the de Broglie relation is the local expression of global coherence.
Momentum and wavelength are not separate variables but conjugate manifestations of curvature feedback.

  • The wave’s phase records how motion wraps upon itself.
  • The boundary checks that record for self-consistency.
  • Quantisation emerges when curvature perfectly re-enters its own loop.
  • Decoherence arises when feedback fails to fully return.

Every quantised state is therefore a stable recursion of curvature memory, sustained by the dialogue between motion and boundary.


🧠 Summary

The de Broglie wavelength describes how motion encodes coherence through curvature.
Momentum defines curvature density; boundaries feed that curvature back upon itself.
Quantisation is the condition of perfect feedback; diffraction is the partial opening of the loop.

In the HST–Flow view:

  • λ = h/p → curvature feedback rule.
  • Quantisation → boundary-enforced phase closure.
  • Diffraction → open feedback and coherence leakage.
  • I_B → memory of boundary integrity.

Thus, every particle is not a point but a loop of recursive motion,
and every wavelength is the distance over which that loop remembers itself.

Motion becomes geometry when its phase returns to meet itself.


Kireth Research
38 Thorndale Croft, Wetwang, Driffield
East Riding of Yorkshire YO25 9XZ
Designed By