# Adversarial review: renderer cost model

Verdict: the narrow numerical result survives; the advertised conversion does not. The leapfrog/FDTD scalar algebra, CFL numbers, diagonal magic-step proof, and 2.144x toy cost arithmetic are basically right for the stated explicit finite-difference model. But RESULT.md uses that toy model to close Vazza's relaxed-timestep escape, to identify implicit numerical coupling with Bell nonlocality, and to price what a physical renderer would expose. Those steps fail. Count: **3 FATAL / 7 SERIOUS / 5 MINOR**.

## CFL does not close Vazza's timestep escape

**Grade: FATAL**

Argus's headline claim in RESULT.md section 0.1 is too strong. CFL is binding on a particular class of algorithms: explicit local time-marching discretizations of hyperbolic PDEs on a grid. Vazza's section 4.2 asks whether high-energy neutrinos could be propagated with a timestep much coarser than `lambda_nu/c` "for reasons beyond what our physics can explain." That is not the same object as a second-order explicit finite-difference wave-equation stencil.

For quantum evolution, the decisive counterexample is immediate: a unitary propagator `exp(-i H t)` can advance by arbitrarily large `t` without a CFL stability limit. The difficulty moves to representing/applying the operator accurately and cheaply, not to numerical stability. Free fields, spectral methods, transfer-matrix/Hamiltonian formulations, exact phase evolution in momentum space, operator splitting, event-driven particle propagation, multirate local timestepping, AMR with local timestepping, semi-Lagrangian schemes, and asynchronous/event updates all break the inference from `Delta x` to one global explicit `Delta t <= Delta x/(c sqrt(d))`. Some of these are expensive, approximate, or unsuitable for interacting relativistic QFT; none are refuted by CFL.

Even within classical wave numerics, the statement "a timestep 2.4e11 times the CFL limit is unstable" is true only after assuming the algorithm whose CFL limit was derived. It does not answer Vazza's conceded escape, which is explicitly an escape from the `Delta t = lambda_nu/c` propagation assumption. Argus has shown: "an explicit local second-order grid renderer cannot take Vazza's relaxed timestep." It has not shown: "a renderer cannot take Vazza's relaxed timestep."

To survive, the claim must be weakened to: **Vazza's relaxed timestep is unavailable to a fixed-grid, explicit, local finite-difference renderer of relativistic wave propagation at spatial spacing `lambda_nu`; it remains open for non-FDTD, spectral, Hamiltonian/unitary, adaptive, event-driven, or otherwise nonlocal formulations.**

## Bell/CHSH and implicit solves are a category error

**Grade: FATAL**

RESULT.md section 0.2 should be removed, not softened. A numerical solver's global linear solve is a statement about computational data dependence inside an algorithm. Bell/CHSH nonlocality is a statement about correlations among spacelike-separated measurement outcomes under assumptions of locality, realism/statistical independence, and hidden variables. They are not the same kind of nonlocality.

An implicit PDE step can require solving a sparse linear system whose inverse has long-range support. That does not make the simulated physics Bell-nonlocal. Conversely, a classical hidden-variable renderer reproducing Bell violations would need nonlocal correlations or superdeterministic/conspiratorial structure at measurement events; that says almost nothing about whether its field-update kernel is explicit, implicit, spectral, event-driven, or table-driven. The mapping from "global solve" to "the same non-locality Bell requires" is not licensed.

This also undercuts the attempted rescue of section 0.1: even if evading CFL required a global solve, the cost/nonlocality thereby incurred would be an algorithmic property, not independent support from Bell.

To survive, the claim must be weakened to: **implicit or spectral schemes may introduce algorithmic long-range data dependence; this is not evidence of, nor equivalent to, Bell nonlocality.**

## The physical-dispersion conversion fails under renormalization

**Grade: FATAL**

RESULT.md section 7 lists assumption 3: "the observed dispersion relation is the scheme's dispersion relation." That is not merely limiting; for the intended physics inference it is fatal. Argus's own prior result says bare couplings/counterterms can absorb lattice artifacts into renormalized parameters. If so, the observed low-energy dispersion need not be the naive tree-level dispersion of the update stencil.

The free scalar case has no interaction freedom, but the universe is not a free scalar benchmark. In lattice QFT, the Symanzik program is precisely the construction of effective continuum descriptions plus irrelevant operators whose coefficients can be tuned. The coefficients that show up as Lorentz-violating dispersion in a toy finite-difference wave equation are not automatically observables of the substrate. They can be tuned away, shifted into other operators, or made unmeasurable in a renormalized low-energy sector.

