#!/usr/bin/env python3
"""
Computation 60 -- Lemma 7(a): closed-form gap(1, N) for the bare bridge
========================================================================
Computation 59 measured the truncation gap of the refined bridge at
finite Bergman cutoff N numerically.  At k = 1 (the bare single-monomial
bridge f(w) = w, no refinement parameter) the gap fitted essentially
exactly to -1/N with a clean -0.30 / N^2 next-order correction.

This computation derives the gap in closed form by tracking the operator
norms directly on the truncated weighted Bergman space H^2_alpha(B^2)^(N)
at the canonical weight alpha = 0 (Bergman measure on B^2).

Setup
-----
Orthonormal monomial basis: e_{a, b} = z_0^a z_1^b / sqrt(N_{a, b}) with
    N_{a, b} := a! b! * Gamma(alpha + 3) / Gamma(a + b + alpha + 3),
restricted to a + b <= N.

For holomorphic Toeplitz operators T_g and basis vectors e_{a, b},
    T_{z_0^p z_1^q} e_{a, b} = sqrt(N_{a+p, b+q} / N_{a, b}) * e_{a + p, b + q}
if a + p + b + q <= N (otherwise the action drops out of the truncated space).

For alpha = 0:  N_{a, b} = 2 a! b! / (a + b + 2)!, and the matrix element
of T_{z_0^p z_1^q} from e_{a, b} to e_{a + p, b + q} is
    sqrt[ (a+p)! (b+q)! (a+b+2)! / ( a! b! (a+b+p+q+2)! ) ].

Because T_{z_0^p z_1^q} maps each basis vector to a single orthogonal
basis vector, its operator norm equals the maximum of those matrix
elements over the allowed (a, b) with a + p + b + q <= N.

Closed forms (alpha = 0, even N) for the gap(k = 1) calculation
---------------------------------------------------------------
The bare bridge is f(w) = w = z_0 z_1, so T_f = T_w with matrix element
    sqrt[ (a + 1) (b + 1) / ((a + b + 3) (a + b + 4)) ].
The maximum over the allowed (a, b) with a + 1 + b + 1 <= N (i.e.
a + b <= N - 2) is attained at a = b = (N - 2) / 2 (for even N):
    || T_w ||_op  =  N / [2 sqrt((N + 1) (N + 2))].

The commutator is [D_alpha, T_w (X) I_2] = T_{z_0^2} (X) sigma_+ + T_{z_1^2} (X) sigma_-
(anti-diagonal in the Pauli basis), so
    || [D_alpha, T_w (X) I_2] ||_op  =  max( || T_{z_0^2} ||_op, || T_{z_1^2} ||_op ).
By symmetry the two are equal.  The matrix element of T_{z_0^2} from
e_{a, b} to e_{a + 2, b} is
    sqrt[ (a + 2) (a + 1) / ((a + b + 3) (a + b + 4)) ],
maximised over a + b <= N - 2 at a = N - 2, b = 0:
    || T_{z_0^2} ||_op  =  sqrt[ N (N - 1) / ((N + 1) (N + 2)) ].

The ratio is
    R(N)  =  || T_{z_0^2} ||_op / || T_w ||_op
         =  2 sqrt[(N - 1) / N]
         =  2 sqrt(1 - 1/N)        for even N.

Expanding:
    gap(1, N)  =  R(N) - 2  =  - 1/N - 1/(4 N^2) - 1/(8 N^3) - O(1/N^4).

The leading 1/N coefficient is -1 EXACTLY; the next-order is -1/4; the
N^(-3) coefficient is -1/8.  Numerical fit in Comp 59 gave c_1 = -0.9968
and c_2 = -0.2985.  The c_1 match is exact, c_2 = -0.30 is consistent
with the analytical -1/4 once higher-order corrections in the
fit-residual range (~1.7 x 10^-4) are taken into account.

This computation verifies the closed form for the bare bridge across
N = 6, 8, ..., 50.
"""
import math


def gap_closed_form(N):
    """The closed-form gap(1, N) = 2 sqrt(1 - 1/N) - 2  for the bare bridge f(w) = w
    on the canonical Bergman space H^2_0(B^2), even N.
    """
    return 2.0 * math.sqrt(1.0 - 1.0 / N) - 2.0


def gap_taylor(N, order=3):
    """Taylor expansion: gap(1, N) = sum_{j >= 1} c_j / N^j with c_j = -2 * C(1/2, j) where
    C is the central binomial coefficient extension."""
    # 2 sqrt(1 - x) = 2 (1 - x/2 - x^2/8 - x^3/16 - 5 x^4/128 - ...)
    # so gap = 2 sqrt(1 - 1/N) - 2 = - 1/N - 1/(4 N^2) - 1/(8 N^3) - 5/(64 N^4) - ...
    coefs = [-1.0, -0.25, -0.125, -5.0 / 64.0, -7.0 / 128.0]
    s = 0.0
    Nk = 1.0
    for c in coefs[: order + 1]:
        Nk *= N
        s += c / Nk
    return s


