[tombouctou]

Steps 1–5 of the outline in #2047: PrecisionReal keeps a real-valued precision, as WMA does, and Plus and Times carry it through.

Input	master	this PR	WMA 15
Precision[1.5`20.3]	20.	20.3	20.3
Precision[1.5`5.497 + 1.5`5.497]	5.	5.497	5.497
Precision[1.5`5.497 * 1.5`5.497]	5.	5.19597	5.19597
Precision[1.5`20.3 + 3.2`30]	20.	20.796	20.796
Precision[2 + 1.5`20.3]	20.	20.668	20.668
Precision[N[Pi, 30] N[E, 30]]	30.	29.699	29.699
Precision[N[Pi, 30] E]	30.	30.	30.
Precision[N[Pi, {20, 5}]]	5.	5.49715	5.49715
Accuracy[1.5`5 - 1.5`5]	15.	4.52288	4.52288
ToString[1.5`20.3, InputForm]	1.5`20.	1.5`20.3	1.5`20.3
3.14159265358979323846264`20.6	20 digits	21 digits	21 digits

Changes

• PrecisionReal (mathics/core/atoms/numerics.py) has a new slot, _precision10. It is None unless the precision differs from what the binary precision of the sympy.Float already gives, so numbers without a fractional precision look the same as before. precision10 returns the decimal precision; for a zero, as before, it is the accuracy. The object cache is keyed by (sympy.Float, precision10). __neg__, do_copy and pickling keep the value. precision still returns binary digits.
• Parser: x`p and xa`` keep the real-valued precision the parser already computed. The binary precision is rounded up from it.
• Precision, Accuracy read precision10.
• Plus, Times: when the numbers are exact or nonzero PrecisionReals, the errors add up, as in WMA. For Plus the absolute errors add: the accuracy is -Log10[Total[10^-acc_i]]. For Times the relative errors add: the precision is -Log10[Total[10^-prec_i]]. A sum that cancels down to no digits becomes a zero with that accuracy, as in WMA. The computation itself still runs in mpmath at a whole number of bits. Machine numbers, complex numbers and zero factors take the code path they took before.
• Exact constants: numerify (used by Plus, Times, Power) evaluates exact numeric elements like E or Sqrt[2] with 16 more digits than the inexact ones. Their error then vanishes next to the error of the inexact ones, so N[Pi, 30] E keeps precision 30., as in WMA. Without this, E would count as one more 30-digit number and give 29.699. Nothing changes when a machine number is involved.
• N[expr, {prec, acc}] (N: evaluate with {precision, accuracy}; give a numeric precision to N rules as a machine real #2028) stores the precision it computes instead of rounding it down to whole bits.
• Equal: the tolerance ("the last 7 binary digits") is taken from the decimal precision, not from the binary digits it was rounded up to. Otherwise 13.14164 == 13.14134 (a doctest, True in WMA) would turn False. For numbers with a whole-digit precision the tolerance is the same as before.
• Output: the number of digits shown is the precision rounded, as in WMA, and InputForm shows the stored precision.
• eval_add_numbers and eval_multiply_numbers had three identical copies: mathics/eval/numeric.py, mathics/eval/arithmetic.py and mathics/eval/arithfns/basic.py. Plus and Times use the one in basic.py, while Abs and Sign use the one in numeric.py. Now there is one, in numeric.py, which the other two modules import, so the new rule applies everywhere.

Tests

• New test_real_valued_precision in test/builtin/atomic/test_numbers.py, with the WMA 15 values above.
• In test_precision, Precision[{{a, 2, 3.2`}, {2.13, 3.25, "a"}}] expected 3.. That was only 2.13 rounded down: its precision is `3.32222`. The case now compares with Precision[2.13]. WMA itself answers MachinePrecision here, because the list holds a machine number; the case above it has the same difference, which this PR doesn't change.
• test_n_precision_and_accuracy (N: evaluate with {precision, accuracy}; give a numeric precision to N rules as a machine real #2028) and test_gamma expected whole-digit precisions. They now expect the WMA 15 values, e.g. Precision[N[Pi, {20, 5}]] is 5.49715 and the Gamma quotient from issue 203 has precision 99.699.

Full run (Python 3.14, pytest -n 4 and docpipeline.py), this branch next to master 0e0aba0 on the same runner:

• Doctests: 4604 passed, 0 failed.
• pytest: 45 failed on this branch, 50 on master. All of them depend on the order the tests run in (contexts, packages, patterns, images): every file with a failure passes when run on its own, on both branches. The two sets also differ from run to run.

Benchmark

Local micro-benchmark (best of 5, Python 3.14, macOS):

	master	this PR
Total[Table[N[1/k, 50], {k, 2000}]]	1299 ms	1308 ms
Times @@ Table[N[1 + 1/k, 50], {k, 2000}]	1476 ms	1574 ms
Do[x = N[k, 50] + Pi, {k, 2000}]	1803 ms	1896 ms
Total[Table[1./k, {k, 2000}]] (machine reals, control)	903 ms	932 ms

So 1–7% on arbitrary-precision sums and products, against 3% noise on the machine-number control. The memory cost is one slot per PrecisionReal.

Not in this PR (step 6 of the outline)

• N[Pi, 20.3] still gives precision 20.: N with a non-integer precision.
• Functions other than Plus and Times, such as Sqrt and Power, keep the minimum precision of their arguments instead of WMA's condition-number adjustment.
• SetPrecision, SetAccuracy.
• A low-precision input is stored with a few bits, so its binary value is off from the decimal one. That shows when it cancels: Precision[1.5`20 - 1.4`2] gives 0.852 here and 0.854 in WMA.

🤖 Generated with Claude Code

[rocky]

Personally, I think this is really excellent. Very well thought out and executed. It is exacting, and this level of detail distinguishes us from virtually all of the other Mathematica lookalikes.

And it also removes some code duplication.

This is a great improvement over the kind of code I experienced when I first encountered this project.

Thanks @tombouctou!

However, @mmatera, you had concerns. So I'm waiting to hear your thoughts.

[rocky]

LGTM