Lossy by Construction

Abstract

This paper audits the numerical substrate on which modern computational physics is performed. The argument is methodological rather than physical. It does not claim that continuum physics is false, nor that its standard equations cease to be useful when evaluated numerically. It asks a narrower question: what is actually being computed when those equations are run on finite-precision binary hardware, and how candidly is that fact described.

Four observations are developed in turn.

First, a large class of methods that present themselves as discrete lattice physics are better described as carrier-field methods. The lattice provides the addressing structure, while the physics is carried by continuous distribution values stored at each cell. Lattice Boltzmann methods on stencils such as D2Q9, D3Q19 and D3Q27 are treated as the canonical example.

Second, the equations evaluated on these substrates contain transcendentals. Constants such as \(\pi\) and \(e\) are continuum-limit objects that no finite substrate can represent exactly. Each appearance is a finite approximation to a borrowed quantity, and that approximation has a precision cost that belongs to the substrate rather than to the underlying physics.

Third, the numerical substrate itself is lossy. IEEE 754 double precision carries about sixteen decimal digits in its mantissa. Quad precision has little practical hardware support outside specialised platforms. Octuple precision is defined by the standard but implemented in hardware nowhere. The error behaviour of long simulations on this substrate is operand-dependent and is rarely reported as a first-class quantity.

Fourth, the standard infeasibility objection to substrate-honest computation is overstated. About 617 bits, or about 405 balanced-ternary trits with sensible headroom, are sufficient to address every Planck cell in the observable universe. This does not make an exact methodology cheap, but it does show that it is not ruled out on addressability grounds.

The paper does not propose alternative physics. It proposes a more candid numerical practice: one that states what is continuous, what is discretised, what is borrowed from the continuum, and what precision budget the substrate is actually spending to produce the reported result. The argument is that this bookkeeping should be treated as a reportable part of the result itself, not as a background condition silently absorbed by the substrate.

The underlying observations are individually familiar across numerical analysis, computational physics and arbitrary-precision arithmetic; the paper's contribution is to state them together as one bookkeeping problem in computational physics.

Introduction

A simple question motivates this paper:

When a numerical physics result is published, how much of what is being reported is properly attributable to the equations of the underlying theory, and how much belongs to the substrate on which those equations were evaluated?

The question should have an unremarkable answer. In practice it does not. The equations of mainstream physics are continuum statements expressed in a mathematics of real and complex numbers, smooth manifolds, integrals over uncountable index sets and limits taken to infinity.

The substrate on which those equations are actually evaluated is finite, binary and lossy. Numerical analysis has long treated this mismatch as a technical matter of rounding error, conditioning and stability [1][2]. Computational physics has usually treated it as a tolerable background condition, on the working assumption that double precision is sufficient and that any remaining error is small enough not to disturb the physical conclusion.

This paper does not argue that the conclusion is therefore invalid. It argues that the numerical situation is deeper and more structural than the field usually states. A result obtained by evaluating a continuum equation on a finite-precision substrate is not simply “the equation, computed.” It is the equation as mediated by a representational format, an arithmetic budget, an error structure and a set of approximations to quantities that the substrate cannot itself represent exactly. That circumstance is not exceptional. It is the normal condition of computational physics.

The paper proceeds by four audits:

First, it asks whether the discrete-looking lattice methods of computational physics are actually discrete, or whether they are continuous carrier-field methods evaluated on a discrete address set.

Second, it asks what is being computed when equations containing transcendentals are run on a substrate that cannot represent those quantities exactly.

Third, it asks what precision the substrate itself actually supplies, how that precision is spent, and how much of the associated loss is ordinarily reported.

Fourth, it asks whether a more substrate-honest methodology is genuinely intractable, or whether one common form of the infeasibility objection has simply been overstated.

The structure of the paper follows that order:

Section 2 removes a single objection that would otherwise derail the discussion.
Section 3 examines the carrier-field character of mainstream lattice methods.
Section 4 examines borrowed transcendentals.
Section 5 examines the floating-point substrate itself.
Section 6 examines tractability.
Section 7 provides a small worked example.
Section 8 states the costs and open difficulties of the alternative methodology.