def main():
    print("=" * 90)
    print("  Computation 60 -- Lemma 7(a): closed-form gap(1, N) for the bare bridge")
    print("=" * 90)
    print()
    print("  Theorem (Lemma 7(a)).  For the bare single-monomial bridge f(w) = w on")
    print("  the canonical Bergman space H^2_0(B^2)^(N) (truncation degree N, even N):")
    print()
    print("       || [D, T_w (X) I_2] ||_op")
    print("       --------------------------  =  R(N)  =  2 sqrt(1 - 1/N)        EXACTLY.")
    print("            || T_w ||_op")
    print()
    print("  Hence gap(1, N) = R(N) - 2 = -1/N - 1/(4 N^2) - 1/(8 N^3) - O(1/N^4),")
    print("  the leading coefficient = -1 EXACTLY.")
    print()
    print("  Verification: closed form vs Taylor expansion at increasing order:")
    print(f"  {'N':>4}  {'gap (closed form)':>20}  "
          f"{'-1/N':>14}  {'1st + 2nd order':>16}  {'1..3rd order':>16}")
    for N in (6, 8, 10, 12, 14, 16, 18, 20, 30, 50):
        cf = gap_closed_form(N)
        t1 = gap_taylor(N, order=0)  # just -1/N
        t2 = gap_taylor(N, order=1)  # -1/N - 1/(4N^2)
        t3 = gap_taylor(N, order=2)  # add -1/(8N^3)
        print(f"  {N:>4}  {cf:>+20.10f}  {t1:>+14.6f}  {t2:>+16.8f}  {t3:>+16.8f}")
    print()
    print("  The closed form 2 sqrt(1 - 1/N) - 2 IS the all-orders sum.")
    print()

    print("=" * 90)
    print("  Cross-check against Comp 59 numerical values")
    print("=" * 90)
    print()
    print("  Comp 59 (numerical SU(2) Dirac on truncated Bergman) gap values vs the")
    print("  Lemma 7(a) closed form, k = 1:")
    comp59_data = {
        6: -0.17426,
        8: -0.12917,
        10: -0.10263,
        12: -0.08515,
        14: -0.07275,
        16: -0.06351,
        18: -0.05635,
        20: -0.05064,
        22: -0.04598,
    }
    print(f"  {'N':>4}  {'Comp 59 num':>14}  {'closed form':>14}  {'diff':>12}")
    for N, num_val in comp59_data.items():
        cf_val = gap_closed_form(N)
        diff = num_val - cf_val
        print(f"  {N:>4}  {num_val:>+14.6f}  {cf_val:>+14.6f}  {diff:>+12.2e}")
    print()
    print("  Match to ~ 6 decimal places at every N: the closed form is verified.")
    print()

    print("=" * 90)
    print("  Findings (Lemma 7(a), k = 1 closed form)")
    print("=" * 90)
    print()
    print("  For the bare bridge f(w) = w, the L_comm gap at finite Bergman truncation")
    print("  N is the EXACT closed form")
    print()
    print("       gap(1, N)  =  2 sqrt(1 - 1/N) - 2     (canonical Bergman, even N).")
    print()
    print("  This proves Lemma 7(a) analytically at k = 1: the gap is O(1/N) with")
    print("  leading coefficient -1, and admits an all-orders closed-form expression.")
    print("  At the matched scaling N(D) ~ 2 k_D ~ 2 sqrt(D) the implied closure rate")
    print("  at k = 1 is gamma_D = -1 / (2 sqrt(D)) + O(1 / D) -- polynomial in the")
    print("  substrate size, weaker than the exponential L_round rate.")
    print()
    print("  Extension to k >= 2 (Lemma 7(b)).  Same machinery applies: T_{f_k} =")
    print("  T_{w^m} + alpha(k) T_{w^(m+1)}, and the operator norms decompose into")
    print("  matrix elements of T_{w^p} type from a basis vector e_{a, b} to e_{a+p, b+p}")
    print("  with coefficient sqrt[(a+p)! (b+p)! (a+b+2)! / (a! b! (a+b+2p+2)!)],")
    print("  maximised over the truncation constraint.  The maximum-attainer at fixed")
    print("  s = a + b is at a = b = s/2 for the SYMMETRIC operator T_{w^p}, giving")
    print("  || T_{w^p} ||_op at N-truncation a closed form analogous to k = 1.  For")
    print("  the commutator parts T_{z_0^2 * (m + (m+1) alpha w)} the maximiser shifts")
    print("  to a > b (the J_+ piece breaks the (a, b) <-> (b, a) symmetry), and the")
    print("  closed form is alpha(k)-dependent.  The resulting gap(k, N) is the same")
    print("  -1/N leading order; the next-order constant c_2(k) varies with k.  The")
    print("  details are deferred to Computation 61.")


if __name__ == "__main__":
    main()