Re-Entry Dynamics as a Switching Process: Comparing Hamiltonian Re-Entry Computation to von Neumann Switching Costs

#1. Introduction

Every computing architecture pays a price for moving state from where it is stored to where it is transformed. In a von Neumann architecture this price appears as the fetch-decode-execute cycle: before any arithmetic happens, the machine must switch its control and data paths to bring an instruction into the processing unit. John Backus argued that this coupling runs deeper than hardware, coining the "von Neumann vicious circle": programming languages are high-level abstract isomorphic copies of the von Neumann machine, so non-von Neumann architectures cannot gain traction without non-von Neumann languages, and vice versa [11]. Any proposal for a fundamentally different computational substrate must therefore be evaluated not only for physical plausibility but for its switching economics.

This paper performs such an evaluation for the computational model proposed in the QNFO framework "Hamiltonian Dynamics as the Engine of Biological Computation" (DOI 10.5281/zenodo.18195888) [12]. The supplied record for [12] gives only the title and identifier and no further summary detail; our reading of the proposal is therefore restricted to what the title asserts, namely that Hamiltonian dynamics — the autonomous, energy-conserving motion of a physical system — can serve as the engine of computation, in the way biological systems appear to compute. We take the central mechanistic idea suggested by the title to be re-entry: a Hamiltonian trajectory that returns to a previously visited region of phase space, closing a loop, so that one act of dynamical setup is reused many times without an external controller re-issuing it.

The comparison target is the switching cost of the von Neumann regime. We build both regimes as minimal per-operation cost models over a common currency, derive their relative cost with fully shown arithmetic, and probe the sensitivity of the result. The contributions are:

1. A two-model cost formalism: an explicit-controller model with per-operation switching cost $c_{\mathrm{sw}}$, and an autonomous re-entry model with per-operation cost $c_{\mathrm{re}}$, with all parameters stated as assumptions.
2. Exact arithmetic derivations of the per-operation costs, their ratio, the break-even memory time, the robustness threshold in re-entry overhead, and the overhead-fraction crossover.
3. A literature synthesis placing the comparison inside the Hamiltonian-statistical-mechanics tradition [1], [2], [5], [6], [7], [8], the dynamical-systems hardness literature [4], the embedding literature for quantum algorithms [3], and the architecture literature [9], [10], [11].
4. An explicit statement of what would falsify the claimed advantage.

We emphasize at the outset that no empirical measurements are reported here. Every number in Sections 4 and 5 is either derived by shown arithmetic from parameters declared in Section 3 as illustrative assumptions, or is a projection whose assumptions and uncertainty are stated inline. The value of the exercise is structural: it converts a qualitative architecture debate into a small set of named parameters whose empirical measurement would settle the question.

#2. Background and Related Work

Entropy from Hamiltonian dynamics. Reference [1] develops the physical basis of the Gibbs-von Neumann entropy, arguing that it is the appropriate statistical-mechanical generalization of thermodynamic entropy for macroscopic and microscopic systems, whether in thermal equilibrium or not, as a consequence of Hamiltonian dynamics; the supplied abstract is truncated mid-sentence after "incorporates a variety of", so we rely only on the claims stated up to that point. This matters for our comparison because it supplies the thermodynamic footing for attributing a physical cost to dynamical computation: if the Gibbs-von Neumann entropy is grounded in Hamiltonian dynamics itself, then a re-entry computation performed by Hamiltonian motion is a process whose entropy bookkeeping is of the standard kind, including away from equilibrium.

Quantum mechanics as a projection of classical statistics. Reference [2] shows that quantum mechanics can be represented as a natural projection of a classical statistical model on a phase space $\Omega = H \times H$, where $H$ is a real Hilbert space, with statistical states given by Gaussian measures of very small dispersion $\alpha$, interpreted as fluctuations; Schrödinger's, Heisenberg's and von Neumann's equations are derived in this picture (the supplied abstract is truncated after introducing the fluctuation interpretation). For our purposes this is a precedent for deriving quantum-looking computational behavior from an underlying classical dynamical substrate: the direction of derivation in [2] runs from classical statistical dynamics up to the von Neumann equation, which is the same direction a "dynamics as engine" account of computation requires.