The Lorentz objection and why it is not engaged here

Any paper that mentions discrete substrates near the Planck scale invites a familiar objection:

A lattice with a fixed cell size defines a preferred reference frame. A boost into another inertial frame contracts the lattice spacing in the direction of motion. The lattice is not Lorentz-covariant, and this conflicts with experimental tests of Lorentz invariance to extremely high precision [3]. No fixed Planck-scale lattice can straightforwardly be identified with physical spacetime.

That objection matters when a paper is proposing discrete physics. It is not the question being asked here. Nothing argued in the present paper depends on the universe being a discrete lattice, on the Planck length being a literal cell size, or on Lorentz invariance being emergent rather than fundamental. The audit concerns the computational substrate on which physics is numerically evaluated: finite-precision binary hardware, discrete memory, fixed arithmetic formats and the methods built around them. Whether the underlying physics is continuous or discrete, the simulation is still performed on a finite machine, and the audit applies regardless.

The distinction matters because the two questions are often collapsed in discussion. A numerical method may be implemented on a discrete machine without committing the underlying theory to discrete spacetime, just as a continuum theory may be sampled on a lattice without implying that the lattice is the thing the theory is about. The present audit concerns this implementation level only. Its claims would remain the same if the underlying ontology were continuous, discrete or unknown.

The same separation applies to the broader viability question. Whether discrete physical substrates are viable in principle is not needed for the present argument. A reader who is fully committed to continuum physics can accept every substantive point made here without inconsistency.

The paper is not asking what the universe is made of. It is asking what the field is actually doing when it computes continuum equations on a finite numerical substrate.

Carrier fluids and the discrete-looking lattice

Many methods in computational physics are described as discrete. Lattice Boltzmann methods are described as discrete simulations of fluids on a regular grid. Lattice gauge theory is described as a discrete formulation of quantum field theory. Cellular-automaton models are described as discrete cosmologies. The shared suggestion is that the lattice itself is carrying the physical content of the calculation.

A closer look shows a different arrangement. In a typical lattice Boltzmann method on the D3Q27 stencil [4], each cell carries twenty-seven floating-point numbers, one for each discrete velocity direction in the stencil. These numbers are the values of a velocity distribution function \(f_i(\mathbf{x}, t)\) that is continuous in state, even though it is sampled on a discrete address set. The dynamics of the method are the update of these distribution values, with stencil weights \(w_i\) chosen so that the moments of the distribution match those of a Maxwell–Boltzmann distribution to a desired order. For D3Q27 these weights are

with a lattice sound speed of \(c_s = 1/\sqrt{3}\) in lattice units. The weights are not consequences of the lattice alone. They are calibrated against Hermite-polynomial integrals over a continuous Gaussian so that the recovered Navier–Stokes behaviour comes out correctly in the small-Mach-number limit [5].

This is a powerful and well-established numerical method. The classification issue is narrower. The lattice is the addressing structure. The physically meaningful quantities being evolved are the floating-point distribution values stored at each address, together with calibrated weights chosen to recover a target continuum behaviour. The observed Navier–Stokes dynamics are not being derived from bare local lattice states alone. They are being recovered from a carrier-field construction whose continuous content has been installed into the method by design.

The same pattern appears elsewhere. Lattice gauge theory stores complex-valued group elements on links. Lattice \(\phi^4\) stores a real-valued field on each site. Smoothed-particle hydrodynamics stores continuous quantities at particle positions. In each case the indexing may be discrete while the state variables and update law remain continuous in the relevant sense.

This is not a criticism of those methods on their own terms. They were designed to approximate continuum theories, and in many cases they do so extremely well. The point is classificatory. When a method built around continuous per-site or per-link quantities is described simply as discrete, an important part of the computational structure disappears from view. What has been shown in such cases is usually not that continuum behaviour emerges from a purely discrete substrate, but that a discretised carrier-field method reproduces the target continuum theory within its design envelope.

A useful test is the carrier-medium test. If the method requires a continuous quantity to be installed at each cell, link or particle in order to work, then the lattice or particle set is serving primarily as an address structure. The substrate that is actually carrying the computation is the attached field of values. A genuinely discrete substrate method would evolve only substrate states, with no continuous carrier attached. Such methods exist and have been studied [6][7][8], but they are not the dominant form of what computational physics ordinarily calls discrete simulation.

