# Independent finite-height factor certificate

[project] This late audit upgrades only the stated finite-height factor data.
It does not prove RH globally. The new scripts use python-flint/Arb at 160 bits,
not PARI's L-function evaluator, for the ordinary and quadratic analytic values.
PARI supplies only exact integer Kronecker character values. The earlier Artin
algorithm is a named, freshly rerun dependency, not secretly re-labelled as a new computation.

## Active analytic identity

[known] For D=5,41,205 the primitive real even quadratic character has conductor
D and root number +1. Its entire completion is

    ΛD(s)=(D/π)^(s/2) Γ(s/2)L(s,χD)
         =(Dπ)^(−s/2) Γ(s/2) Σ_(a=1)^(D−1) χD(a) ζ(s,a/D).

This follows by separating the Dirichlet series into residue classes, then
continuation. The apparent poles cancel in the entire completion. None of the
chosen boundary segments contains a pole of an individual evaluation factor.
The usual functional equation is ΛD(s)=ΛD(1−s). On a boundary ball wholly left
of real part 1/2 we evaluate the reflected formula instead; this avoids numerical
cancellation, without assuming any zero-location theorem.

[known] For D=1 the separate entire function used is
ξ(s)=s(s−1)π^(−s/2)Γ(s/2)ζ(s)/2. It has the same reflection symmetry and exactly
the ordinary nontrivial zeros. The identities, analyticity and symmetry are
classical input; the finite arithmetic verification is new to this notebook.

## Not a sampled contour

[project] We traverse the rectangle with real boundaries −1/2,3/2 and imaginary
boundaries −30,30 counterclockwise. Dyadic subdivisions give exact binary
endpoints. For each segment S:

1. Arb evaluates F on an entire complex rectangle containing S.
2. We accept only if the image enclosure is finite and excludes 0.
3. The interval ratio F(end)/F(start) must have positive real part; this keeps
   its principal argument safely inside (−π/2,π/2).
4. Otherwise subdivide S. No unresolved segment is silently skipped.

[known] The image enclosure is convex and excludes 0, so the true image curve
is homotopic, with endpoints fixed, to its endpoint chord inside a zero-free
convex set. It cannot make an extra turn around 0 within that set. The principal
ratio argument is therefore the true argument increment. Summing the interval
increments and dividing by 2π encloses the winding. Because the function is
entire and the contour is closed and zero-free, this quantity is an integer.
The script demands the interval lie within 1/4 of one integer, uniquely
identifying the zero count with multiplicity.

## Critical-line brackets complete the count

[project] For every earlier numerical height t, evaluate the real completed
function at 1/2+i(t±10^−12). Root number +1 and real coefficients make it real
on the critical line; the program also checks that the imaginary enclosure
contains 0. Strict opposite real signs prove a zero in the bracket. Exact rational
comparisons check the brackets are disjoint. Conjugation supplies a matching
negative-height zero. The central value is enclosed away from zero.

[known / project deduction] If the total winding equals twice the number of
positive brackets, these brackets exhaust every zero in the rectangle, and each
zero has multiplicity 1. There is no space left for an off-line zero, a real
exceptional zero, an extra critical zero or a higher multiplicity in this finite
rectangle. The new results are 3,11,21,28 positive zeros for D=1,5,41,205.
These are familiar finite zero facts, not new theoretical constraints.

## Artin dependency and the factored field count

[project] The previous `hyper-critical/q8-extended-results.json` already encloses
all 101 positive zeros of 2.42025.8t5.a.a through height 50 in disjoint brackets,
with total count 203 including the simple centre. The aggregation script records
that file's SHA256, checks its count/bracket metadata, and selects the 55 brackets
strictly below 30. A frozen copy and all inputs are in `sources/artin-dependency/`.
The complete algorithm was subsequently rerun in 221.824 seconds, with every
non-timing field identical to the pinned output. The assembler uses this fresh
result under `results/artin-rerun/`. A complete source read, mathematical bound
audit and exact reconstruction of all 5000 coefficients are recorded in
`artin-proof-audit.md`. Reproducing this algorithm is not an independent
implementation. The new field certificate is consequently a
**factored finite-height certificate using the freshly rerun Artin certificate**, not
an independent direct Arb computation of ζK.

[known / project deduction] Artin formalism and holomorphy give the exact
multiset union. The factor contributions are 3+11+21+28+2×55=173 at positive
height, plus the double centre; including negative heights gives 348. The field
function inherits three ordinary zeros, not all 173 ordinary zeros. Cross-factor
bracket disjointness is checked, and Artin zeros remain double as factors require.

## An unsuccessful approach retained honestly

[project] We first used the theta-integral/incomplete-gamma expansion. For
−1≤Re(s)≤2 and a=π/D, truncating after M has complex tail at most
exp(−aM²)/(a²M³). The inequality follows by bounding each t-power by 1 on
[1,∞), integrating the Gaussian and using an integral test in n.
Point values work and the D=5 special value is correct. But interval evaluation
on high contour boxes loses the exponentially small gamma scale through
cancellation: subdivision became impractically fine. A failing regression test
captured that. The active finite Hurwitz sum keeps the gamma factor outside;
reflection then fixes the expensive left-boundary cancellation. The unused
formula is retained as a reference, not claimed as the successful certificate.

## Reproduce

```sh
PY=/workspace/tools/pari-venv/bin/python
$PY scripts/test_quadratic_certificate.py
for D in 1 5 41 205; do $PY scripts/quadratic_certificate.py --D "$D"; done
python3 scripts/pin_factor_certificates.py
python3 scripts/assemble_certificate.py
python3 scripts/test_certificate_chain.py
```

[project] Each new factor JSON records its evaluator, complete argument enclosure,
accepted-segment statistics, signed endpoint enclosures, central enclosure and
source SHA256. The aggregate explicitly identifies reuse of the Artin certificate.
The original sampled winding remains just a sampled winding; this later proof
does not turn that old mesh into a certified contour after the fact.