Embedding classical dynamics for quantum algorithms. Reference [3] studies how to map linear differential equations to Schrödinger equations via Carleman and Koopman-von Neumann embeddings for quantum algorithms, noting that solving differential equations with large degrees of freedom is an important scientific and industrial task and that embedding classical variables into a quantum state is necessary to solve such equations on a quantum computer; the entry states that the class of problems that can be treated has been limited so far (the sentence is truncated). This is the constructive counterpart of our cost question: embeddings make dynamical computation executable on quantum hardware, and the switching-cost comparison of this paper quantifies what such embeddings would save or spend.

Hardness of assessing mixing. Reference [4] considers interacting qubit systems with dynamics according to 4-local Hamiltonians and continuous quantum random walks, and states that for these systems one could use the von Neumann entropy of the time-average to characterize mixing properties; the title asserts that estimating these mixing properties is PSPACE-hard. This is a central caveat for re-entry computation: whether a Hamiltonian trajectory actually re-enters a useful region — whether the dynamics mixes well enough to revisit computationally relevant states — is in general exponentially hard to decide. Our cost model assumes re-entry occurs with a given mean time; [4] tells us that verifying this assumption for a specific large Hamiltonian system is computationally intractable in general.

Nonequilibrium statistical operators. References [5] and [6] address the same foundational gap from the Zubarev tradition. Entry [5] states that the statistical mechanics of nonequilibrium processes is not rigorously solved, that D. N. Zubarev invented the nonequilibrium statistical operator (NSO) method to describe irreversible behavior starting from reversible Hamiltonian dynamics, and that the paper discusses this approach in the context of the electrical conductivity of charged particle systems, in particular the extended variant (the entry truncates there). Entry [6] makes the same framing — approaches to nonequilibrium statistical mechanics rest on empirical assumptions while a rigorous first-principles theory is missing — and credits the NSO as an important contribution to describing irreversible behavior from reversible dynamics. Re-entry computation lives exactly in this gap: it is an irreversible, dissipative-looking computational pattern realized by reversible Hamiltonian motion, so the NSO line of work is the natural statistical-mechanical language in which a rigorous cost accounting of re-entry would eventually have to be written.

Geometry and time-energy cost of dynamics. Reference [7] establishes relations between Hamiltonian dynamics and Riemannian structures on phase spaces for unitarily evolving finite-level quantum systems in mixed states, showing that the energy dispersion — defined as $1/\hbar$ times the path integral of the energy uncertainty — of a unitary evolution is bounded from below by the length of the evolution curve (the supplied text is truncated beyond this point). This gives our cost model a physical lower-bound principle: a re-entry loop of a given geometric length in state space cannot be traversed without at least a corresponding integrated energy uncertainty. Any claim that re-entry is "cheap" must respect this bound; we use it qualitatively in Section 6.

Hybrid and generalized dynamics. Reference [8] describes a path-integral formulation of classical Hamiltonian dynamics and, building on it, a new attempt at hybrid dynamics coupling classical and quantum degrees of freedom directly, noting that no fully satisfactory solution of the hybrid problem has been established to date (the entry is truncated after "Related aspects"; we use only the stated claims). Hybrid dynamics is relevant because a re-entry computer would inevitably couple an autonomous Hamiltonian core to a classical readout and control layer, and [8] indicates that this coupling is an open foundational problem, not a solved engineering detail.

Beyond von Neumann: neuromorphic and switching hardware. Reference [9] is a bibliometric review of neuromorphic computing and spiking neural networks, stating that these fields aim to leverage biological inspiration to achieve greater energy efficiency and computational power beyond traditional von Neumann architectured machines, that spiking neural networks hold potential as the basis of third-generation neural networks, and that developments in memristive and compute-in-memory technologies aid this program (entry truncated). This locates the re-entry proposal inside an existing research current that already measures itself against von Neumann energy costs. Reference [10] concerns the hardware switching layer directly: it notes that input scheduling based on Birkhoff-von-Neumann (BvN) decomposition achieves high throughput and low complexity, but that the BvN switch becomes less predictable under bursty input traffic, and proposes a deflection-compensated BvN (D-BvN) switch architecture to enhance quasi-static scheduling based on BvN decomposition (entry truncated). Although the "von Neumann" in [10] is a decomposition in switching theory rather than the stored-program architecture, the shared theme is that switching fabric costs are the bottleneck resource; we borrow its spirit in treating a switching event as the atomic unit of cost.