The conclusion of this section is modest but important. Much of computational physics that is described as discrete is more exactly described as continuum-state computation on a discrete index set. That is a perfectly legitimate methodology. It should simply be described with that precision. The remainder of the paper concerns the continuous quantities actually being computed, regardless of the address structure that holds them.

Borrowed transcendentals

Mainstream physics equations contain transcendental constants. The constant \(\pi\) appears in equations touching geometry, waves and statistics. The constant \(e\) appears in equations involving growth, decay and thermal occupation. Other transcendentals appear less often but in important places. None of these quantities has a finite representation in any positional number system. Yet every numerical evaluation of a physics equation containing them must produce a finite numerical answer.

The procedure by which this happens is familiar from the implementation of mathematical libraries. The transcendental is computed or retrieved to the precision of the substrate and then participates in the arithmetic as though it were exact at that precision. This is standard practice and is not being challenged here. The methodological point is simply that the quantity being used in the computation is not the transcendental as such, but a finite approximation to it supplied by the substrate.

That distinction is not merely philosophical. Numerical analysis has long shown how approximation error in constants can be bounded and propagated, and in many applications the resulting uncertainty is small enough to be negligible. But the distinction remains structural. When a result is reported as following from an equation, what has actually been computed is the result of evaluating that equation on a substrate that has approximated some of its constants and rounded the rest. The approximation budget belongs to the computation whether or not it materially changes the physical conclusion.

The constant \(\pi\) is a useful example because it does several different jobs in physics equations, and the audit applies slightly differently to each.

The first job of \(\pi\) is integration over a smooth direction set. When the constant appears as \(4\pi\), \(4\pi r^2\) or \(\frac{4}{3}\pi r^3\), it is measuring how much smooth angular space there is.

The fine-structure constant in SI units, \(\alpha = e^2/(4\pi\varepsilon_0\hbar c)\), contains a \(4\pi\) for this reason.

The Planck radiation law, \(u(\nu,T) = (8\pi h \nu^3/c^3)\,(e^{h\nu/kT}-1)^{-1}\), contains an \(8\pi\) for the same reason: it is counting modes in a smooth three-dimensional momentum space.

The Schwarzschild horizon area, \(A = 4\pi r_s^2\), contains a \(4\pi\) because it is the surface of a smooth two-sphere.

In each case the underlying continuum operation is angular integration. A finite substrate does not perform that operation exactly. It evaluates a finite approximation to the quantity that the continuum integral names.

The second job of \(\pi\) is conversion between cycles and phase. When the constant appears as \(2\pi\) in \(\hbar = h/2\pi\), it is converting between whole-cycle counting and a continuous phase variable.

Every appearance of \(\hbar\) in quantum mechanics carries this conversion silently. The Heisenberg bound \(\Delta x \Delta p \geq \hbar/2\), the canonical commutator \([\hat x, \hat p] = i\hbar\), and the Schrödinger equation \(i\hbar \, \partial_t \psi = \hat H \psi\) all rest on a \(2\pi\) that assumes a continuous phase circle. A finite substrate can only approximate that phase geometry to the precision available in its representation.

The third job of \(\pi\) is normalisation of a continuum measure. When the constant appears as \(\sqrt{2\pi\sigma^2}\) in the Gaussian distribution \(p(x) = (2\pi\sigma^2)^{-1/2}\exp(-x^2/2\sigma^2)\), it is fixing the integral of the distribution to unity over a continuous real line. Every application of the central limit theorem in physics inherits this \(\pi\), as do path-integral measures, partition functions of continuous-spin models and many other constructions. A finite substrate does not integrate over a continuous real line exactly. It evaluates a finite numerical surrogate to that normalisation.

The same pattern repeats for \(e\), for \(\sqrt{2}\), for the Euler–Mascheroni constant, for \(\zeta(3)\) and for other transcendentals appearing in physical equations. Each is a continuum-limit quantity that the substrate can only approximate at finite precision. The resulting value is not determined by the physics alone. It is also determined by the representational budget of the machine carrying out the calculation.

