AMR-050-0044 / k804,a: complementary direct-geometry lane

No canonical classification, acceptance, publication or peer files were changed.
The exact controls below do not establish the all-period analytic theorem.

Definition used
---------------
For an original billiard vertex P and a fixed focus F, unit inversion is
I_F(P)=F+(P-F)/|P-F|^2. We compute the signed shoelace area in the original
cyclic order. Omitting the final translation by F does not change this area.
The quantity tested is original signed area times inverted signed area.

Actual high-precision diagnostic
--------------------------------
scout_focal_inverted_area.py used the retained Jacobi orbit construction from
AMR-050-0007's direct-geometry checker, not a proposed closed area formula.
For parameter m=k^2, K=ellipk(m), delta=2*winding*K/n,
  a=dn(delta)/cn(delta), b=sqrt(1-m)/cn(delta), c=sqrt(m),
  P_i=(-a*sn(u+2*i*delta), b*cn(u+2*i*delta)).
The caustic squared semiaxes are 1,1-m, and lambda=b^2-(1-m).
Every sampled orbit was separately checked for boundary incidence, closure,
unit-velocity reflection, and confocal caustic tangency.

The actual run used mpmath 1.3.0, 85 decimal digits, m=.1,.5,.9, five phases
0,K/17,K/7,5K/13,11K/17, and both foci. It sampled every coprime winding
0<winding<n/2 for n=4,8,12,16: 27 families. Maximum reported relative spread
of A*A_dagger was 1.7114218e-85. This is numerical support, not proof.
The additional primitive n=3 and n=6 families all exhibited phase variation.
Their largest observed spreads were about .2017 and .04069 respectively.
Original output: executions/scout-run-001.json.

Exact finite controls
---------------------
check_exact_inverted_areas.py is self-contained Python standard-library code.
It uses Fraction arithmetic in quadratic fields, independently checks each
fixture's actual incidence, reflected unit-velocity directions, tangency and
strictly internal contact, and computes inversions directly. Every focal
squared distance is proved positive by rational comparisons.

1. On a^2=4,b^2=1,lambda=4/5, the primitive quadrilateral with axis vertices
   and the rectangular primitive phase both give A*A_dagger=4 at both foci.

2. The retained primitive octagon on a^2=40,b^2=15,lambda=24/7 gives
   A*A_dagger=133/5 at both foci. The rational logical vertices have physical
   scale sqrt(7). They are reconstructed from the retained boundary-tangent
   polygon and all reflection/tangency tests are rerun here; no old checker
   execution is merely assumed.

3. On a^2=21,b^2=16,lambda=336/25, let
   T=[(sqrt(21),0),(-3sqrt(21)/5,16/5),(-3sqrt(21)/5,-16/5)]
   and F=(sqrt(5),0). Both T and -T are genuine primitive three-periodic
   billiards on the same fixed ellipse and caustic. Their area products are
      98/75 - (2/225)*sqrt(105),
      98/75 + (2/225)*sqrt(105).
   Repeating each four times gives listed length 12 and products
      1568/75 - (32/225)*sqrt(105),
      1568/75 + (32/225)*sqrt(105).
   Both values are finite and unequal. This refutes an unrestricted
   listed-length-divisible-by-four reading, not a genuine 4|least-period result.

Original exact output: executions/exact-run-001.json.

Additional even-primitive repetition obstruction
------------------------------------------------
check_repeated_six.py imports only the adjacent exact helper after verifying
its SHA-256. Its two positive-order primitive hexagons share a=2,b=1,
lambda=4/9 and F=(sqrt(3),0):
  H=[(2,0),(4/3,sqrt(5)/3),(-4/3,sqrt(5)/3),(-2,0),
     (-4/3,-sqrt(5)/3),(4/3,-sqrt(5)/3)],
  V=[(0,1),(-4sqrt(2)/3,1/3),(-4sqrt(2)/3,-1/3),(0,-1),
     (4sqrt(2)/3,-1/3),(4sqrt(2)/3,1/3)].
All geometric checks are exact and rerun. The products are respectively
125/6 and 64/3. Repeating each twice gives listed length 12 and products
250/3 and 256/3. Thus even least period by itself is also insufficient when
an arbitrary repeat is padded to a multiple of four.
Output: executions/repeated-six-run-001.json.

Execution provenance and preserved failed route
-----------------------------------------------
Actual successful tool chunks: numerical 110b46; exact 50b471; six b02081.
The first exact invocation (fddde5) failed with a Python TypeError: separate
calls to the field factory created distinct classes, so cross-call equality
could not coerce a same-radicand value. No successful result file existed from
that invocation. Adding functools.cache to the field factory corrected this
implementation issue; the following exact run passed without changing the
mathematical calculations. This was not a theorem failure or numeric rounding.

Reproduction (from repository root; use a fresh --output path or omit it):
  python3 -I -B problems/AMR-050-0044/attacks/geometry/check_exact_inverted_areas.py
  python3 -I -B problems/AMR-050-0044/attacks/geometry/check_repeated_six.py
  python3 -I -B problems/AMR-050-0044/attacks/geometry/scout_focal_inverted_area.py
Only the last command uses an existing project-local mpmath dependency.
No dependency installation or external network request was performed.