The architecture trap. Finally, [11] analyzes the "von Neumann vicious circle" coined by John Backus: non-von Neumann architectures cannot be developed because of the lack of widely available effective non-von Neumann languages, and new languages cannot be created for lack of conceptual foundations for non-von Neumann architectures, the reason being that programming languages are high-level abstract isomorphic copies of von Neumann computers. This is the socio-technical reason a re-entry architecture needs an explicit cost comparison stated in architecture-neutral terms, as we attempt here.

The QNFO corpus. The supplied record for [12], "Hamiltonian Dynamics as the Engine of Biological Computation" (DOI 10.5281/zenodo.18195888), contains only the title and identifier; the summary field is empty, so no internal claims, methods, or numbers of that work can be quoted here. The same holds for [13], "Comprehensive Technical Framework for Network Isomorphism" (DOI 10.5281/zenodo.18199940). We treat [12] as the proposal under evaluation — its title licenses the reading that Hamiltonian dynamics performs computation — and note that [13], by title, concerns isomorphism testing between networks, which would be the natural tool for checking whether two re-entry loop structures implement the same computation; beyond that title-level remark we make no claim about its content.

#3. Methods

#3.1 The two cost models

Von Neumann switching model. Consider a stored-program machine executing a program of $N_{\mathrm{op}}$ logical operations. Each operation requires $k_{\mathrm{acc}}$ memory accesses (instruction fetch plus data load/store) before the logical work is done. Let $t_{\mathrm{mem}}$ be the effective time per memory access and $t_{\mathrm{alu}}$ the time for the logical work itself. The per-operation cost is

and the total cost is

We call $k_{\mathrm{acc}}\, t_{\mathrm{mem}}$ the switching overhead per operation and define the overhead fraction

Hamiltonian re-entry model. In the re-entry model, the machine state is a point $x_t$ in phase space evolving under a Hamiltonian $H$. A computation of $N_{\mathrm{op}}$ logical steps corresponds to $N_{\mathrm{op}}$ re-entries of the trajectory into a designated operating region $\mathcal{R} \subset \Omega$. Let $t_{\mathrm{dyn}}$ be the mean time for the trajectory to traverse one useful dynamical segment (the analogue of $t_{\mathrm{alu}}$), and let $t_{\mathrm{re}}$ be the mean re-entry overhead: the extra time spent steering the trajectory back into $\mathcal{R}$ after each useful segment, including any classical control intervention of the hybrid kind discussed in [8]. The per-re-entry cost is

and the total is

The geometric lower bound of [7] — energy dispersion bounded below by curve length — enters as a constraint that $t_{\mathrm{re}}$ cannot be driven to zero without paying in energy spread; we encode this by treating $t_{\mathrm{re}}$ as a positive parameter rather than a free optimization target.

#3.2 Comparison criterion

The re-entry model beats the switching model on total time when $T_{\mathrm{re}} \lt T_{\mathrm{sw}}$, i.e. when

#3.3 Assumptions

(A1) Both machines perform the same $N_{\mathrm{op}}$ logical operations; the models differ only in update overhead. (A2) Memory accesses are serialized; no caching removes them. (A3) The re-entry overhead $t_{\mathrm{re}}$ is a fixed parameter, not derived from a nonequilibrium statistical operator; deriving it from first principles along the lines of [5], [6] is left open. (A4) Mixing is adequate that the mean re-entry time exists; computing it would require solving a mixing problem of the kind shown to be PSPACE-hard in [4], so we do not attempt it.

#4. Analysis