A more useful framing is as a bookkeeping requirement. Each transcendental appearing in a numerical physics calculation names a continuum quantity that the substrate must approximate. That approximation has a precision cost. The cost is a function of the numerical substrate, not of the underlying theory. When the substrate changes, the cost changes. When the precision changes, the cost changes. In principle the cost can be estimated and propagated just as other numerical uncertainties are estimated and propagated.

The conclusion of this section is limited but practical. Every transcendental constant in a numerical physics calculation is a borrowed quantity in the sense that the substrate does not contain it exactly and must supply it approximately. That borrowing is often entirely acceptable. What is less acceptable is the routine failure to treat the approximation budget as a first-class part of the reported computation. A more candid practice would name the borrowed quantity, state the precision at which it is being supplied, and propagate the associated uncertainty through the calculation.

The floating-point substrate

The previous section noted that numerical physics calculations routinely depend on constants that the substrate cannot represent exactly. This section turns from the constants to the substrate itself.

The substrate of almost all production computational physics is IEEE 754 binary floating point [9].

The standard defines several precisions, of which two have widespread hardware support and two have little or none.
The single-precision format (FP32) carries a 24-bit significand and provides about 7 decimal digits of precision.
The double-precision format (FP64) carries a 53-bit significand and provides about 16 decimal digits.
The quadruple-precision format (FP128) carries a 113-bit significand and provides about 34 decimal digits.
The octuple-precision format (FP256) carries a 237-bit significand and provides about 71 decimal digits.

Hardware availability varies sharply across these formats. FP32 and FP64 are implemented in the floating-point units of essentially every general-purpose processor manufactured in the last three decades. FP128 has hardware support on a small number of platforms, including IBM POWER and certain SPARC variants, and is otherwise emulated in software at a substantial cost. FP256 is implemented in hardware on no commercially available processor. Software libraries such as MPFR and Boost.Multiprecision provide arbitrary-precision arithmetic, but the cost is severe relative to native FP64 [10][11].

The implication for computational physics is direct. Almost every published numerical result rests on FP64 or lower precision. The arithmetic on which the result is computed has about sixteen decimal digits of relative precision per operation at best. The constants of the equations being evaluated, including the transcendentals discussed in the previous section, are themselves approximations at that precision. The accumulated error of a long simulation depends on operand magnitudes, on the conditioning of the operations, and on the order in which those operations are performed.

A simple numerical estimate is useful.

A modern lattice simulation may involve \(10^9\) cells and \(10^6\) time steps, performing perhaps ten arithmetic operations per cell per step. The total operation count is then on the order of \(10^{16}\). FP64 carries a machine epsilon of about \(2^{-52} \approx 2.22 \times 10^{-16}\). This does not mean the simulation accumulates an error of order unity in any simple way, because floating-point errors can cancel, decorrelate or amplify depending on the algorithm. It does mean that the available precision budget is finite and that very long runs can push hard against it. Whether the reported result remains trustworthy in detail, or only in aggregate, is an application-dependent question that is not always stated explicitly.

Recent literature contains a growing internal discussion of this issue. Studies on whether direct numerical simulation of turbulence can be performed in FP32 rather than FP64 [12] have shown that the flow physics is often robust to reduced precision, and that other sources of uncertainty, such as averaging windows or modelling choices, frequently dominate. That is an encouraging result for reduced-precision computing. It also shows that nominal format precision and effective result precision are not the same quantity. A code may tolerate lower precision because its physically relevant observables are insensitive to some part of the rounding structure already present in the higher-precision run.

A second observation concerns error structure. IEEE 754 behaviour depends not only on the nominal format but also on the magnitudes and ordering of operands. Subtraction of nearby quantities can lose leading digits through catastrophic cancellation. Summation of many small quantities depends on summation order. Conditional branches taken on floating-point comparisons can yield different control flow across machines or compiler settings even when the nominal algorithm is the same [13]. These effects are formally analysable, but in production codes they are often only partially tracked.

