Datasets:
Formats:
json
Languages:
English
Size:
< 1K
ArXiv:
Tags:
mathematics
optimization
gradient-descent
convex-optimization
learning-theory
recursive-self-improvement
Download research/code/verify_certificates.py from PureOne/Nhoryun-Omega-III: direct link, hf CLI and curl.
- Browser
- Download file 4.52 kB
-
https://huggingface.co/datasets/PureOne/Nhoryun-Omega-III/resolve/main/research/code/verify_certificates.py
- Command line
-
hf download hf://datasets/PureOne/Nhoryun-Omega-III/research/code/verify_certificates.py
-
curl -L -o verify_certificates.py https://huggingface.co/datasets/PureOne/Nhoryun-Omega-III/resolve/main/research/code/verify_certificates.py
4.52 kB
| #!/usr/bin/env python3 | |
| """Independent exact checks for finite-transcript and robustness certificates.""" | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from fractions import Fraction as Q | |
| from pathlib import Path | |
| from trajectory_certificates import (AffineForm, dot, interpolation_form, | |
| gd_coefficients, compensation_certificate, psd_exact, residual_lower_bound, | |
| trajectory_tube, linear_error_allowance) | |
| def main(): | |
| parser=argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument('--output',type=Path) | |
| args=parser.parse_args() | |
| interpolation_checks=0 | |
| for h in [Q(1,5),Q(1),Q(9,5),Q(19,10)]: | |
| for mu in [Q(0),Q(1,10)]: | |
| lambdas=[Q(1,5),Q(3,5),Q(9,10)] | |
| states=[(Q(1),Q(-2),Q(3,2))] | |
| for k in range(4): | |
| states.append(tuple((1-h*l)*x for l,x in zip(lambdas,states[-1]))) | |
| gradients=[tuple(l*x for l,x in zip(lambdas,z)) for z in states] | |
| values=[sum((l*x*x/2 for l,x in zip(lambdas,z)),Q(0)) for z in states] | |
| gram=[[dot(g,gp) for gp in gradients] for g in gradients] | |
| coeff=gd_coefficients(h,4) | |
| for i in range(5): | |
| for j in range(5): | |
| dx=tuple(x-y for x,y in zip(states[i],states[j])) | |
| dg=tuple(x-y for x,y in zip(gradients[i],gradients[j])) | |
| residual=tuple(d-mu*x for d,x in zip(dg,dx)) | |
| direct=values[i]-values[j]-dot(gradients[j],dx)-mu*dot(dx,dx)/2-dot(residual,residual)/(2*(1-mu)) | |
| encoded=interpolation_form(coeff,i,j,mu).evaluate(values,gram) | |
| assert encoded==direct and direct>=0 | |
| interpolation_checks+=1 | |
| accepted=[] | |
| for h in [Q(1,10),Q(1),Q(7,4),Q(9,5),Q(1859,1000)]: | |
| target,weighted,residual,weights=compensation_certificate(h) | |
| assert all(v>=0 for v in weights.values()) | |
| assert residual.loss==(Q(0),)*4 and residual.constant==0 | |
| result=residual_lower_bound(residual,4,[0,2,4,6]) | |
| assert result['verified'] and result['lower_bound_exact']=='0' | |
| accepted.append(str(h)) | |
| _,_,beyond,_=compensation_certificate(Q(93,50)) | |
| assert not psd_exact(beyond.gram)[0] | |
| # A failed original certificate above its range is not itself a counterexample. | |
| # The separate sharp-compensation verifier supplies actual interpolable data. | |
| assert psd_exact([[0,0],[0,1]])[0] | |
| assert not psd_exact([[0,1],[1,1]])[0] | |
| assert not psd_exact([[1,2],[2,1]])[0] | |
| assert psd_exact([[1,2],[2,4]])[0] | |
| assert psd_exact([[Q(1,3)]])[0] | |
| residual=AffineForm.make([Q(1,10),Q(-1,5)],[[-1,0],[0,2]],3) | |
| bounded=residual_lower_bound(residual,4,[1,2],1) | |
| assert bounded['verified'] and Q(bounded['lower_bound_exact'])==Q(-3,2) | |
| tube=trajectory_tube(Q(9,5),1,1,[Q(1,100000)]*3) | |
| allowance=linear_error_allowance([Q(2,3),-1,0,Q(1,3)],tube,[Q(1,1000000)]*4) | |
| assert allowance==Q('0.000038000648') | |
| # Independently realize an inexact quadratic trajectory and check every bound. | |
| quadratic_cases=0 | |
| for mu in [Q(0),Q(1,10)]: | |
| for lam in [Q(1,5),Q(3,5),Q(1)]: | |
| for eta in [Q(1,2),Q(9,5)]: | |
| err=[Q((-1)**k,100) for k in range(8)] | |
| bounds=trajectory_tube(eta,1,lam,[abs(e) for e in err],mu=mu) | |
| x=y=Q(1) | |
| for k in range(9): | |
| assert abs(y-x)<=bounds[k]['position'] | |
| assert abs(lam*(y*y-x*x)/2)<=bounds[k]['value'] | |
| if k<8: | |
| x=(1-eta*lam)*x | |
| y=(1-eta*lam)*y-eta*err[k] | |
| quadratic_cases+=1 | |
| report={ | |
| 'all_exact_checks_passed':True, | |
| 'arithmetic':'fractions.Fraction, no floating point assertions', | |
| 'ambient_vs_gram_interpolation_equalities':interpolation_checks, | |
| 'verified_compensation_steps':accepted, | |
| 'out_of_range_certificate_rejected':True, | |
| 'PSD_adversarial_cases':5, | |
| 'residual_certificate_bound_exact':bounded['lower_bound_exact'], | |
| 'three_step_error_allowance_exact':str(allowance), | |
| 'inexact_quadratic_trajectory_cases':quadratic_cases, | |
| 'scope':'Algebra and stated finite checks; the universal statements are proved in the manuscript.'} | |
| if args.output: | |
| args.output.parent.mkdir(parents=True,exist_ok=True) | |
| args.output.write_text(json.dumps(report,indent=2)+'\n') | |
| print(json.dumps(report,indent=2)) | |
| if __name__=='__main__': | |
| main() | |