Every number in this section is derived from the stated inputs. Inputs are of two kinds: structural integers of the model ($k_{\mathrm{acc}}$) and illustrative parameter values that we state explicitly as assumptions (all times). No value is taken from measurement or from the cited literature.

Input 1 (structural). $k_{\mathrm{acc}} = 4$ memory accesses per operation: one instruction fetch, one operand load, one store, one next-instruction prefetch. Source: model definition in Section 3.1.

Input 2 (assumed, labeled). $t_{\mathrm{alu}} = 1$ time unit (normalization). $t_{\mathrm{mem}} = 16$ time units per access — chosen to represent a memory hierarchy much slower than the arithmetic unit, a regime in which switching overhead is the dominant concern; this is an assumption of the illustrative scenario, not a measurement. $t_{\mathrm{dyn}} = 4$ time units per useful dynamical segment — assumed. $t_{\mathrm{re}} = 1$ time unit per re-entry — assumed, representing modest steering overhead consistent with the geometric constraint of [7] that re-entry cost is bounded below but not zero.

Derivation 1: switching cost per operation.

Derivation 2: switching overhead fraction.

Under the assumed parameters, $100 \times f_{\mathrm{sw}} = 98.4615\ldots\%$ of the stored-program machine's time is switching overhead.

Derivation 3: re-entry cost per operation.

Derivation 4: re-entry overhead fraction.

Derivation 5: total-time comparison for $N_{\mathrm{op}} = 10^{6}$ operations.

The ratio is

Derivation 6: the break-even condition. The re-entry model wins when $c_{\mathrm{re}} \lt c_{\mathrm{sw}}$, i.e.

Solve for the memory time $t_{\mathrm{mem}}$ at equality, holding the other assumed values fixed:

So under these assumptions the re-entry model wins whenever $t_{\mathrm{mem}} \gt 1$ time unit, i.e. whenever memory is slower than the arithmetic unit at all — a very weak condition, which reflects that the assumed $t_{\mathrm{re}} = 1$ is small relative to $t_{\mathrm{dyn}} = 4$.

Derivation 7: sensitivity of the verdict to $t_{\mathrm{re}}$. The comparison flips when the re-entry overhead grows. Setting $c_{\mathrm{re}} = c_{\mathrm{sw}} = 65$ and solving for $t_{\mathrm{re}}$:

Thus the re-entry model tolerates a re-entry overhead up to $61$ time units — $61/4 = 15.25$ times the useful segment time $t_{\mathrm{dyn}} = 4$ — before losing to the switching model at the assumed $t_{\mathrm{mem}} = 16$.

Derivation 8: overhead-fraction crossover in $r = t_{\mathrm{mem}}/t_{\mathrm{alu}}$. With $t_{\mathrm{alu}} = 1$, $t_{\mathrm{dyn}} = 4$, $t_{\mathrm{re}} = 1$, and $t_{\mathrm{mem}} = r$, the switching overhead fraction is

At $r = 4$: $f_{\mathrm{sw}} = 16/17 \approx 0.9412$. At $r = 16$: $f_{\mathrm{sw}} = 64/65 = 0.984615\ldots$ (matching Derivation 2). At $r = 1$: $f_{\mathrm{sw}} = 4/5 = 0.8$. The re-entry overhead fraction is constant at $f_{\mathrm{re}} = 0.2$. The fractions are equal when $4r/(4r+1) = 1/5$, i.e. $20r = 4r + 1$, so $16r = 1$ and

for every $r \gt 0.0625$ the switching machine wastes a larger fraction of its time on overhead than the re-entry machine does under these assumptions.

Derivation 9: entropy bookkeeping quantity. If the re-entry overhead is booked as an entropy production cost, and following [1] we use the Gibbs-von Neumann entropy as the state functional, a dimensionless bookkeeping quantity is the ratio of overhead-plus-useful to useful evolution in log form:

This is a model quantity, not a thermodynamic entropy measurement; its physical interpretation is deferred to Section 6.

Derivation 10 (alternative parameterization, cost-unit currency). As a robustness check under a different convention, one may price switching in abstract cost units (cu), one per elementary act of redirecting state, in the spirit of BvN scheduling [10]. With fetch $c_f = 1.0$, decode $c_d = 0.5$, execute $c_e = 1.0$:

With a re-entry loop of $L = 4$ nodes and per-pass cost $c_p = 0.2\ \mathrm{cu}$:

Amortizing a setup cost $C_s = 10\ \mathrm{cu}$ over $n$ cycles, $C_{\mathrm{re}}(n) = 10/n + 0.8$; break-even solves $10/n + 0.8 = 2.5$, giving $10/n = 1.7$ and $n^{*} = 10/1.7 \approx 5.882$, i.e. at least $6$ whole cycles of reuse. The advantage vanishes when $L\,c_p^{*} = C_{\mathrm{vN}}$, i.e. $c_p^{*} = 2.5/4 = 0.625\ \mathrm{cu}$, or equivalently at loop length $L^{*} = 2.5/0.2 = 12.5$ nodes for $c_p = 0.2$. These numbers follow a different cost convention than Derivations 1-9 and are reported separately.

#5. Results

All results below are projections of the cost model of Section 3 under the assumptions of Section 4; none are empirical measurements.

• R1 (per-operation costs). Under the assumed parameters ($k_{\mathrm{acc}} = 4$, $t_{\mathrm{mem}} = 16$, $t_{\mathrm{alu}} = 1$, $t_{\mathrm{dyn}} = 4$, $t_{\mathrm{re}} = 1$): $c_{\mathrm{sw}} = 65$ time units, $c_{\mathrm{re}} = 5$ time units (Derivations 1, 3).
• R2 (overhead fractions). $f_{\mathrm{sw}} = 64/65 = 0.984615\ldots$; $f_{\mathrm{re}} = 0.2000$ (Derivations 2, 4).
• R3 (total-time ratio). For $N_{\mathrm{op}} = 10^{6}$: $T_{\mathrm{sw}} = 6.5 \times 10^{7}$, $T_{\mathrm{re}} = 5.0 \times 10^{6}$, ratio $13.0$ (Derivation 5).
• R4 (break-even). The re-entry model wins whenever $t_{\mathrm{mem}} \gt t_{\mathrm{mem}}^{*} = 1$ time unit, under the fixed assumptions (Derivation 6).
• R5 (robustness to re-entry overhead). The verdict is unchanged for any $t_{\mathrm{re}} \lt t_{\mathrm{re}}^{*} = 61$ time units, i.e. up to $15.25$ times the useful segment time (Derivation 7).
• R6 (fraction crossover). The switching machine's overhead fraction exceeds the re-entry machine's for all $r \gt 1/16 = 0.0625$; at $r = 16$ the fractions are $64/65 = 0.984615\ldots$ versus $0.2000$ (Derivation 8).
• R7 (bookkeeping ratio). $\eta = \ln(5/4) \approx 0.2231$ (Derivation 9), a dimensionless model quantity.
• R8 (alternative parameterization). Under the cost-unit convention of Derivation 10: $C_{\mathrm{vN}} = 2.5\ \mathrm{cu}$, $C_{\mathrm{re}} = 0.8\ \mathrm{cu}$, ratio $R = 3.125$; break-even reuse $n^{*} \approx 5.88$ cycles; advantage thresholds $c_p^{*} = 0.625\ \mathrm{cu}$ and $L^{*} = 12.5$ nodes.

The qualitative reading, convergent across both parameterizations: in a memory-bound regime, the stored-program organization spends nearly all of its time switching, and the re-entry organization wins by a large modeled margin and tolerates a wide range of re-entry overheads before the verdict reverses. The strength of this conclusion is entirely conditional on the assumed parameters, as Section 6 makes explicit.

#6. Discussion

What the comparison does and does not show. The models compare switching effort per logical operation, not total system cost, accuracy, programmability, or verification cost. The ratio $13.0$ is a property of the assumed parameters, not of the architectures; its role is to isolate the parameters — $t_{\mathrm{mem}}$, $t_{\mathrm{re}}$, and in the alternative convention $c_p$ and $L$ — on which the re-entry proposal's economic case turns.

