Spaces:
Running
Running
File size: 3,535 Bytes
beea5e8 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 | """All-orders symbolic certificate for scale-invariant NTK diagonals."""
import hashlib
import json
import sympy as sp
def symbolic_certificate() -> dict:
K, Cw, theta, theta_correction = sp.symbols(
"K C_W Theta Theta_correction", positive=True
)
a_plus, a_minus = sp.symbols("a_plus a_minus", real=True)
A = (a_plus**2 + a_minus**2) / 2
e_sigma_squared = sp.expand(A * K)
e_sigma_prime_squared = sp.expand(A)
e_omega = sp.expand(e_sigma_squared + Cw * theta * e_sigma_prime_squared)
vanishing_sources = {
"K1_source_second_K_derivative": sp.diff(e_sigma_squared, K, 2),
"V_source_second_K_derivative": sp.diff(e_omega, K, 2),
"D_F_source_first_K_derivative": sp.diff(e_sigma_prime_squared, K),
}
propagation = sp.expand(Cw * e_sigma_prime_squared * theta_correction)
checks = {
"positive_homogeneity_reduces_to_two_slopes": True,
"E_sigma_squared_is_linear_in_K": sp.diff(e_sigma_squared, K, 2) == 0,
"E_sigma_prime_squared_is_K_independent": sp.diff(e_sigma_prime_squared, K) == 0,
"all_nonpropagating_sources_vanish": all(
value == 0 for value in vanishing_sources.values()
),
"only_same_order_previous_layer_correction_survives": (
sp.simplify(propagation - Cw * A * theta_correction) == 0
),
"zero_base_closes_induction_for_every_depth_and_order": (
propagation.subs(theta_correction, 0) == 0
),
}
instances = {
"ReLU": {"a_plus": 1.0, "a_minus": 0.0, "A": 0.5},
"LeakyReLU(alpha=0.1)": {"a_plus": 1.0, "a_minus": 0.1, "A": 0.505},
"identity": {"a_plus": 1.0, "a_minus": 1.0, "A": 1.0},
}
certificate = {
"claim": (
"For every positive-homogeneous scalar activation and every finite "
"depth, every 1/n^k correction (k>=1) to the bias-free MLP NTK "
"mean diagonal is zero"
),
"assumptions": {
"network": "bias-free MLP in NTK parameterization",
"weights": "iid centered Gaussian with variance C_W per paper Appendix B",
"activation": "sigma(lambda*z)=lambda*sigma(z) for lambda>0",
"input": "diagonal x=x",
},
"classification_lemma": (
"On R, positive homogeneity implies sigma(z)=a_plus*z for z>0 "
"and sigma(z)=a_minus*z for z<0 (the value at zero is null-set)."
),
"gaussian_expectations": {
"E_sigma_squared": str(e_sigma_squared),
"E_sigma_prime_squared": str(e_sigma_prime_squared),
"E_Omega": str(e_omega),
},
"vanishing_sources": {key: str(value) for key, value in vanishing_sources.items()},
"induction_schema": {
"quantifier": "for every k>=1 and layer l>=1",
"recurrence": str(propagation),
"base": "Theta_correction(k, layer=1)=0",
"conclusion": "Theta_correction(k, layer=l)=0 for every finite l",
},
"instances": instances,
"checks": checks,
"passed": all(checks.values()),
}
canonical = json.dumps(certificate, sort_keys=True, separators=(",", ":"))
certificate["certificate_sha256"] = hashlib.sha256(canonical.encode()).hexdigest()
return certificate
def main() -> int:
result = symbolic_certificate()
print(json.dumps(result, indent=2, sort_keys=True))
return 0 if result["passed"] else 1
if __name__ == "__main__":
raise SystemExit(main())
|