A third observation concerns the substrate's special values. IEEE 754 defines positive and negative zero, signed infinities, signalling and quiet NaNs, and subnormal numbers near the smallest representable magnitudes. These are features of the arithmetic format, introduced to manage exceptional numerical situations. They are not themselves physical observables. A simulation that produces a NaN has not thereby discovered a feature of the underlying theory; it has entered a numerical state the substrate cannot interpret as an ordinary finite value. Likewise, an infinity in the output may indicate overflow rather than a physically meaningful divergence. Distinguishing numerical pathology from physical content is part of the analyst's job, and sometimes a nontrivial part.

The conclusion of this section is practical rather than dramatic. The floating-point substrate on which mainstream computational physics is performed is finite, lossy and operand-dependent. None of these properties is a flaw of a particular implementation. They are normal properties of the format. The field has built an effective numerical practice around them. A more candid version of that practice would treat precision as a first-class resource: budgeted, monitored and reported alongside other uncertainties rather than left implicit in the background.

Tractability

The audit so far has identified structural limits in current numerical practice. The next question is narrower and more practical. If one wanted a more substrate-honest methodology, is it ruled out on computational grounds, or only made expensive?

One part of that question is addressability. The relevant calculation has been done independently several times, and the result is smaller than many first assume.

The diameter of the observable universe is approximately \(8.8 \times 10^{26}\) metres, or about 93 billion light-years. The Planck length is approximately \(1.616 \times 10^{-35}\) metres. The number of Planck cells along a single axis of a cube enclosing the observable universe is

To address each such cell uniquely along one axis requires

or equivalently

For the full three-dimensional coordinate triple, the requirement is approximately 615 bits or 390 trits. Pratten [14] computed this in 2008 and obtained 617 bits including a small headroom margin, and the calculation has since been independently rederived several times [15]. The result is robust to reasonable choices of universe radius and Planck length.

Some headroom is sensible to allow for cosmological growth, observational refinement of the universe radius, and a margin of safety. Working at 135 trits per axis instead of 130 multiplies the addressable range per axis by a factor of \(3^5 = 243\), giving a cube approximately 243 times wider than the observable universe along each side and approximately \(1.4 \times 10^{7}\) times larger by volume. The total budget for a coordinate triple at this resolution is 405 trits, or about 642 bits.

This calculation supports a limited conclusion. A substrate-honest methodology is not ruled out on addressing grounds alone. The coordinate ranges themselves are finite and numerically manageable.

That is not the same as saying the full methodology is cheap. Addressability is only one part of tractability. Exact or substrate-honest dynamics would still have to pay for neighbourhood bookkeeping, state update cost, memory bandwidth, cache behaviour, precision propagation and, on current commodity hardware, the overhead of emulating arithmetic that the machine does not natively support. Those costs are real. The present section removes one common impossibility claim. It does not eliminate the engineering problem.

For comparison, FP64 carries 53 bits of mantissa precision and would require about 204 mantissa bits to address \(10^{61}\) values along a single axis. This is FP256-equivalent precision, software-emulated at substantial cost. Three FP256 numbers per coordinate triple cost approximately 768 bits of storage and a very large arithmetic overhead. The same job done with 405 trits of integer-valued balanced ternary requires roughly 642 bits of storage. On commodity binary hardware this does not remove the emulation tax, but it does reduce the representational burden relative to a floating-point route aimed at the same raw addressing range.

A subsidiary point is in order. The choice of base 3 rather than base 2 is not idle.

Balanced ternary, with digits drawn from \(\{-1, 0, +1\}\), has a sign that is a property of the representation rather than a separate annotation. Carry propagation is symmetric. Negation is a per-digit operation. Knuth's discussion [16] treats the format as “perhaps the prettiest” of the integer number systems, and notes its asymptotic optimality in radix economy. The format also matches a small and growing body of work on ternary representations as substrates for both arithmetic [17][18] and machine learning [19]. The point made here is independent of base choice; the audit applies to any candidate substrate that takes precision as first-class. Balanced ternary is one such candidate, and it has structural properties that recommend it.

The conclusion of this section is narrow but useful. The standard claim that a more substrate-honest computational physics is impossible because the coordinate ranges are too large does not survive a numerical check. Around 615 bits or 390 trits suffice to address every Planck cell in the observable universe. With sensible headroom, 405 trits is enough. That does not settle runtime cost, tooling cost or adoption cost. It does show that one widely repeated impossibility argument is weaker than it is often taken to be.