This kills the conversion from "p=2 suppresses anisotropy by `(k a)^2` for this stencil" to "a physical substrate would expose or hide Lorentz violation at this price." The price table may be a correct table for a toy solver; it is not yet a price of physical Lorentz invariance.

To survive, the claim must be weakened to: **for a bare tree-level scalar finite-difference model with observed dispersion identified directly with stencil dispersion, spatial improvement suppresses rotation-breaking errors cheaply. No conclusion follows yet for interacting renormalized QFT.**

## The implicit-escape claim is overdrawn

**Grade: SERIOUS**

RESULT.md says abandoning explicitness "means a global solve coupling every cell every step." That does not follow. Crank-Nicolson and fully implicit schemes do solve sparse systems whose inverse is formally global, but practical algorithms use local sparse matrix-vector products, domain decompositions, multigrid, preconditioners, ADI factorizations, line solves, and approximate/local implicitness. Some unconditionally stable FDTD variants exist; searches surfaced CN-FDTD examples where timesteps over the CFL limit are allowed but iterative-solver cost grows as matrices lose diagonal dominance. That is a cost/conditioning trade, not a theorem that every cell is globally coupled every step.

For unitary evolution the stronger counterexample remains: applying `exp(-iHt)` has no stability limit. It may be globally expensive, but not because implicit PDE solves necessarily couple every cell in the way Argus states.

To survive, weaken to: **many CFL-evading schemes trade stability for nonlocal transforms, sparse solves, conditioning costs, or approximation error; the magnitude depends on formulation.**

## `C = N_sites x w` is too small to carry the word "cost"

**Grade: SERIOUS**

The cost model is defensible only as a toy operation-count proxy. In real stencil codes, memory bandwidth often dominates arithmetic. Cache reuse, vectorization, halo width, domain decomposition, synchronization, interconnect bandwidth, storage/checkpointing, and boundary/event handling can dominate FLOPs. Higher-order stencils increase halo radius and communication volume; spectral methods replace local stencil cost with transforms and global communication. The 2.144x number therefore means "stencil points times timestep count in this model," not "total compute" in any robust sense.

The denominator "per unit physical spacetime 4-volume" also presupposes uniform full-volume rendering. It is the wrong denominator for Vazza's holographic-surface bit budget, for sparse/event-based renderers, for adaptive mesh refinement, for observer-centered rendering, or for quantum-state evolution where Hilbert-space/state complexity, entanglement, and measurement schedule may dominate.

To survive, weaken to: **`C` is a local explicit grid-update proxy at fixed spatial resolution, useful for comparing stencil orders within one algorithm family.**

## Cost-minimizer at CFL ignores accuracy constraints

**Grade: SERIOUS**

Within the toy model, `C proportional 1/lambda` makes the largest stable timestep cheapest. But a renderer constrained by observables is not minimizing update count alone; it is minimizing cost subject to error tolerances. The Cheng et al. FDTD paper found that timestep choice affects numerical dispersion non-monotonically depending on scheme, and for FDTD(2,2) smaller timesteps can increase numerical dispersion while for FDTD(2,4) errors first decrease then increase. This supports Argus's local point that timestep is an error knob, but it also means "cost pins lambda at CFL" is not an unconstrained physical prediction. Accuracy, dispersion, damping, solver convergence, and measurement schedule can move the optimum.

To survive, weaken to: **if no accuracy constraint except stability is imposed, the explicit toy model chooses the CFL boundary.**

## The algebra checks, but only for the stated stencil

**Grade: SERIOUS**

I independently get Argus's leading phase-speed expansion. Starting from

`4 sin^2(omega lambda / 2) = lambda^2 sum_i 4 sin^2(k_i/2)`,

expand to fourth order:

`omega^2 - lambda^2 omega^4/12 = k^2 - sum_i k_i^4/12 + O(k^6)`.

With `omega/k = 1 + alpha k^2 + O(k^4)` and `k_i = k khat_i`, this gives

`alpha = (lambda^2 - sum_i khat_i^4)/24`.

So RESULT.md section 4 is right for `p=1`: the leading directional spread is lambda-free and equals `(1 - 1/d)/24` in coefficient. For a `2p` spatial stencil, the spatial anisotropy is pushed to `k^(2p)` in phase speed while the second-order time error remains `O(k^2)`. That part survives.

