pith. sign in

arxiv: 2604.17885 · v1 · submitted 2026-04-20 · 💻 cs.DS · cs.PL

Surreal Arithmetic, Lazily

Lloyd Allison This is my paper

Pith reviewed 2026-05-10 04:02 UTC · model grok-4.3

classification 💻 cs.DS cs.PL
keywords surreal numberslazy evaluationrecursive data structuresarithmetic operationsefficient implementationConway numbersdata structures
0
0 comments X

The pith

Lazy evaluation and recursive data structures yield considerable speedups for surreal number arithmetic.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper examines practical ways to implement Conway's surreal numbers along with their addition, multiplication, and other operations so that the code runs efficiently rather than bogging down. It finds that representing each surreal as a lazy recursive structure, where the left and right sets are only evaluated when actually required, produces a substantial performance gain. A sympathetic reader would care because surreal numbers form a single ordered field containing the reals, all ordinals, and infinitesimals; making them cheap to compute would let programmers and mathematicians use this rich system without custom shortcuts. The method works by deferring construction of subexpressions until an operation genuinely needs their values.

Core claim

Representing surreal numbers via lazy recursive data structures, in which each number's left and right sets are thunks evaluated on demand, allows the standard arithmetic operations to be coded directly yet execute with far less work than eager implementations that build entire subtrees immediately.

What carries the argument

Lazy recursive data structures for surreals, where left and right options are stored as unevaluated expressions that expand only when an operation inspects them.

If this is right

  • Surreal arithmetic becomes feasible for larger or more deeply nested numbers without exponential blow-up in work.
  • Operations can safely produce infinite or infinitesimal results because only the demanded parts of each number are ever built.
  • The same lazy discipline can be reused for any recursive definition of numbers or sets once the basic surreal machinery is in place.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • Languages with built-in laziness or easy thunk creation become natural hosts for exact arithmetic systems beyond floating-point.
  • The technique may generalize to other inductively defined objects such as games or combinatorial game values.
  • Memoization layered on top of the lazy trees could further reduce repeated work across multiple operations.

Load-bearing premise

The lazy recursive code faithfully reproduces the mathematical definitions of surreal equality, ordering, and arithmetic without introducing errors, non-termination, or wrong results.

What would settle it

Running the lazy implementation side-by-side with a correct non-lazy reference on a battery of addition, multiplication, and comparison tests and either obtaining mismatched results or failing to measure any runtime improvement.

Figures

Figures reproduced from arXiv: 2604.17885 by Lloyd Allison.

