Do two implementations of “read an amount” agree?

They differed by a factor of one hundred on an ordinary input, and by a sign on another. Both had shipped. Both had passing tests.

Outcome

Divergent

Published

10 September 2026

Question fixed

08 September 2026· stated by us, not proven

What came back.

They did not agree. One implementation removed every character that was not a digit, so an amount printed with two decimal places came back a hundred times too large. Another had no sign handling at all, so a negative came back positive and a loss was recorded as income. Both were in production and both had passing tests.

Implementations of one quantity: 3
600000.00, stripping non-digits: 60000000
The same input read correctly: 600000
Ratio: 100×
(-) 1,00,52,670 with no sign handling: positive
Implementations after the fix: 1

The system under test.

Reading a number off a document looks like the least interesting code in a system, which is why it accumulates several implementations without anyone noticing. This check asks the only question that matters about them: do they agree?

Implementations found: 3, each documented as returning the same unit
Probe input 1: 600000.00 — an ordinary amount printed with decimals
Probe input 2: (-) 1,00,52,670 — a negative printed in the local convention
Probe input 3: ELSS - 190147 — a separator dash, not a minus sign
Method: Run every implementation over the same inputs and compare

The stated constraints

A1A printed amount and the number produced from it must denote the same quantity
A2A negative amount must stay negative, however the page marks it
A3A stated zero and an absent value must remain distinguishable
A4Two implementations of one quantity must produce one answer, or there must be only one implementation

The second instrument.

Independence is a claim. The table below is the evidence for it — including the two things that ARE shared.

First instrument

The implementations as written

Each was called on the same strings, in isolation, exactly as its callers call it.

Second instrument

Arithmetic on the printed value

The document states the quantity in a notation with agreed meaning. The check is what that notation denotes, computed by hand — which needs no implementation and so cannot inherit a defect from one.

Shared?	What	Note
Not shared	Implementation code	The comparison calls each function and reads what comes back. It contains no parsing of its own.
Not shared	The notation’s meaning	A decimal point and a minus sign are not conventions this system gets to define. That is what makes the second reading independent of every implementation.
Shared	The input strings	All readings see the same text. A misreading of what is PRINTED on the page would be reproduced by every one of them.
Shared	The author	The probe inputs were chosen by the person who suspected the defect. Inputs nobody thought of are not covered, and the fuzz harness exists for that reason.

The reasoning

Five steps, each checkable without a computer.

This is the part that does not require you to trust the solver.

01Removing every non-digit is not parsing. It is deletion.“600000.00” holds a 6, five zeros, and two further zeros after a point that has been thrown away — so the result is the correct number multiplied by one hundred. Anyone can reproduce it in one line, which is why it opens the homepage.

02A hundredfold error stays inside the plausible range.It does not throw, does not round oddly, and does not look like a bug on screen. Nothing about the output announces it. That is the definition of the failure this practice exists to find.

03Each implementation was right about what its author had in mind.One was written for a document that prints whole numbers; another for a document that never prints negatives. Neither was wrong in isolation, and neither was ever run against the other.

04Nothing recorded that they were two answers to one question.They lived in different modules under different names. The system held no representation of the fact that both claimed to compute the same quantity — which is exactly the condition under which a second instrument is worth building.

05A separator dash is not a minus sign, and the distinction is not obvious.A line reading “ELSS - 190147” is a label, a spacer and a figure. Treating the spacer as a sign turned a real deduction negative and the row was rejected. The rule that resolved it is positional: a minus must touch the digits.

What this does not settle.

It establishes disagreement on the inputs tested, not correctness on all inputs.: One grammar now exists and it agrees with the printed notation on every case examined. That is a stronger position than three implementations, and it is not a proof.
The probe inputs were chosen by someone who already suspected the defect.: A shape nobody imagined is not covered here. A property-based fuzz harness covers more of that space, and it is how the separator-dash case was actually found.
It says nothing about whether the number on the document is itself right.: This check is about reading, not about the truth of what was printed. A wrong figure faithfully read is a different check.
The unit fix is compile-time and language-specific.: Branding the unit in the type system removes this class where the type system reaches. It does nothing at a boundary where the value arrives as an untyped number.

What would change the conclusion.

An input where the single grammar disagrees with the printed notation would reopen this immediately, and would be the more valuable finding.
A convention the grammar does not model — a different decimal separator, or accounting parentheses inside a larger expression — would need the rule restated rather than extended.
If the two implementations had ever been run against each other, this check would have been unnecessary. That is the general remedy, and it is what we build for other people.

Artifacts

identifiedThe single grammar that replaced the three implementations: One module carrying the sign rule, the decimal rule, and the stated-zero-versus-absent distinction. Identified by content hash; not yet published as a downloadable file.
identifiedThe property-based fuzz harness: Generates format variations and asserts extraction invariance. It found the separator-dash case, which no hand-written test had.
identifiedThe unit brand: The compile-time guard that makes the hundredfold class a build error. Mutation-proven: weakening the brand makes the guard assertions themselves stop compiling.
unavailableThird-party reproduction: Nobody outside ProServiq has re-run this. The one-line reproduction below needs nothing from us, though.

Revisions

10 Sept 2026
Published.

A corrected figure stays in the record. Silently fixing one would make every other figure unverifiable.

Reproduce

Any language with a regular-expression library

Strip every non-digit from the string "600000.00" and read the result as an integer.

It returns 60000000. The correct value is 600000. That is the whole defect, and confirming it needs nothing of ours.

← All checks The method →