The limitation is that this is an algebraic property of separable Cartesian central differences with second-order time stepping. It is not a general theorem about lattice actions, gauge fields, fermions, quantum circuits, perfect actions, random lattices, causal sets, tensor networks, or adaptive/spectral renderers.

To survive, keep the algebra and narrow the scope aggressively.

## The CFL values and 2.144x table check out, but the interpretation does not

**Grade: SERIOUS**

The reported CFL bounds are arithmetically right for the listed 1-D second-derivative stencils with max symbol at `theta = pi`:

- `p=1`: `D(pi)=4`, `lambda_max=2/sqrt(12)=0.577350269` in `d=3`.
- `p=2`: `D(pi)=16/3`, `lambda_max=0.5`.
- `p=3`: `D(pi)=272/45`, `lambda_max=0.469668...`.
- `p=4`: `D(pi)=2048/315`, `lambda_max=0.452856...`.

The cost table also checks: `(6p+1)/7 * lambda_1/lambda_p` gives `2.1444`, `3.3366`, `4.5533` for `p=2..4`.

But "2.144x in total compute buys forty decades" is over-interpreted. Forty decades only follows at `k a_s ~ 1e-20`; run1.txt itself notices that at the ultra-high-energy endpoint relevant to some lattice-bound arguments, `k a_s` can be `O(1)` if `1/a_s` is near a bound like `1e11 GeV`. The RESULT.md phrasing makes the Planck-scale/low-energy case sound generic. It is not.

To survive, weaken to: **in the toy model, one spatial-improvement order costs 2.144x by stencil-count proxy and suppresses leading anisotropy by `(k a_s)^2`; the numerical benefit depends entirely on the actual probed `k a_s`.**

## The magic timestep is real and standard FDTD territory

**Grade: SERIOUS**

Argus's proof is correct. At `lambda = 1/sqrt(d)` and body-diagonal direction, `k_i = k/sqrt(d) = k lambda`, so

`4 sin^2(omega lambda/2) = lambda^2 d 4 sin^2(k lambda/2) = 4 sin^2(k lambda/2)`.

For `0 <= k_i <= pi`, the principal branch gives `omega = k`. This is exact, not merely leading order.

But this is not novel. It is standard numerical-dispersion behavior in FDTD/Yee-type schemes. Cowan, Bruhwiler, Cary, Cormier-Michel, and Geddes, "Generalized algorithm for control of numerical dispersion in explicit time-domain electromagnetic simulations," Phys. Rev. ST Accel. Beams 16, 041303 (2013), explicitly says FDTD is well known to have numerical dispersion error for waves not propagating along a grid diagonal. Cheng, Chen, Wang, and Yang, "Investigation of numerical dispersion with time step of the FDTD methods: avoiding erroneous conclusions," IET Microwaves, Antennas & Propagation (2021), arXiv:2001.10721, analyzes FDTD(2,2)/(2,4) timestep effects from 1-D to 3-D and treats CFL/time-step dispersion as established terrain.

To survive, mark this as rediscovery/prior art, useful as a check but not as a new finding.

## Prior art probably consumes all numerical-analysis novelty

**Grade: SERIOUS**

Argus expected rediscovery, and that expectation is right. CFL stability, Yee/FDTD dispersion, magic timestep behavior, higher-order finite differences, and Symanzik improvement are mature literatures. The search did not find an existing paper using CFL specifically to rebut Vazza's section 4.2 or a simulation-hypothesis cost claim; searches for `Courant`/`CFL` plus `Vazza`/`simulation hypothesis` returned no hits. That negative result is bounded and unverified, not proof of absence.

For improvement cost, there is direct prior art that improved actions are chosen to reduce finite-cutoff scaling violations with modest overhead. Snippe and van Baal, "Testing Improved Actions" (hep-lat/9607007), state that the computational overhead of more complicated improved actions is usually not more than a few to ten times the Wilson action. I did not find, in this search, someone explicitly pricing Symanzik improvement against Lorentz-violation observability in the simulation-hypothesis frame. Mark that as unverified, not novel.

To survive, claim novelty only for the attempted application to Vazza, and then only after the CFL/QFT objection is answered.

## Vazza's model and Argus's model meet less than RESULT.md says

**Grade: MINOR**