Worked example: representation error of a sinusoid

The previous sections make a general methodological argument. A small worked example is useful for two narrower reasons. It shows that precision can be tracked as a structural property of a representation, and it shows where the test apparatus itself becomes the limiting factor.

Consider the simple function \(f(t) = \sin(2\pi t)\) on the unit interval. Suppose it is sampled at \(M\) evenly spaced points and represented in a balanced-ternary fixed-point format with \(N\) fractional trits. Each sample value is then rounded to the nearest representable multiple of \(3^{-N}\), and the per-sample rounding error is bounded by \(3^{-N}/2\). This bound is a property of the representation and the chosen precision alone. It does not depend on the sample history or on the order in which later operations are performed.

Table 1 records this bound for representative values of \(N\), alongside the equivalent decimal precision and the number of representable states in \([-1,1]\).

Table 1: Maximum representation error for a balanced-ternary fixed-point format of \(N\) fractional trits over \([-1, 1]\).

The floating-point comparison is straightforward. FP64 has relative precision near unity of about \(2^{-52} \approx 2.22 \times 10^{-16}\), which corresponds to roughly 33 trits of balanced-ternary fixed-point precision. FP128, where available, corresponds to about 71 trits. FP256, which has no mainstream hardware implementation, corresponds to about 150 trits. These are representational comparisons, not statements of equal runtime cost.

Table 2 reports the actual representation error for the sinusoid sampled at \(M = 1024\) points. The values were obtained by rounding each sample to the nearest representable trit-precision quantity and comparing against a reference value computed on the host machine in FP64 arithmetic.

Table 2: Representation error of the sinusoid \(\sin(2\pi t)\) sampled at 1024 points, rounded to balanced-ternary fixed-point precision of \(N\) trits.

The error follows the bound \(3^{-N}/2\) closely up to about \(N = 32\). Beyond that point the measured error stops decreasing. This is not evidence against the balanced-ternary representation. It is evidence that the reference values are themselves limited by the host FP64 substrate, which saturates near \(10^{-16}\). The test ceases to be informative once the reference arithmetic becomes the bottleneck.

That limitation is useful rather than embarrassing. It shows exactly the kind of bookkeeping problem the paper has been discussing. A test designed to evaluate a higher-precision representation cannot be validated indefinitely against a lower-precision reference. To test a 64-trit representation properly, one would need a higher-precision reference path, for example arbitrary-precision software arithmetic, with its own cost explicitly acknowledged.

The conclusion of the example is modest. It does not establish the superiority of one global methodology over another. It shows that, for a fixed-point representation, the representation error is a direct function of the format and can be bounded in advance. It also shows that the apparent accuracy of the test itself is constrained by the substrate on which the test is performed. A more candid numerical practice would treat both facts as reportable parts of the computation.

What this methodology costs

The argument so far has been largely diagnostic. A balanced account also needs to state what a more substrate-honest methodology would cost. Those costs are real, and they should be named plainly.

The first cost is functional. A substrate-honest methodology does not inherit an exact native treatment of the special functions on which much of physics relies. Sine, cosine, exponential, logarithm, gamma, Bessel functions, elliptic integrals and spherical harmonics all require approximation when evaluated on a finite substrate. Existing floating-point libraries already pay this cost internally and usually hide it from the user. A more candid methodology would not make the cost disappear. It would expose it, budget it and propagate the resulting uncertainty as part of the computation.

The second cost is analytical. Much of mathematical physics is built for the continuum: differential operators, integral measures, Lie groups, Fourier analysis and the associated asymptotic machinery. Discrete analogues exist for parts of this apparatus [20], but they are not yet as mature, general or standardised as their continuum counterparts. A substrate-honest computational physics would require not only alternative arithmetic but also a stronger library of discrete analytical tools. That is a research programme, not a drop-in replacement.

