"""TNFR Riemann Zeros as Resonance Poles — Demonstration (P13).

Companion to ``41_von_mangoldt_zeta_demo.py``.  The prime-ladder
Dirichlet trace

    Z_vM(s) = Σ_{p,k} log(p) · exp(-s · k · log p) = -ζ'(s)/ζ(s)

converges only on Re(s) > 1.  This script demonstrates the
**analytic continuation in TNFR language** (module
``tnfr.riemann.analytic_continuation``, P13):

1. Evaluate the continuation at arbitrary s ∈ ℂ via mpmath.
2. Verify agreement with the prime-ladder sum on Re(s) > 1.
3. Detect Riemann zeros as **resonance poles** along Re(s) = 1/2.
4. Reconstruct ψ(x) = Σ_{n ≤ x} Λ(n) via the truncated explicit
   formula and quantify how each added resonance pole refines the
   prime-ladder envelope.

TNFR reading
------------
Each prime p contributes a REMESH echo ladder μ_{p,k} = k·log p.
Continuing Z_vM(s) to the strip Re(s) ≤ 1 exposes a discrete set of
*resonance poles* which carry the entire arithmetic content:

* The pole at s = 1 encodes the linear envelope ψ(x) ~ x.
* Each pole at s = ρ = 1/2 + i t_n acts as a coherent
  resonant frequency of the prime-ladder spectrum.

Honesty disclaimer
------------------
This script does not prove the Riemann Hypothesis.  It makes the
classical Hadamard / explicit-formula machinery **operational in TNFR
terms**: every analytic feature of -ζ'/ζ is labelled by a structural
mechanism of the prime-ladder REMESH spectrum.

See: theory/TNFR_RIEMANN_RESEARCH_NOTES.md §9.
"""

from __future__ import annotations

import sys

from tnfr.riemann import (
    build_prime_ladder_spectrum,
    fetch_riemann_zeros,
    reconstruct_psi_via_explicit_formula,
    scan_critical_line_for_poles,
    verify_continuation_agreement,
    von_mangoldt_zeta_continued,
)

# Ensure unicode-safe stdout on Windows piped terminals.
if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(encoding="utf-8")


def section(title: str) -> None:
    print()
    print("=" * 78)
    print(title)
    print("=" * 78)


def main() -> None:
    section("1) Continuation evaluator -- -zeta'(s)/zeta(s) at arbitrary s")
    sample_points = [
        (2.0, "real, in convergent region"),
        (3.0, "real, deeper in convergent region"),
        (complex(1.5, 5.0), "complex, on edge of convergence"),
        (complex(0.5, 14.134725141734693), "first Riemann zero (pole!)"),
        (complex(0.5, 20.0), "critical line, between zeros"),
        (-3.0, "between trivial zeros at s = -2, -4"),
    ]
    print(f"{'s':<45s}{'Re Z':>15s}{'Im Z':>15s}")
    print("-" * 75)
    for s, label in sample_points:
        try:
            z = von_mangoldt_zeta_continued(s, dps=25)
            print(f"  s={str(s):<40s}{z.real:>15.6g}{z.imag:>15.6g}    [{label}]")
        except ValueError as exc:
            print(f"  s={str(s):<40s}{'POLE':>15s}{'':>15s}    [{label}: {exc}]")

    section("2) Agreement on Re(s) > 1  (prime ladder vs continuation)")
    spectrum = build_prime_ladder_spectrum(n_primes=5000, max_power=15)
    print(
        f"Built prime-ladder spectrum: {spectrum.n_primes} primes, "
        f"max_power={spectrum.max_power}, size={spectrum.size}"
    )
    s_test = [2.0, 3.0, 4.0, complex(2.0, 1.0), complex(2.5, 5.0), complex(1.5, 3.0)]
    agree = verify_continuation_agreement(spectrum, s_test, dps=30)
    print(f"\n{'s':<25s}{'|Z_prime|':>15s}{'|Z_continued|':>18s}{'rel_diff':>12s}")
    print("-" * 70)
    for s, z_pl, z_co, rd in zip(
        agree.s_values, agree.z_prime_ladder, agree.z_continued, agree.rel_diff
    ):
        print(f"  s={str(s):<20s}{abs(z_pl):>15.6g}{abs(z_co):>18.6g}{rd:>12.3e}")
    print(
        f"\nAgreement: {agree.agreement_quality}  "
        f"(max_rel_diff = {agree.max_rel_diff:.3e}, "
        f"max_abs_diff = {agree.max_abs_diff:.3e})"
    )

    section("3) Resonance poles along Re(s) = 1/2  -- Riemann zeros detected")
    scan = scan_critical_line_for_poles(
        t_min=10.0,
        t_max=80.0,
        n_samples=4001,
        dps=25,
        peak_prominence=5.0,
        match_tolerance=0.05,
    )
    print(
        f"Sampled {scan.t_values.size} points along s = 1/2 + it, "
        f"t in [{scan.t_values[0]:.1f}, {scan.t_values[-1]:.1f}]"
    )
    print(
        f"Detected {scan.detected_peaks.size} resonance peaks; "
        f"matched {len(scan.matched_zeros)} known Riemann zeros "
        f"(quality: {scan.detection_quality})"
    )
    print(f"\n{'t_detected':>14s}{'t_known':>14s}{'|delta|':>12s}")
    print("-" * 40)
    for t_det, t_known, delta in scan.matched_zeros:
        print(f"  {t_det:>12.5f}  {t_known:>12.5f}  {delta:>10.2e}")

    section("4) Explicit-formula reconstruction of psi(x)")
    print("Fetching first 50 Riemann zeros via mpmath.zetazero ...")
    zeros = fetch_riemann_zeros(50, dps=30)
    x_pts = [20.0, 50.0, 100.0, 200.0]
    print()
    for n_use in (10, 30, 50):
        res = reconstruct_psi_via_explicit_formula(
            x_pts, n_zeros=n_use, zeros=zeros[:n_use]
        )
        print(f"  Using {n_use:>3d} zeros:")
        print(
            f"    {'x':>6s}{'psi(x) exact':>16s}{'psi(x) explicit':>18s}"
            f"{'abs_err':>12s}{'rel_err':>12s}"
        )
        for x, pc, pe, ae, re in zip(
            res.x_values,
            res.psi_classical,
            res.psi_explicit,
            res.abs_error,
            res.rel_error,
        ):
            print(f"    {x:>6.1f}{pc:>16.4f}{pe:>18.4f}{ae:>12.4f}{re:>12.4f}")
        print()

    section("Summary")
    print(
        "  - The TNFR prime-ladder Dirichlet trace agrees with\n"
        "    -zeta'(s)/zeta(s) on Re(s) > 1 to the prescribed precision.\n"
        "  - Continued to Re(s) = 1/2 it exhibits sharp resonance poles\n"
        "    at exactly the imaginary parts of the Riemann zeros.\n"
        "  - Truncating the explicit formula at N resonance poles\n"
        "    reconstructs psi(x) with O(N^{-1/2}) decay of the residual.\n"
        "  - All four features are PRESENT in the classical zeta calculus;\n"
        "    P13 only re-labels them in the prime-ladder REMESH-echo\n"
        "    formalism so each analytic feature acquires a structural\n"
        "    meaning in the TNFR framework."
    )


if __name__ == "__main__":
    main()