"""JAM 6, line 2 instrument (2026-07-23): the resonance-debt ledger
proposed at line 1. Reuses next_parts/counts/deviation exactly from
jam2_rotation_protractor.py (unedited import) so the vectors e_d = P
e_{d-1} + a_d are the SAME rotated/arrival deviations JAM 2 already
computed the unweighted cosine on -- this is a re-weighting of that
same data, not a new measurement.

Exact telescoping identity (P a permutation mod odd q, hence norm-
preserving): with e_{d+1} = rotated_d + arrival_d,

    ||e_D||^2 = ||e_0||^2 + sum_d ||arrival_d||^2 + 2*sum_d <rotated_d, arrival_d>

Self-audited below before any new claim is trusted: the identity is
checked exactly (to float tolerance) at every depth, not assumed.

R_D := 2*sum_{d<D} <rotated_d, arrival_d> / sum_{d<D} ||arrival_d||^2
     = (||e_D||^2 - ||e_0||^2)/sum||a_d||^2  -  1

R_D -> 0 means the cross terms vanish relative to the injection
energy (pure Pythagorean growth, ||e_D||^2 ~ sum||a_d||^2, consistent
with JAM 2's near-zero unweighted cosine finding surviving weighting
too). R_D bounded away from 0, or flipping sign in long runs instead
of oscillating step to step, would mean "nearly orthogonal on
average" was hiding a real weighted resonance and JAM 2's diffusion
reading needs recarving.
"""
from __future__ import annotations

import numpy as np

from jam2_rotation_protractor import counts, deviation, next_parts

DEFAULT_MODULI = (9, 27, 81, 243, 729)
DEPTH = 63


def run(modulus: int, depth: int):
    level = np.array([1], dtype=np.uint64)
    e0 = deviation(counts(level, modulus))
    e_prev_norm2 = float(np.dot(e0, e0))

    cross_terms = []          # <rotated_d, arrival_d> per depth
    a_norms2 = []             # ||arrival_d||^2 per depth
    e_norms2 = [e_prev_norm2]  # ||e_d||^2 including e_0
    max_identity_err = 0.0

    for d in range(depth):
        doubled, injected = next_parts(level)
        nxt = np.concatenate((doubled, injected))
        doubled_counts = counts(doubled, modulus)
        injected_counts = counts(injected, modulus)
        next_counts = counts(nxt, modulus)

        rotated = deviation(doubled_counts)
        arrival = deviation(injected_counts)
        next_error = deviation(next_counts)

        cross = float(np.dot(rotated, arrival))
        a_norm2 = float(np.dot(arrival, arrival))
        e_next_norm2 = float(np.dot(next_error, next_error))

        # exact telescoping check at this single step
        predicted = e_norms2[-1] + a_norm2 + 2 * cross
        max_identity_err = max(max_identity_err,
                                abs(predicted - e_next_norm2) /
                                max(e_next_norm2, 1.0))

        cross_terms.append(cross)
        a_norms2.append(a_norm2)
        e_norms2.append(e_next_norm2)
        level = nxt

    return cross_terms, a_norms2, e_norms2, max_identity_err


def band_sign_runs(cross_terms):
    """Longest run of same-signed cross terms -- coherence, not just
    a nonzero mean, is what would falsify 'nearly orthogonal'."""
    signs = [1 if c > 0 else (-1 if c < 0 else 0) for c in cross_terms]
    best, cur, cur_sign = 0, 0, 0
    for s in signs:
        if s == cur_sign and s != 0:
            cur += 1
        else:
            cur, cur_sign = 1, s
        best = max(best, cur)
    return best


def main():
    print("modulus | max identity err | R_D (final) | longest same-sign run"
          " | ||e_D||^2/N_D (last 5 depths)")
    for modulus in DEFAULT_MODULI:
        cross_terms, a_norms2, e_norms2, ident_err = run(modulus, DEPTH)
        sum_a2 = sum(a_norms2)
        sum_cross = sum(cross_terms)
        R_D = (2 * sum_cross / sum_a2) if sum_a2 else float("nan")
        run_len = band_sign_runs(cross_terms)
        # e_D^2 / N_D over the last 5 depths, N_D = 2^D-ish node growth
        # proxied here by depth index since node count isn't tracked in
        # this loop -- report raw e_D^2 trend instead, honestly.
        tail_e2 = e_norms2[-5:]
        print("  %-4d | %.3e | %+.6f | %3d / %3d steps | %s"
              % (modulus, ident_err, R_D, run_len, len(cross_terms),
                 ["%.1f" % v for v in tail_e2]))

    print("\nHonest reading: identity error near machine epsilon confirms the")
    print("exact telescoping ledger (P is norm-preserving mod each odd q, self-")
    print("audited, not assumed). R_D measures the WEIGHTED resonance JAM 2's")
    print("unweighted cosine average could have hidden. A same-sign run length")
    print("comparable to total depth (not ~2, consistent with alternation) would")
    print("be the coherence signature line 1 warned about.")


if __name__ == "__main__":
    main()