Limitations. First, (A2) — serialized, uncached memory — is the most favorable case for the switching machine's critic to attack in reverse: real hierarchies cache instructions and data, reducing effective $k_{\mathrm{acc}}\, t_{\mathrm{mem}}$ dramatically for regular workloads. If effective memory time drops to $t_{\mathrm{mem}}^{\mathrm{eff}} = 1$ time unit, then $c_{\mathrm{sw}} = 4 \times 1 + 1 = 5 = c_{\mathrm{re}}$, and the models tie exactly; any further caching improvement makes the switching model win. The headline ratio of $13.0$ therefore holds only in the memory-bound regime and is not a general claim. Similarly, real fetch-decode-execute pipelines amortize fetch across superscalar issue, so effective $c_{\mathrm{sw}}$ per operation can fall below the modeled value.

Second, (A3) is the deepest limitation: we assumed $t_{\mathrm{re}}$ rather than deriving it. The nonequilibrium statistical operator program [5], [6] exists precisely because irreversible behavior from reversible Hamiltonian dynamics lacks a rigorous first-principles treatment; a derived $t_{\mathrm{re}}$ might be far larger than the assumed $1$ time unit, since steering a trajectory back into $\mathcal{R}$ may require control actions whose cost scales badly. The robustness result R5 ($t_{\mathrm{re}}$ may reach $61$ time units) is generous, but it is a projection within the model, not evidence about real Hamiltonian devices.

Third, (A4) hides the hardest computational problem. Whether the trajectory re-enters $\mathcal{R}$ at all, and how often, is a mixing question; [4] reports that estimating mixing properties for 4-local Hamiltonian dynamics and continuous quantum random walks is PSPACE-hard, and proposes the von Neumann entropy of the time-average as a mixing characterization. Our model assumes the benign case. If the system is not mixing on relevant timescales, $t_{\mathrm{re}}$ may be unbounded, and the setup cost of the loop may include an intractable verification step that our model does not price.

Fourth, the per-pass dynamical cost is not free physics: by the bound of [7], traversing a loop of nonzero geometric length requires a path integral of energy uncertainty at least proportional to that length, so $t_{\mathrm{re}}$ and the per-pass cost have a dynamical floor that our illustrative values may violate for long loops; this is precisely the regime (loop length near $L^{*} = 12.5$ in the alternative convention) where the advantage collapses.

Fifth, readout and error correction are unpriced in the re-entry model; a hybrid classical-quantum coupling of the kind discussed in [8] — for which no fully satisfactory solution has been established — would add controller-like costs back into the re-entry regime, eroding the distinction the comparison rests on. The entropy bookkeeping quantity $\eta \approx 0.2231$ of Derivation 9 is a dimensionless model construct; connecting it to a genuine Gibbs-von Neumann entropy production via the framework of [1] remains open.

Sixth, the source proposal itself supplies no data: the record for [12] has an empty summary field, so no parameter can be anchored to it, and the entire quantitative content of this paper rests on declared assumptions.

Failure modes. If re-entry loops must be re-initialized every few cycles (small effective reuse), the amortization result R8 flips the sign of the comparison: below $n \approx 5.88$ cycles of reuse, the explicit controller wins in the cost-unit convention. If the per-pass cost scales with system size (e.g. $c_p \propto L$ rather than constant), then $C_{\mathrm{re}} \propto L^{2}$ and the advantage disappears for any nontrivial loop.

What would falsify the claims. The central claim — that re-entry can undercut von Neumann switching cost — is falsified empirically if measured per-pass switching costs in any concrete Hamiltonian substrate exceed the corresponding thresholds ($c_p^{*} = 0.625\ \mathrm{cu}$ in the cost-unit convention, or effective $t_{\mathrm{mem}} \leq 1$ time unit under caching in the time convention), or if practical reuse factors stay below $n^{*} \approx 5.88$. It is falsified theoretically if the geometric energy bound of [7] forces the per-pass cost to grow linearly with loop length in a way that violates the threshold for all useful loop lengths.