Figure 1
Figure 1. Figure 1: Definitions (see [2](p.4)) behaviours, e.g., ⟨0|⟩ × 𝑥 = 𝑥, 1 + ⟨|0⟩ = 0, and so on. After the birth of its two children there is generation 2 of zero’s four grandchildren including 2 = ⟨1|⟩ and 1/2 = ⟨0|1⟩, subsequently its eight great grandchildren and so on. The surreal numbers that are born in finite generations in the above way are equivalent to the dyadic rationals – numbers of the form 𝑖/2 𝑗 for inte… view at source ↗
Figure 2
Figure 2. Figure 2: SNs, the ”Genealogy” Tree of Surreals to the extent that, in a naive implementation, times 3 3 takes a fraction of a second but times 4 4 takes minutes and times 5 5 is hardly to be entertained. The cure for this problem of inefficiency is to use multiplication- and addition-tables which are in fact Trees of Trees, as defined in figure 3. Here map (apply to all) is the obvious function on Trees rather than… view at source ↗
Figure 3
Figure 3. Figure 3: Multiplication and Addition Tables [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
read the original abstract

Conway's surreal numbers were aptly named by Knuth. This note examines how far one can get towards implementing surreals and the arithmetic operations on them so that they execute efficiently. Lazy evaluation and recursive data structures yield a considerable speed up.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

2 major / 1 minor

Summary. The manuscript proposes implementing Conway's surreal numbers and their arithmetic operations (addition, multiplication, ordering) via lazy evaluation and recursive data structures, claiming this approach yields a considerable speed up over conventional methods.

Significance. If the lazy implementation is correct and the speed-up claim holds under fair comparison, the work could enable practical computation with surreal numbers in functional programming settings, where their recursive birthday-order definitions otherwise incur high costs. The approach leverages standard lazy techniques but currently provides no evidence to substantiate either correctness or performance gains.

major comments (2)
  1. [Abstract] Abstract: the claim that lazy evaluation and recursive data structures 'yield a considerable speed up' is unsupported, as the manuscript contains no benchmarks, runtime measurements, complexity analysis, or comparison to a baseline implementation.
  2. The manuscript provides no verification (proof, test suite, or reference implementation) that the proposed lazy recursive structures correctly realize Conway's definitions, especially for multiplication which recurses over all left/right option pairs; without this, non-termination or deviation from the standard ordering cannot be ruled out.
minor comments (1)
  1. The manuscript is extremely brief and lacks any pseudocode, implementation sketch, or discussion of memoization/equality handling needed for lazy surreal arithmetic.

Simulated Author's Rebuttal

2 responses · 0 unresolved

We thank the referee for their constructive comments. We provide point-by-point responses to the major comments below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the claim that lazy evaluation and recursive data structures 'yield a considerable speed up' is unsupported, as the manuscript contains no benchmarks, runtime measurements, complexity analysis, or comparison to a baseline implementation.

    Authors: While the manuscript does not present empirical benchmarks or runtime measurements, the proposed lazy evaluation and recursive data structures are designed to provide efficiency gains by computing surreal number options only as needed, thereby avoiding the full expansion of recursive definitions that would occur in an eager implementation. We will revise the manuscript to include a theoretical analysis of the computational complexity and a comparison to a baseline eager implementation to support this claim. revision: yes

  2. Referee: The manuscript provides no verification (proof, test suite, or reference implementation) that the proposed lazy recursive structures correctly realize Conway's definitions, especially for multiplication which recurses over all left/right option pairs; without this, non-termination or deviation from the standard ordering cannot be ruled out.

    Authors: The lazy recursive structures are constructed to faithfully implement Conway's definitions, with laziness ensuring termination by deferring computations. For the multiplication operation, although the definition involves all option pairs, only those required for the specific result are evaluated on demand. We will include a test suite in the revised manuscript to verify that the implementation matches known properties of surreal numbers and to rule out issues such as non-termination or incorrect ordering. revision: yes

Circularity Check

0 steps flagged

No circularity: performance claim is implementation-based, not derived from self-referential inputs

full rationale

The paper's core claim is that lazy evaluation and recursive data structures provide a speed-up for surreal arithmetic. This is a practical implementation assertion rather than a first-principles derivation, prediction, or theorem that could reduce to its own inputs. No equations, fitted parameters, self-citations as load-bearing premises, or renamings of known results appear in the abstract or context. The skeptic's concerns address verification of correctness (unrelated to circularity), and the reader's assessment of score 0 aligns with the absence of any enumerated circular patterns.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

The abstract provides no specific free parameters, axioms, or invented entities; the work rests on Conway's prior definition of surreal numbers.

pith-pipeline@v0.9.0 · 5306 in / 880 out tokens · 35339 ms · 2026-05-10T04:02:35.082005+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

9 extracted references · 9 canonical work pages

  1. [1]

    1975 , isbn =

    Conway, John Horton , title =. 1975 , isbn =

    work page 1975

  2. [2]

    1974 , note =

    Knuth, Donald Ervin , title =. 1974 , note =

    work page 1974

  3. [3]

    Software Practice and Experience , volume =

    Allison, Lloyd , title =. Software Practice and Experience , volume =. 1989 , url =

    work page 1989

  4. [4]

    Australian Computer Journal , volume =

    Allison, Lloyd , title =. Australian Computer Journal , volume =. 1993 , url =

    work page 1993

  5. [5]

    2015 , url =

    Roberts, Siobhan , title =. 2015 , url =

    work page 2015

  6. [6]

    An Invitation to Abstract Mathematics , publisher =

    Bajnock, Bela , title =. An Invitation to Abstract Mathematics , publisher =. 2013 , url =

    work page 2013

  7. [7]

    SoftwareX , pages =

    Roughan, Matthew , title =. SoftwareX , pages =. 2019 , url =

    work page 2019

  8. [8]

    Moscow Math

    Schleicher, Dierk and Stoll, Michael , title =. Moscow Math. J. , pages =. 2006 , url =

    work page 2006

  9. [9]

    Mamane, L. E. , title =. Types 2004 , publisher =. 2004 , url =

    work page 2004