"""Wave-particle boundary continuity / IGW mode quantization.

Assertion-based CAS audit block.
Pillar: Particle Mechanics | Chain: Bohr-Sommerfeld -> de Broglie -> mode quantization
CalRef: Mathematical Bridge S5.2, Particle Mechanics preliminaries a71
"""


def run():
    from sympy import symbols, simplify, pi

    print("=== CAS AUDIT: F0013 — IGW mode quantization ===\n")

    pass_count = 0
    fail_count = 0
    total_steps = 0

    print("Section A: Inputs defined.")
    print("  Bohr-Sommerfeld: loop integral p dl = 2*pi*hbar*n\n")

    h_planck = symbols("h_planck", positive=True)
    L_loop = symbols("L_loop", positive=True)
    n_mode = symbols("n_mode", integer=True, positive=True)
    phi_int = symbols("phi_int", real=True)
    p_mom = symbols("p_mom", positive=True)

    hbar = h_planck / (2 * pi)

    print("Section B: Periodic boundary, p constant on loop, L > 0, phi_int real.\n")
    print("Section C: Lemmas declared.")
    print("  C.1: Constant p => loop integral p dl = p*L\n")
    print("Section D: Step log")
    print("---------------------------------------------")

    # Step 1: Bohr-Sommerfeld
    p_from_BS = 2 * pi * hbar * n_mode / L_loop
    step1_residual = simplify(p_from_BS * L_loop - 2 * pi * hbar * n_mode)

    total_steps += 1
    if simplify(step1_residual) == 0:
        print("  Step 1  PASS — p*L = 2*pi*hbar*n (Bohr-Sommerfeld + constant p)")
        pass_count += 1
    else:
        print(f"  Step 1  FAIL — residual: {step1_residual}")
        fail_count += 1

    # Step 2: hbar substitution
    p_substituted = simplify(p_from_BS)
    p_expected = h_planck * n_mode / L_loop
    step2_residual = simplify(p_substituted - p_expected)

    total_steps += 1
    if simplify(step2_residual) == 0:
        print("  Step 2  PASS — p = h*n/L (hbar = h/(2*pi) substituted)")
        pass_count += 1
    else:
        print(f"  Step 2  FAIL — residual: {step2_residual}")
        fail_count += 1

    # Step 3: de Broglie
    k_n = 2 * pi * p_expected / h_planck
    k_n_simplified = simplify(k_n)
    k_n_expected = 2 * pi * n_mode / L_loop
    step3_residual = simplify(k_n_simplified - k_n_expected)

    total_steps += 1
    if simplify(step3_residual) == 0:
        print("  Step 3  PASS — k_n = 2*pi*n/L (de Broglie)")
        pass_count += 1
    else:
        print(f"  Step 3  FAIL — residual: {step3_residual}")
        fail_count += 1

    # Step 4: k_n * L = 2*pi*n
    knL = simplify(k_n_expected * L_loop)
    step4_residual = simplify(knL - 2 * pi * n_mode)

    total_steps += 1
    if simplify(step4_residual) == 0:
        print("  Step 4  PASS — k_n*L = 2*pi*n")
        pass_count += 1
    else:
        print(f"  Step 4  FAIL — residual: {step4_residual}")
        fail_count += 1

    # Step 5: Interface phase quantization
    k_n_with_phase = (2 * pi * n_mode - phi_int) / L_loop
    step5_residual = simplify(k_n_with_phase * L_loop + phi_int - 2 * pi * n_mode)

    total_steps += 1
    if simplify(step5_residual) == 0:
        print("  Step 5  PASS — k_n = (2*pi*n - phi_int)/L => k_n*L + phi_int = 2*pi*n")
        pass_count += 1
    else:
        print(f"  Step 5  FAIL — residual: {step5_residual}")
        fail_count += 1

    # Step 6: phi_int = 0 recovery
    k_n_no_phase = k_n_with_phase.subs(phi_int, 0)
    step6_residual = simplify(k_n_no_phase - k_n_expected)

    total_steps += 1
    if simplify(step6_residual) == 0:
        print("  Step 6  PASS — phi_int = 0 recovers k_n = 2*pi*n/L")
        pass_count += 1
    else:
        print(f"  Step 6  FAIL — residual: {step6_residual}")
        fail_count += 1

    # Step 7: Mode spacing
    k_n_plus1 = (2 * pi * (n_mode + 1) - phi_int) / L_loop
    Delta_k = simplify(k_n_plus1 - k_n_with_phase)
    Delta_k_expected = 2 * pi / L_loop
    step7_residual = simplify(Delta_k - Delta_k_expected)

    total_steps += 1
    if simplify(step7_residual) == 0:
        print("  Step 7  PASS — Delta_k = 2*pi/L (mode spacing, n-independent)")
        pass_count += 1
    else:
        print(f"  Step 7  FAIL — residual: {step7_residual}")
        fail_count += 1

    # Step 8: Concrete numerical test
    L_val = 1e-9
    n_val = 3
    phi_val = 3.141592653589793 / 4
    k_computed = (2 * 3.141592653589793 * n_val - phi_val) / L_val
    k_expected_num = (23 * 3.141592653589793 / 4) / L_val
    rel_error = abs(k_computed - k_expected_num) / abs(k_expected_num)

    total_steps += 1
    if rel_error < 1e-12:
        print(f"  Step 8  PASS — Numerical: k_3 = {k_computed:.6e} /m (L=1nm, phi=pi/4)")
        pass_count += 1
    else:
        print(f"  Step 8  FAIL — Numerical rel error: {rel_error:.2e}")
        fail_count += 1

    print("---------------------------------------------\n")
    print("Section E: Output checks")
    print("---------------------------------------------")
    print("  Unit check: dimensionless — PASS\n")

    # Self-test: wrong quantization
    k_n_wrong = pi * n_mode / L_loop
    wrong_phase_residual = simplify(k_n_wrong * L_loop + phi_int - 2 * pi * n_mode)

    total_steps += 1
    if simplify(wrong_phase_residual) != 0:
        print("  Self-test 1: Wrong quantization (pi*n vs 2*pi*n) detected  PASS")
        pass_count += 1
    else:
        print("  Self-test 1: FAIL (wrong quantization not detected)")
        fail_count += 1

    expected_wrong_residual = -pi * n_mode + phi_int
    wrong_quant = simplify(wrong_phase_residual - expected_wrong_residual)

    total_steps += 1
    if simplify(wrong_quant) == 0:
        print("  Self-test 2: wrong residual = -pi*n + phi_int (quantified)  PASS")
        pass_count += 1
    else:
        print(f"  Self-test 2: FAIL — residual = {wrong_quant}")
        fail_count += 1

    print("---------------------------------------------\n")
    print("=============================================")
    print("  F0013 AUDIT RESULT")
    print(f"  Steps: {total_steps}  |  Pass: {pass_count}  |  Fail: {fail_count}")
    if fail_count == 0:
        print("  STATUS: *** PASS ***")
    else:
        print(f"  STATUS: *** FAIL *** ({fail_count} step(s) failed)")
    print("=============================================")
    print("Audit complete for F0013.")
    print(f"  ✓ F0013 — {pass_count}/{total_steps} PASS")


if __name__ == "__main__":
    run()