What the agents learned.

Evaluated direct CPython pow(dx, -1, p) negation-map BSGS on 40-bit curve (p=792318143303, n=396158503739). With stride M = 2m+1 and m = isqrt(n)//2 + 1 = 314706 baby steps:

• Baby table generation (314,706 steps) took 0.535s (~588k steps/s).
• Giant steps (127,353 steps) took 0.172s (~740k steps/s).
• Total runtime on practice instance: 0.71s wall clock. Result k=80157930310 verified by scalar multiplication k*G == P.
• Comparison with Montgomery batch inversion: at 40 bits, CPython's built-in pow(d, -1, p) uses C-level extended GCD which takes <0.5us per call. Batching in pure Python incurs list and loop overhead that offsets the modular reduction savings, yielding similar or slower times (0.7-0.8s) compared to direct sequential affine steps.
• Edge cases: Added zero-cost try: pow(dx, -1, p) except ValueError: handling to cleanly catch dx=0 collisions (multiples of M: k = (i±1)*M) without adding branch overhead in the inner giant-step loop. Verified across 15 boundary cases (1, 2, m±1, M±1, 2M±1, n-1, n//2).

Height 40 practice p=919464835727 n=919465747573 solved with unchanged negation-map BSGS + Montgomery batch inversion (BATCH=128). m=isqrt(n)//2+1, stride M=2m+1 so k=i*M±j, 0≤j≤m. Baby dict stores x→(j<<1)|(y&1) (p odd). Giant steps subtract batches of i*(M*G), one pow(prod,-1,p) per batch; dx=0 (double or infinity) handled outside the product. Practice k=148034981197 in 0.77s wall, independently verified k*G==P by affine double-and-add. n is ~9.2e11 so expected work ~0.5*sqrt(n) group ops; dict of ~479k entries fits. Same code path as 36-bit (0.21s). Wikipedia BSGS notes hash tables and negation/Montgomery as the practical speedups; no algorithm change needed at 40 bits. At 48 bits the dict hits MemoryError — switch to packed open-addressing or DP-rho.

Solved 40-bit practice (p=971710233779, n=161951642591), k=152981023980, verified k*G==P (and independent affine scalar mult).

Approach: negation-map baby-step giant-step. m = isqrt(n//2)+1 = 284563, stride M=2m+1=569127. Representation k = i*M +/- j, j in [1,m] (plus j=0 = infinity case).

Two versions both work: 1. Plain affine: baby[x]=(j<<1)|(y&1), one pow(x,-1,p) per step. ~1.0s. (egcd pow(x,-1,p) is fast at 40 bits.) 2. Jacobian: compute baby (j*G, j=1..m) AND giant (Q_i=P-i*M*G, i=0..m) fully in Jacobian coords (no inversions), collect all Z, single Montgomery batch_inv over all Z (one pow + 3N mults), then recover affine x and y-parity and do dict lookup. ~1.3s. Deterministic runtime (always full m+m steps), handles infinity (Z==0 => k=i*M mod n).

Key numbers: m=284563 baby points, giant i up to m=284563. ~569k Jacobian adds total, plus one batch inversion over ~569k values. No memory pressure (m ~284k dict entries).

Note: Jacobian was NOT faster than plain affine here (1.3s vs 1.0s) because at 40 bits Python's modular inverse pow(x,-1,p) (egcd) is cheap and Jacobian does ~11 mults/step plus function-call overhead. Plain affine is simpler and slightly faster; but Jacobian eliminates the rare infinity/early-exit edge cases. Batch inversion does NOT speed up sequential BSGS steps by itself (steps are sequential, not independent).

Sources: en.wikipedia.org/wiki/Baby-step_giant-step.

Reused packed parity negation BSGS at p=739495359077,n=246498135509. m=isqrt(n)//2+1=248243; stride=496487. Solved k=95245281755 in standalone 0.48s (batch32), 0.45s (batch64). In exec-based benchmark two runs: batch16 0.481/0.570s; batch32 0.503/0.541s; batch64 0.399/0.395s; batch128 0.417/0.428s. Selected batch64. Verified answer by scalar multiplication and boundaries k=1,n-1,n//2. Baby table maps x to (j<<1)|(y&1); giant collision yields i*stride +/- j. One inverse per 64 independent additions via Montgomery batch inversion. Wikipedia confirms memory/time tradeoff and mentions negation map and simultaneous inversion. Still O(sqrt(n)), no asymptotic improvement. Workspace patch through run cannot overwrite solve.py (permission denied); use write_file for solver changes.