The third cost is computational in the narrow sense. Most production physics codes are written for native FP64 hardware that is fast, ubiquitous and heavily optimised by compilers, libraries and accelerators. A substrate-honest implementation running on today's commodity binary hardware will usually be slower per operation if it relies on software-emulated arithmetic, larger integer representations or explicit precision tracking. The cross-over point at which the additional cost repays itself depends on the application. Some calculations are throughput-limited and will continue to favour conventional floating-point methods. Others are precision-limited and may justify a more explicit substrate budget. The present paper does not claim that one regime dominates all others.

The fourth cost is infrastructural. Decades of code, benchmarking practice, validation suites and trained intuition have been built around floating-point methods. Moving to a more substrate-honest methodology would involve toolchain work, library work, reporting reform and retraining.

There is also a class of open technical questions that this audit does not pretend to settle. The relationship between substrate-level arithmetic and the symmetries of the continuum theories being approximated is not yet fully worked out. The precision costs identified in earlier sections can in principle be estimated, but a general catalogue of such costs for substantive physics workloads does not yet exist. The interaction between representational precision, renormalisation procedures and long-time stability remains incompletely studied. None of these observations refutes the methodology. They do mean that any serious alternative has to arrive with its own tooling, its own validation discipline and its own error analysis.

The conclusion of this section is restrained. A more substrate-honest computational physics is not a free upgrade. It costs performance, analysis, tooling and institutional effort. Those costs are part of the case, not an embarrassment to it. The argument of the present paper is only that they should be weighed against the existing costs of a practice that already spends a precision budget while often leaving that budget implicit.

The audit makes a limited claim. The numerical substrate on which computational physics is performed has structural properties that belong to the result, and those properties are not consistently treated as part of what is being reported. A more candid practice would name them, budget them and propagate them.

References

1. N. J. Higham, Accuracy and Stability of Numerical Algorithms, 2nd edition, SIAM (2002).
2. D. Goldberg, What Every Computer Scientist Should Know About Floating-Point Arithmetic, ACM Computing Surveys 23, 5–48 (1991).
3. V. A. Kostelecký and N. Russell, Data Tables for Lorentz and CPT Violation, Reviews of Modern Physics 83, 11–31 (2011).
4. S. Succi, The Lattice Boltzmann Equation for Complex States of Flowing Matter, Oxford University Press (2018).
5. X. Shan, X.-F. Yuan and H. Chen, Kinetic theory representation of hydrodynamics: a way beyond the Navier-Stokes equation, Journal of Fluid Mechanics 550, 413–441 (2006).
6. S. Wolfram, A New Kind of Science, Wolfram Media (2002).
7. G. 't Hooft, The Cellular Automaton Interpretation of Quantum Mechanics, Springer Fundamental Theories of Physics, vol. 185 (2016).
8. K. Zuse, Rechnender Raum, Friedrich Vieweg & Sohn (1969). English translation: Calculating Space, MIT Project MAC (1970).
9. IEEE Computer Society, IEEE Standard for Floating-Point Arithmetic, IEEE Std 754-2019 (Revision of IEEE 754-2008), July 2019.
10. D. H. Bailey and J. M. Borwein, High-Precision Arithmetic in Mathematical Physics, Mathematics 3, 337–367 (2015).
11. Boost C++ Libraries, Multiprecision.
12. M. Karp, R. Stanly, T. Mukha, et al., Effects of lower floating-point precision on scale-resolving numerical simulations of turbulence, 2025.
13. G. Fiedler, Floating Point Determinism, Gaffer on Games (2010).
14. T. Pratten, How Many Bits to Address the Universe? (2008).
15. B. Pallagi, Addressing the Universe: How Many Bits? (2022).
16. D. E. Knuth, The Art of Computer Programming, Vol. 2: Seminumerical Algorithms, 3rd edition, Addison-Wesley (1997).
17. P. O'Hare, Balanced Ternary: The Elegant Number System You’ve Never Heard Of, The Math Citadel (2021).
18. A. Hunhold, Ternary Arithmetic: A Survey and a New Approach, Mathematics 13, 2025.
19. Tim Dettmers et al., BitNet: Ternary Neural Networks with 1.58 bits per weight, 2025.
20. A. N. Hirani, Discrete Exterior Calculus, PhD thesis, Caltech (2003).