RESULT.md says Vazza and Argus "meet at exactly one place: the time step." They meet there only rhetorically. Vazza's model is holographic bits plus Landauer/Lloyd throughput, with no cells, grid, FLOPs, bandwidth, or stencil. Argus's model is cell updates per physical 4-volume. Both contain a `Delta t`, but the surrounding cost functionals are different enough that importing CFL into Vazza requires an extra premise: Vazza's abstract bit update is implemented as explicit local wave propagation on a spatial grid. That premise is not in Vazza.

To survive, say: **the models can be compared only after adding an explicit-local-grid implementation assumption to Vazza.**

## `sqrt(3)` stricter-than-Vazza is not generally meaningful

**Grade: MINOR**

For the scalar Cartesian 3-D explicit scheme, CFL is `Delta t <= Delta x/(c sqrt(3))`, stricter than Vazza's `Delta x/c`. But a particle/worldline renderer, ray tracing, exact characteristic method, or 1-D propagation along a chosen direction may naturally use `Delta x/c`; an anisotropic grid can also change the condition. The `sqrt(3)` correction is a property of this grid stencil, not a universal rebuttal.

To survive, keep it as a note about the chosen 3-D Cartesian finite-difference scheme.

## The code's verification is good but not independent enough for the general claims

**Grade: MINOR**

The code uses exact rational coefficients and high-precision evaluation, and it caught one self-labeling error. Good. But `D_max(p)` is asserted by grid search and equality at `pi` for `p=1..4`, not proved for arbitrary order. The empirical stepping test does not cover `d=3`, where the headline CFL number is used, though the symbol calculation is enough for the toy model. These are minor because the values themselves check out.

To survive, either state the finite checked range or add the proof of the symbol maximum for the stencil family being used.

## The self-criticism misses the big failure

**Grade: MINOR**

RESULT.md section 8 catches the mislabeled isotropic probe, the false body-diagonal prediction, and the missing timestep factor in the cost table. It does not catch the main failure: CFL is not a theorem about simulating QFT, and numerical-solver nonlocality is not Bell nonlocality. The self-criticism is complete for internal arithmetic mistakes, incomplete for conversion mistakes.

To survive, add those as first-order caveats in section 8 or section 7, not as afterthoughts.

## The result overstates sign-definite physical predictions

**Grade: MINOR**

For the p=1 toy scheme at CFL, the leading coefficient is non-positive and vanishes on body diagonals. That does imply subluminal phase speed at leading order for that scheme. It does not imply "any superluminal propagation excludes this class" unless "this class" is kept extremely narrow and unless group velocity, phase velocity, higher-order terms, field content, and renormalized observables are specified. Improved spatial stencils in Argus's own section 4 generate an isotropic superluminal leading term from time discretization, so even inside the family the sign claim is fragile.

To survive, restrict it to the unimproved p=1 scalar leapfrog phase velocity near `k=0`.

## WHAT I COULD NOT BREAK

- The leading-order phase-speed formula for the p=1 scalar leapfrog scheme is correct: `v = 1 + (k^2 a_s^2/24)(lambda^2 - sum_i khat_i^4) + O(k^4)`.
- The anisotropic coefficient spread is lambda-independent for that scheme.
- The p=1 diagonal magic-step proof at `lambda = 1/sqrt(d)` is correct and exact on the principal branch inside the Brillouin zone.
- The listed `lambda_max` values for `p=1..4` in `d=3` check out.
- The 2.1444x, 3.3366x, and 4.5533x toy stencil-count cost ratios check out.
- I found no verified prior use of CFL specifically against Vazza's relaxed-timestep section or against a simulation-hypothesis cost claim. This is a bounded negative search, not proof.

## Recommended credences

**H15: 0.82, down from 0.89.** The broad lesson that substrate claims require policy/action details still looks right, and this review actually reinforces it. But this result should not be counted as a completed independent support line, because its conversion fails at the Vazza/QFT step.

**H11: 0.78, down from 0.84.** The idea that Lorentz-violation bounds constrain an action/improvement policy rather than raw spacing remains plausible and is standard lattice-thinking. The specific "2.144x buys invisibility" quantification is too toy-model dependent, too sensitive to `k a_s`, and too exposed to renormalization/counterterm objections to carry 0.84.

**H16: 0.30, down from 0.50.** If H16 is the CAPACITY -> ERROR conversion route, this was not a successful completion. It completed an explicit-FD toy calculation, not a physical renderer conversion. The route remains possible in principle, but this instance shows how easy it is to smuggle the observable into the numerical scheme and then mistake the scheme error for a physical error.