Open questions. (i) What is the true dynamical floor of $t_{\mathrm{re}}$ for a given Hamiltonian loop, and can the NSO formalism of [5], [6] — which treats irreversibility emerging from reversible Hamiltonian dynamics — supply a first-principles value? (ii) Can Koopman-von Neumann embeddings [3] turn re-entry loops into executable quantum circuits, and does the embedding preserve the cost advantage? (iii) Can the projection framework of [2], which derives the von Neumann equation from classical statistical dynamics, be used to define the re-entry cost intrinsically, without a classical control layer? (iv) How would the vicious-circle dynamics described in [11] interact with a cost advantage of the size modeled here — is $13.0$ in the memory-bound regime large enough to break the language-architecture lock-in, or does lock-in dominate economics?

#7. Conclusion

We have built a minimal, fully parameterized comparison between von Neumann switching costs and the re-entry costs of a Hamiltonian-computation paradigm motivated by the QNFO proposal [12]. Under explicitly stated memory-bound assumptions, the stored-program organization spends $100 \times 64/65 = 98.4615\ldots\%$ of its per-operation time on switching overhead and runs a modeled factor of $13.0$ slower than the re-entry organization, which tolerates re-entry overheads up to $15.25$ times its useful segment time before losing. Under an alternative cost-unit parameterization the advantage is smaller ($R = 3.125$) but requires only about $6$ cycles of loop reuse to break even. Both parameterizations agree qualitatively: the case for re-entry computation is an economic case about a small number of measurable parameters, not a conceptual impossibility. The comparison is bounded by the PSPACE-hardness of verifying the mixing behavior it assumes [4], by the geometric energy floor of [7], and by the unsolved hybrid-coupling problem of [8]; rigorous validation requires measuring the per-pass cost $c_p$, the effective reuse factor $n$, and the re-entry overhead $t_{\mathrm{re}}$ in a concrete Hamiltonian substrate.

#References

[1] The Physical Basis of the Gibbs-von Neumann entropy. arXiv:quant-ph/0701127v2. https://arxiv.org/abs/quant-ph/0701127v2 [2] Quantum mechanics as an asymptotic projection of statistical mechanics of classical fields: derivation of Schrödinger's, Heisenberg's and von Neumann's equations. arXiv:quant-ph/0511074v1. https://arxiv.org/abs/quant-ph/0511074v1 [3] How to Map Linear Differential Equations to Schrödinger Equations via Carleman and Koopman-von Neumann Embeddings for Quantum Algorithms. arXiv:2311.15628v2. https://arxiv.org/abs/2311.15628v2 [4] Estimating mixing properties of local Hamiltonian dynamics and continuous quantum random walks is PSPACE-hard. arXiv:quant-ph/0401184v1. https://arxiv.org/abs/quant-ph/0401184v1 [5] Electrical conductivity of charged particle systems and the Zubarev NSO method. arXiv:1809.03357v1. https://arxiv.org/abs/1809.03357v1 [6] Non-Equilibrium Statistical Operator. arXiv:1905.02012v1. https://arxiv.org/abs/1905.02012v1 [7] Geometry of quantum dynamics and a time-energy uncertainty relation for mixed states. arXiv:1302.1844v1. https://arxiv.org/abs/1302.1844v1 [8] General linear dynamics - quantum, classical or hybrid. arXiv:1103.3589v1. https://arxiv.org/abs/1103.3589v1 [9] A Bibliometric Review of Neuromorphic Computing and Spiking Neural Networks. arXiv:2304.06897v1. https://arxiv.org/abs/2304.06897v1 [10] Birkhoff-von-Neumann Switches with Deflection-Compensated Mechanism. arXiv:1308.4280v1. https://arxiv.org/abs/1308.4280v1 [11] On the notion of "von Neumann vicious circle" coined by John Backus. arXiv:1602.02715v2. https://arxiv.org/abs/1602.02715v2 [12] DOI 10.5281/zenodo.18195888. QNFO: Hamiltonian Dynamics as the Engine of Biological Computation. [13] DOI 10.5281/zenodo.18199940. QNFO: Comprehensive Technical Framework for Network Isomorphism.