"""Original bounded tolerance contract with actual NumPy/math and rational oracle."""
from fractions import Fraction as F
from itertools import product
import math,json
import numpy as np

def validate(a,b,rtol,atol):
 if any(type(v) not in [int,float] or not math.isfinite(v) or abs(v)>10**6 for v in [a,b]) or any(type(v) not in [int,float] or not math.isfinite(v) or not 0<=v<=1 for v in [rtol,atol]):raise ValueError('finite bounded real scalars,nonnegative tolerances<=1;bool excluded')
 if rtol>=1:raise ValueError('local relative tolerance strictly below1')

def compare(a,b,rtol,atol):
 validate(a,b,rtol,atol);aa=F(a);bb=F(b);r=F(rtol);t=F(atol);error=abs(aa-bb);refbound=t+r*abs(bb);symbound=max(t,r*max(abs(aa),abs(bb)));return {'a':a,'b':b,'rtol':rtol,'atol':atol,'exact_binary_input_error':str(error),'reference_b_bound_exact':str(refbound),'symmetric_max_bound_exact':str(symbound),'manual_reference_b':error<=refbound,'numpy_isclose':bool(np.isclose(a,b,rtol=rtol,atol=atol)),'manual_symmetric':error<=symbound,'math_isclose':math.isclose(a,b,rel_tol=rtol,abs_tol=atol)}

def demo():
 forward=compare(1,2,.75,0);reverse=compare(2,1,.75,0);assert forward['numpy_isclose'] and not reverse['numpy_isclose'] and forward['math_isclose']==reverse['math_isclose']==True
 checks=0
 for a,b,r,t in product([-2,-1,-.5,0,.5,1,2],[-2,-1,-.5,0,.5,1,2],[0,.125,.5,.75],[0,.125,.5]):
  row=compare(a,b,r,t);assert row['manual_reference_b']==row['numpy_isclose'] and row['manual_symmetric']==row['math_isclose'];checks+=1
 near={'numpy_default':bool(np.isclose(1e-9,0)),'numpy_relative_only':bool(np.isclose(1e-9,0,atol=0)),'math_relative_only':math.isclose(1e-9,0)};assert near=={'numpy_default':True,'numpy_relative_only':False,'math_relative_only':False}
 chain=[compare(a,b,0,.1) for a,b in [(0,.06),(.06,.12),(0,.12)]];assert [r['numpy_isclose'] for r in chain]==[True,True,False]
 units=[compare(1,1.05,0,.1),compare(1000,1050,0,.1)];assert [r['numpy_isclose'] for r in units]==[True,False]
 boundary=compare(1,1.125,0,.125);assert boundary['numpy_isclose'] and boundary['manual_reference_b']
 special={'numpy_nan_self_default':bool(np.isclose(np.nan,np.nan)),'numpy_nan_self_equal_nan':bool(np.isclose(np.nan,np.nan,equal_nan=True)),'numpy_inf_self':bool(np.isclose(np.inf,np.inf)),'numpy_opposite_inf':bool(np.isclose(np.inf,-np.inf)),'math_nan_self':math.isclose(math.nan,math.nan)};assert special=={'numpy_nan_self_default':False,'numpy_nan_self_equal_nan':True,'numpy_inf_self':True,'numpy_opposite_inf':False,'math_nan_self':False}
 rejected=[]
 for label,args in [('relative_one_rejected',(1,2,1,0)),('negative_tolerance',(1,2,-.1,0)),('infinite_tolerance',(1,2,math.inf,0)),('nonnumeric',('1',2,0,0)),('bool_input',(True,2,0,0)),('shape_not_scalar',([1],[1],0,0)),('NaN_wrapper',(math.nan,0,0,0)),('over_value_budget',(10**7,0,0,0))]:
  try:compare(*args)
  except ValueError:rejected.append(label)
  else:raise AssertionError('expected rejection')
 return {'asymmetric_reference_forward':forward,'asymmetric_reference_reverse':reverse,'all588_binary_representable_grid_oracles':checks,'near_zero':near,'nontransitive_chain':chain,'unit_change_without_tolerance_change':units,'exact_binary_boundary':boundary,'direct_library_special_values_outside_finite_wrapper':special,'invalid_cases_rejected':rejected,'numpy_version':np.__version__,'scope':'exact rational oracle interprets supplied binary floats; tested grid uses exactly representable arithmetic, not proof all rounded boundary computations agree. NumPy reference-b uses sum, math symmetric usesmax; approximate closeness not transitive/identity/equivalence for dedup or quality of model/Opera output'}
if __name__=='__main__':print(json.dumps(demo(),ensure_ascii=True,indent=2))