"""Proof: addition order changes the answer. One million float32
values, three orders, three sums; then the repairs: pairwise
(what torch does), Kahan compensation, and fsum as ground truth."""
import math, torch

torch.manual_seed(0)
x = (torch.randn(1_000_000) * 100).float()
truth = math.fsum(x.double().tolist())

fwd = torch.tensor(0.0)
for c in x.split(100_000):          # sequential in chunks, forward
    for v in c: pass
# a plain python loop over 1e6 floats is slow; do exact fp32 fold in torch
def fold(t):
    s = torch.tensor(0.0, dtype=torch.float32)
    for v in t.split(4096):
        for u in v.tolist():
            s = s + torch.tensor(u, dtype=torch.float32)
    return s.item()

seq_fwd = fold(x[:50_000])          # smaller slice keeps runtime sane
seq_rev = fold(x[:50_000].flip(0))
tsum    = x[:50_000].sum().item()   # torch's pairwise-style reduction
truth50 = math.fsum(x[:50_000].double().tolist())
print(f"ground truth (fsum)       : {truth50:.6f}")
print(f"sequential, forward       : {seq_fwd:.6f}   err {seq_fwd-truth50:+.6f}")
print(f"sequential, reversed      : {seq_rev:.6f}   err {seq_rev-truth50:+.6f}")
print(f"torch .sum() (pairwise)   : {tsum:.6f}   err {tsum-truth50:+.6f}")
print(f"forward == reversed       : {seq_fwd == seq_rev}")