| import Mathlib |
|
|
| namespace OAI |
| /-! |
| Fixed-denominator rational interval certificates (§07–08). |
| Unknown intervals admit all real values. |
| -/ |
| namespace GeneralMahler.Cert |
| inductive IV |
| | unk |
| | box (lo hi:Int) |
| deriving DecidableEq, Repr |
|
|
| namespace IV |
| def den : Int := 1000000000000000000000000000000 |
| noncomputable def w (a:Int) := (a:ℝ)/(den:ℝ) |
| def Has (x:ℝ): IV → Prop |
| | unk => True |
| | box l h=> w l ≤ x ∧ x ≤ w h |
| |
| instance : Membership ℝ IV := ⟨fun v x=>Has x v⟩ |
|
|
| def c (n:Int):IV := box (n*den) (n*den) |
| instance (n:Nat) : OfNat IV n := ⟨c n⟩ |
| |
| protected def add0 : IV→IV→IV |
| | box a b,box c d=> box (a+c) (b+d) |
| | _,_=> unk |
| instance : Add IV := ⟨IV.add0⟩ |
| protected def n0 : IV → IV |
| | box a b=> box (-b) (-a) |
| | _=> unk |
| instance : Neg IV := ⟨IV.n0⟩ |
| instance : Sub IV := ⟨fun a b=> a+ -b⟩ |
|
|
| -- upward round division |
| def ud (a b : Int) : Int := -((-a)/b) |
| protected def mul0 : IV → IV → IV |
| | box a b,box c d => |
| let l:=min (min (a*c) (a*d)) (min (b*c) (b*d)) |
| let h:=max (max (a*c) (a*d)) (max (b*c) (b*d)) |
| box (l/den) (ud h den) |
| | _,_=> unk |
| instance : Mul IV := ⟨IV.mul0⟩ |
|
|
| def posInv (a b:Int) : IV := box (den*den/b) (ud (den*den) a) |
| protected def inv0 : IV→IV |
| | box a b=> if a>0 then posInv a b else if b<0 then -posInv (-b) (-a) else unk |
| | unk=> unk |
| instance : Inv IV := ⟨IV.inv0⟩ |
| instance : Div IV := ⟨fun a b=>a*b⁻¹⟩ |
| |
| protected def pow0 (A:IV) : ℕ→IV |
| | 0=>1 |
| | n+1=> (A.pow0 n)*A |
| instance : Pow IV ℕ := ⟨IV.pow0⟩ |
|
|
| def pos0 : IV→IV |
| | box a b=> box (max 0 a) (max 0 b) |
| | unk=> unk |
| def clampNN : IV→IV |
| | box a b=> box (max 0 a) b |
| | unk=> unk |
|
|
| def Zmax : IV→IV→IV |
| | box a b,box c d=> box (max a c) (max b d) |
| | _,_ =>unk |
| def Zmin (x y:IV) : IV := - Zmax (-x) (-y) |
| def Zabs (x:IV) : IV := clampNN (Zmax x (-x)) |
| def sq (x:IV) : IV := (Zabs x)*(Zabs x) |
| def span : IV→IV→IV |
| | box a b,box c d=> box (min a c) (max b d) |
| | _,_=>unk |
| def meet : IV→IV→IV |
| | unk,x=>x |
| | x,unk=>x |
| | box a b,box c d=>box (max a c) (min b d) |
| def Less : IV→IV→Bool |
| | box _ b,box c _=> decide (b<c) |
| | _,_=>false |
| def LeB : IV→IV→Bool |
| | box _ b,box c _=> decide (b≤c) |
| | _,_=>false |
| def SubB : IV→IV→Bool |
| | _,unk=>true |
| | box a b,box c d=> decide (c≤a) && decide (b≤d) |
| | _,_=>false |
|
|
| lemma dpos : 0<den := by decide |
| lemma rpos : 0<(den:ℝ) := by exact_mod_cast dpos |
| lemma w_mono : Monotone w := by |
| intro a b h; apply div_le_div_of_nonneg_right _ rpos.le; exact_mod_cast h |
| lemma w_strict : StrictMono w := by |
| intro a b h; apply div_lt_div_of_pos_right _ rpos; exact_mod_cast h |
| lemma w_max (a b:Int) : w (max a b)=max (w a) (w b) := w_mono.map_max |
| lemma w_min (a b:Int) : w (min a b)=min (w a) (w b) := w_mono.map_min |
| lemma w_add (a b:Int) : w (a+b)=w a+w b := by unfold w; push_cast; ring |
| lemma w_neg (a:Int): w (-a)= -w a:= by unfold w; push_cast; ring |
| lemma w0 : w 0=0 := by simp [w] |
|
|
| lemma mc (a:Int) : (a:ℝ)∈c a := by |
| change _≤ _ ∧ _ ≤ _ |
| unfold w |
| push_cast; rw [mul_div_cancel_right₀ _ rpos.ne']; exact ⟨le_rfl,le_rfl⟩ |
| lemma nc (n:ℕ) : (n:ℝ)∈c (n:Int) := by simpa using mc (n:Int) |
| lemma mz : (0:ℝ) ∈ (0:IV) := by change (0:ℝ) ∈ c (Int.ofNat 0); simpa using mc (Int.ofNat 0) |
| lemma mo : (1:ℝ)∈(1:IV) := by change (1:ℝ) ∈ c (Int.ofNat 1); simpa using mc (Int.ofNat 1) |
| variable {u v:ℝ} {A B:IV} |
| lemma madd (hu:u∈A) (hv:v∈B) : |
| u+v∈A+B := by |
| cases A <;> cases B <;> first | trivial | skip |
| rename_i a b c d |
| change w _ ≤ _ ∧ _ ≤ w _ |
| rw [w_add,w_add] |
| exact ⟨add_le_add hu.1 hv.1, add_le_add hu.2 hv.2⟩ |
| lemma mneg (hu:u∈A) : -u∈-A := by |
| cases A |
| · trivial |
| change w _ ≤ _ ∧ _ ≤ w _ |
| rw [w_neg,w_neg]; exact ⟨neg_le_neg hu.2,neg_le_neg hu.1⟩ |
| lemma msub (hu:u∈A) (hv:v∈B) : |
| u-v∈A-B := by rw [sub_eq_add_neg]; exact madd hu (mneg hv) |
| lemma lower_div (a b:Int) (h:0<b): |
| ((a/b:Int):ℝ)≤ (a:ℝ)/(b:ℝ) := by |
| apply (le_div_iff₀ (show (0:ℝ)<b from by exact_mod_cast h)).mpr |
| exact_mod_cast Int.ediv_mul_le a h.ne' |
| lemma upper_div (a b:Int) (h:0<b): |
| (a:ℝ)/(b:ℝ)≤(ud a b:ℝ) := by |
| have he:=lower_div (-a) b h |
| push_cast at he |
| unfold ud; push_cast; rw [neg_div] at he; linarith |
|
|
| lemma product_box (a b c d:ℝ) (ha:a≤u) (hb:u≤b) (hc:c≤v) (hd:v≤d): |
| min (min (a*c) (a*d)) (min (b*c) (b*d))≤ u*v ∧ |
| u*v≤ max (max (a*c) (a*d)) (max (b*c) (b*d)) := by |
| have hi (r:ℝ): min (r*c) (r*d) ≤ r*v ∧ r*v≤ max (r*c) (r*d) := by |
| rcases le_total 0 r with h|h |
| · exact ⟨le_trans (min_le_left _ _) (mul_le_mul_of_nonneg_left hc h), |
| le_trans (mul_le_mul_of_nonneg_left hd h) (le_max_right _ _)⟩ |
| exact ⟨le_trans (min_le_right _ _) (mul_le_mul_of_nonpos_left hd h), |
| le_trans (mul_le_mul_of_nonpos_left hc h) (le_max_left _ _)⟩ |
| rcases le_total 0 v with h|h |
| · exact ⟨le_trans (min_le_left _ _) ((hi _).1.trans (mul_le_mul_of_nonneg_right ha h)), |
| le_trans ((mul_le_mul_of_nonneg_right hb h).trans (hi _).2) (le_max_right _ _)⟩ |
| exact ⟨le_trans (min_le_right _ _) ((hi _).1.trans (mul_le_mul_of_nonpos_right hb h)), |
| le_trans ((mul_le_mul_of_nonpos_right ha h).trans (hi _).2) (le_max_left _ _)⟩ |
|
|
| lemma wdn (a:Int): w (a/den) ≤ w a / den := |
| div_le_div_of_nonneg_right (lower_div a den dpos) rpos.le |
| lemma wup (a:Int): w a / den ≤ w (ud a den) := |
| div_le_div_of_nonneg_right (upper_div a den dpos) rpos.le |
| lemma wm (a b:Int): w (a*b)/(den:ℝ)=w a*w b := by unfold w; push_cast; ring |
|
|
| lemma mmul (hu:u∈A) (hv:v∈B) : u*v∈ A*B := by |
| cases A <;> cases B <;> first| trivial|skip |
| rename_i a b c d |
| let l := min (min (a*c) (a*d)) (min (b*c) (b*d)) |
| let h := max (max (a*c) (a*d)) (max (b*c) (b*d)) |
| change w (l/den)≤_ ∧ _ ≤ w (ud h den) |
| have he : Monotone (fun a=>w a/(den:ℝ)) := |
| fun a b ha=> div_le_div_of_nonneg_right (w_mono ha) rpos.le |
| have hmin (a b:Int) : w (min a b)/den=min (w a/den) (w b/den) := he.map_min |
| have hmax (a b:Int) : w (max a b)/den=max (w a/den) (w b/den) := he.map_max |
| have hp:= product_box (w a) (w b) (w c) (w d) hu.1 hu.2 hv.1 hv.2 |
| refine ⟨(wdn l).trans ?_,le_trans ?_ (wup h)⟩ |
| · unfold l; simp_rw [hmin,wm]; exact hp.1 |
| unfold h; simp_rw [hmax,wm]; exact hp.2 |
|
|
| lemma mposInv (a b:Int) (h:0<a) (hu:u∈box a b) : u⁻¹∈posInv a b := by |
| have ha : 0<w a := w0 ▸ w_strict h |
| have hp : 0<u := lt_of_lt_of_le ha hu.1 |
| have hh : 0<w b := lt_of_lt_of_le hp hu.2 |
| have hb : 0<b := w_strict.lt_iff_lt.mp (by rwa [w0]) |
| change w _ ≤ _ ∧ _≤ w _ |
| have H (a:Int): (((den*den:Int):ℝ)/(a:ℝ))/(den:ℝ)=(w a)⁻¹ := by |
| unfold w; push_cast; rw [inv_div]; field_simp |
| refine ⟨le_trans ?_ ((inv_le_inv₀ hh hp).mpr hu.2), |
| le_trans ((inv_le_inv₀ hp ha).mpr hu.1) ?_⟩ |
| · rw [← H]; exact div_le_div_of_nonneg_right (lower_div _ _ hb) rpos.le |
| rw [← H]; exact div_le_div_of_nonneg_right (upper_div _ _ h) rpos.le |
|
|
| lemma minv (hu:u∈A) : u⁻¹∈A⁻¹ := by |
| cases A |
| · trivial |
| rename_i a b |
| change _∈ if a>0 then _ else if b<0 then _ else _ |
| split |
| next h=> exact mposInv a b h hu |
| split |
| next h=> |
| have hi : -u∈box (-b) (-a):=mneg hu |
| simpa only [inv_neg,neg_neg] using mneg (mposInv (-b) (-a) (neg_pos.mpr h) hi) |
| trivial |
|
|
| lemma mdiv (hu:u∈A) (hv:v∈B): u/v∈A/B := by rw [div_eq_mul_inv]; exact mmul hu (minv hv) |
| lemma mpow (hu:u∈A) (n:ℕ): u^n∈A^n := by |
| induction n with |
| | zero=> rw [pow_zero]; exact mo |
| | succ n ih=> rw [pow_succ]; exact mmul ih hu |
|
|
| lemma mle (hu:u∈A) (hv:v∈B) (he:LeB A B=true): u≤v := by |
| cases A <;> cases B <;> simp only [LeB,Bool.false_eq_true,decide_eq_true_eq] at he |
| exact hu.2.trans ((w_mono he).trans hv.1) |
| lemma mlt (hu:u∈A) (hv:v∈B) (he:Less A B=true): u<v := by |
| cases A <;> cases B <;> simp only [Less,Bool.false_eq_true,decide_eq_true_eq] at he |
| exact lt_of_le_of_lt hu.2 (lt_of_lt_of_le (w_strict he) hv.1) |
| lemma subB (hu:u∈A) (he:SubB A B=true): u∈B := by |
| cases B |
| · trivial |
| cases A |
| · contradiction |
| simp only [SubB,Bool.and_eq_true,decide_eq_true_eq] at he |
| exact ⟨(w_mono he.1).trans hu.1,hu.2.trans (w_mono he.2)⟩ |
|
|
| lemma mmax (hu:u∈A) (hv:v∈B): max u v∈Zmax A B := by |
| cases A <;> cases B <;> first| trivial|skip |
| change w _ ≤ _ ∧ _ ≤ w _ |
| rw [w_max,w_max] |
| exact ⟨max_le_max hu.1 hv.1,max_le_max hu.2 hv.2⟩ |
| lemma mclamp (hu:u∈A) (hh:0≤u): u∈clampNN A := by |
| cases A |
| · trivial |
| refine ⟨?_,hu.2⟩ |
| rw [w_max,w0]; exact max_le hh hu.1 |
| lemma mabs (hu:u∈A): |u|∈Zabs A := mclamp (mmax hu (mneg hu)) (abs_nonneg _) |
| lemma msq (hu:u∈A) : u^2∈sq A := by |
| have h:=mmul (mabs hu) (mabs hu) |
| rwa [← pow_two,sq_abs] at h |
| lemma mmeet (hu:u∈A) (hv:u∈B): u∈meet A B := by |
| cases A |
| · exact hv |
| cases B |
| · exact hu |
| refine ⟨?_,?_⟩ |
| · rw [w_max]; exact max_le hu.1 hv.1 |
| rw [w_min]; exact le_min hu.2 hv.2 |
| lemma span_conv {x:ℝ} (hu:u∈A) (hv:v∈B) (he:u≤x) (ht:x≤v): x∈span A B := by |
| cases A <;> cases B <;> first| trivial|skip |
| refine ⟨?_,?_⟩ |
| · rw [w_min]; exact (min_le_left _ _).trans (hu.1.trans he) |
| rw [w_max]; exact ht.trans (hv.2.trans (le_max_right _ _)) |
|
|
| end IV |
| end GeneralMahler.Cert |
|
|
| end OAI |
|
|
