openAI-math-dataset / lean /OAI /MeasureTheory /FalconerCompletion /Recursion /ProfileLipschitz.lean
| import Mathlib | |
| import OAI.MeasureTheory.Falconer.Estimates.ActualDirectBuffer | |
| import OAI.MeasureTheory.Falconer.Estimates.ActualFarBuffer | |
| import OAI.MeasureTheory.Falconer.Estimates.ActualOuterMasks | |
| import OAI.MeasureTheory.Falconer.Model | |
| import OAI.MeasureTheory.Falconer.Recursion.BranchCounts | |
| import OAI.MeasureTheory.Falconer.Recursion.BranchExponent | |
| import OAI.MeasureTheory.Falconer.Recursion.BranchPotential | |
| import OAI.MeasureTheory.Falconer.Recursion.BranchTransitions | |
| import OAI.MeasureTheory.Falconer.Recursion.DirectPolicyWitness | |
| import OAI.MeasureTheory.Falconer.Recursion.InheritedPolicyState | |
| import OAI.MeasureTheory.Falconer.Recursion.InteriorPolicy | |
| import OAI.MeasureTheory.Falconer.Recursion.Ledger | |
| import OAI.MeasureTheory.Falconer.Recursion.PolicyDescriptors | |
| import OAI.MeasureTheory.Falconer.Recursion.Potential | |
| import OAI.MeasureTheory.Falconer.Recursion.SourceBranchDepth | |
| import OAI.MeasureTheory.FalconerCompletion.Recursion.HighDepthGap | |
| namespace OAI | |
| /-! Recursive policies and quantitative depth estimates. -/ | |
| open _root_.OAI.PlanarFalconer | |
| section | |
| section | |
| open Set MeasureTheory | |
| open scoped ComplexConjugate RealInnerProductSpace | |
| namespace GraphLiteralSupport | |
| namespace CurrentFalconer.DimensionalPolicy | |
| open PlanarFalconer | |
| def ProfileLipschitzND (A : ℕ → ℝ) (N : ℕ) (L : ℝ) : Prop := | |
| ∀ i ≤ N, ∀ j ≤ N, |A i-A j| ≤ L*|(i:ℝ)-j|/(N:ℝ) | |
| lemma adjusted_profile_lipschitzND (m : ℕ → ℝ) {N : ℕ} {d : ℝ} | |
| (hN : 0 < N) (_hd : 0 ≤ d) | |
| (hinc : ∀ i j, i ≤ j → j ≤ N → | |
| 0 ≤ m j-m i ∧ m j-m i ≤ d*((j:ℝ)-i)/(N:ℝ)) : | |
| ProfileLipschitzND (fun n => m n-(d/2)*(n:ℝ)/N) N (d/2) := by | |
| intro i hi j hj | |
| have hNr : 0 < (N:ℝ) := by exact_mod_cast hN | |
| rcases le_total i j with hij | hji | |
| · have hh := hinc i j hij hj | |
| have hdij : (i:ℝ) ≤ j := by exact_mod_cast hij | |
| rw [abs_of_nonpos (sub_nonpos.mpr hdij)] | |
| dsimp only | |
| simp only [div_eq_mul_inv] at hh ⊢ | |
| apply abs_le.mpr | |
| constructor <;> nlinarith [hh.1,hh.2] | |
| · have hh := hinc j i hji hi | |
| have hdji : (j:ℝ) ≤ i := by exact_mod_cast hji | |
| rw [abs_of_nonneg (sub_nonneg.mpr hdji)] | |
| dsimp only | |
| simp only [div_eq_mul_inv] at hh ⊢ | |
| apply abs_le.mpr | |
| constructor <;> nlinarith [hh.1,hh.2] | |
| lemma potential_le_final_startND {A : ℕ → ℝ} {N a t f Q : ℕ} {L : ℝ} | |
| (hN : 0 < N) (hL : 0 ≤ L) (hA : ProfileLipschitzND A N L) | |
| (hQ : 0 < Q) (hw : a+Q ≤ t) (ht : t ≤ N) (haf : a ≤ f) (hft : f ≤ t) : | |
| potential A a t Q ≤ 2*A f+2*L*(Q:ℝ)/N := by | |
| have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN | |
| have hb := potential_near_final A hQ hw haf hft (e := L*(Q:ℝ)/N) ?_ | |
| · convert hb using 1; ring | |
| intro j _ hjt hjf hfj | |
| have hd : |(j:ℝ)-f| ≤ (Q:ℝ) := by | |
| have hjR : (j:ℝ) ≤ (f:ℝ)+Q := by exact_mod_cast hjf | |
| have hfR : (f:ℝ) ≤ (j:ℝ)+Q := by exact_mod_cast hfj | |
| exact abs_le.mpr ⟨by linarith,by linarith⟩ | |
| have hh := (hA j (hjt.trans ht) f (hft.trans ht)).trans | |
| (div_le_div_of_nonneg_right (mul_le_mul_of_nonneg_left hd hL) hNR.le) | |
| have hh' := (le_abs_self (A j-A f)).trans hh | |
| linarith | |
| theorem policy_costs_le_final_startND {A : ℕ → ℝ} {N q n offset : ℕ} {sig L : ℝ} | |
| (b : PolicyBranch A N q offset sig n) (hN : 0 < N) (hq : 0 < q) | |
| (hslack : sig*(N:ℝ) ≤ q) (hL : 0 ≤ L) (hA : ProfileLipschitzND A N L) | |
| (hinit : (b.state 0).start+10*q ≤ (b.state 0).finish) : | |
| ∑ j ∈ Finset.range n, branchCost A (b.state j) (b.label j) (b.state (j+1)) ≤ | |
| 2*A (b.state n).start+20*L*(q:ℝ)/N- | |
| potential A (b.state 0).start (b.state 0).finish (10*q) := by | |
| have hQ : 0 < 10*q := by omega | |
| have hfinal := BranchState.valid_depths (b.valid n le_rfl) | |
| by_cases hw : (b.state n).start+10*q ≤ (b.state n).finish | |
| · have hc := b.costs_le_potential hq hslack hw | |
| have hf := potential_le_final_startND hN hL hA hQ hw hfinal.2 (le_refl _) hfinal.1 | |
| norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf | |
| linear_combination hc+hf | |
| · cases n with | |
| | zero => exact (hw hinit).elim | |
| | succ n => | |
| have hs := b.step n (by omega) | |
| have hn := hs.nested hq (b.valid n (by omega)) | |
| have hp := hs.nonterminal | |
| have hpwide : (b.state n).start+10*q ≤ (b.state n).finish := by omega | |
| have hd := BranchState.valid_depths (b.valid n (by omega)) | |
| have hc := (b.initialSegment n (by omega)).costs_le_potential hq hslack hpwide | |
| dsimp only [PolicyBranch.initialSegment] at hc | |
| have hz := hs.short_cost_zero hq (b.valid n (by omega)) hslack (by omega) | |
| have hf := potential_le_final_startND hN hL hA hQ hpwide hd.2 hn.1 | |
| (hfinal.1.trans hn.2) | |
| norm_num only [Nat.cast_mul,Nat.cast_ofNat] at hf | |
| rw [Finset.sum_range_succ,hz,add_zero] | |
| linear_combination hc+hf | |
| noncomputable def branchExponentND (A : ℕ → ℝ) (C lam sig eps : ℝ) | |
| (s : BranchState) (label : BranchLabel) (u : BranchState) : ℝ := | |
| -2*(A u.start-A s.start)+branchCost A s label u+ | |
| (if label = .low then 0 else C*(lam+sig))+eps | |
| lemma branch_exponent_sumND (A : ℕ → ℝ) (C lam sig eps : ℝ) | |
| (state : ℕ → BranchState) (label : ℕ → BranchLabel) (n : ℕ) : | |
| (∑ j ∈ Finset.range n, branchExponentND A C lam sig eps | |
| (state j) (label j) (state (j+1))) = | |
| 2*A (state 0).start-2*A (state n).start+ | |
| (∑ j ∈ Finset.range n, branchCost A (state j) (label j) (state (j+1)))+ | |
| (branchNonlowCount label n:ℝ)*(C*(lam+sig))+(n:ℝ)*eps := by | |
| simp only [branchExponentND,Finset.sum_add_distrib] | |
| rw [profile_increments_telescope A (fun j => (state j).start) n,branch_nonlow_loss_sum] | |
| simp [branchNonlowCount,PlanarFalconer.branchNonlowCount,branchCount,PlanarFalconer.branchCount] | |
| theorem source_branch_exponentND {A : ℕ → ℝ} {N n offset : ℕ} {lam sig kap eta L C : ℝ} | |
| (hN : 0 < N) (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) | |
| (heta : 0 < eta) (hL : 0 ≤ L) (hC : 0 ≤ C) | |
| (hceil : ⌈10*sig*(N:ℝ)⌉₊ < sourcePolicyBlock N kap) | |
| (hslack : sig*(N:ℝ) ≤ sourcePolicyBlock N kap) | |
| (hqratio : (sourcePolicyBlock N kap:ℝ)/(N:ℝ) ≤ 2*kap) | |
| (hA : ProfileLipschitzND A N L) | |
| (b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n) | |
| (hinit : (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish) : | |
| let eps := eta/(2*(1+20/kap+1/sig)) | |
| (∑ j ∈ Finset.range n, branchExponentND A C lam sig eps | |
| (b.state j) (b.label j) (b.state (j+1)))+ | |
| (200*L*(sourcePolicyBlock N kap:ℝ)/N+C*lam+eta/2) ≤ | |
| 2*A (b.state 0).start-potential A (b.state 0).start (b.state 0).finish | |
| (10*sourcePolicyBlock N kap)+500*L*kap+100*C*(lam+sig)/kap+eta := by | |
| dsimp only | |
| have hq := sourcePolicyBlock_pos hN hkap | |
| have hc := policy_costs_le_final_startND b hN hq hslack hL hA hinit | |
| have hb := source_branch_count_bounds hN hsig hkap hkap1 hceil b | |
| let D : ℝ := 1+20/kap+1/sig | |
| have hD : 0 < D := by dsimp [D]; positivity | |
| have heps : 0 ≤ eta/(2*D) := by positivity | |
| have htime : (n:ℝ)*(eta/(2*D)) ≤ eta/2 := by | |
| have hn : (n:ℝ) ≤ D := by dsimp [D]; linarith [hb.2.2] | |
| calc | |
| _ ≤ D*(eta/(2*D)) := mul_le_mul_of_nonneg_right hn heps | |
| _ = eta/2 := by field_simp | |
| have hloss : (branchNonlowCount b.label n:ℝ)*(C*(lam+sig)) ≤ 20*C*(lam+sig)/kap := by | |
| calc | |
| _ ≤ (20/kap)*(C*(lam+sig)) := mul_le_mul_of_nonneg_right hb.1 (by positivity) | |
| _ = _ := by ring | |
| have hlamK : C*lam ≤ C*(lam+sig)/kap := by | |
| apply (le_div_iff₀ hkap).mpr | |
| have hh := mul_le_mul_of_nonneg_left hkap1 (mul_nonneg hC hlam) | |
| have hcs := mul_nonneg hC hsig.le | |
| nlinarith | |
| have hbudget : 0 ≤ C*(lam+sig)/kap := by positivity | |
| have hwidth := mul_le_mul_of_nonneg_left hqratio (show 0 ≤ 220*L by positivity) | |
| have hLK : 0 ≤ L*kap := by positivity | |
| rw [branch_exponent_sumND] | |
| dsimp only [D] at htime | |
| simp only [mul_div_assoc] at hc hloss hlamK hbudget hwidth ⊢ | |
| nlinarith | |
| theorem uniform_source_branch_exponentND (offset : ℕ) {lam sig kap eta L C : ℝ} | |
| (hlam : 0 ≤ lam) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) | |
| (hgap : sig < kap/1000) (heta : 0 < eta) (hL : 0 ≤ L) (hC : 0 ≤ C) : | |
| ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ, | |
| ProfileLipschitzND A N L → ∀ n : ℕ, | |
| ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n, | |
| (b.state 0).start+10*sourcePolicyBlock N kap ≤ (b.state 0).finish → | |
| (∑ j ∈ Finset.range n, branchExponentND A C lam sig (eta/(2*(1+20/kap+1/sig))) | |
| (b.state j) (b.label j) (b.state (j+1)))+ | |
| (200*L*(sourcePolicyBlock N kap:ℝ)/N+C*lam+eta/2) ≤ | |
| 2*A (b.state 0).start-potential A (b.state 0).start (b.state 0).finish | |
| (10*sourcePolicyBlock N kap)+500*L*kap+100*C*(lam+sig)/kap+eta := by | |
| obtain ⟨N₁,hN₁,h₁⟩ := uniform_source_ceiling_slack hsig hgap | |
| obtain ⟨N₂,hN₂⟩ := exists_nat_gt (1/kap) | |
| refine ⟨max N₁ N₂,by omega,?_⟩ | |
| intro N hN A hA n b hi | |
| have hNp : 0 < N := by omega | |
| have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hNp | |
| have hkn : 1 < kap*(N:ℝ) := by | |
| have hh := (div_lt_iff₀ hkap).mp (hN₂.trans_le (Nat.cast_le.mpr (show N₂ ≤ N by omega))) | |
| linarith | |
| have hq : (sourcePolicyBlock N kap:ℝ) < kap*N+1 := | |
| Nat.ceil_lt_add_one (mul_nonneg hkap.le hNR.le) | |
| have hqr : (sourcePolicyBlock N kap:ℝ)/(N:ℝ) ≤ 2*kap := | |
| (div_le_iff₀ hNR).mpr (by linarith) | |
| exact source_branch_exponentND hNp hlam hsig hkap hkap1 heta hL hC | |
| (h₁ N (by omega)).1 (h₁ N (by omega)).2.2 hqr hA b hi | |
| end CurrentFalconer.DimensionalPolicy | |
| end GraphLiteralSupport | |
| end | |
| end | |
| section | |
| section | |
| open Set MeasureTheory | |
| open scoped ComplexConjugate RealInnerProductSpace | |
| namespace GraphLiteralSupport | |
| namespace CurrentFalconer.DimensionalPolicy | |
| open PlanarFalconer | |
| theorem BranchStep.strict_progress {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} | |
| (hN : 0 < N) (hq : 0 < q) (hsig : 0 < sig) | |
| {s u : BranchState} {label : BranchLabel} | |
| (h : BranchStep A N q offset sig s label u) (hv : s.Valid N sig) : | |
| s.start < u.start ∨ u.finish < s.finish := by | |
| cases h with | |
| | suffix hw hs => | |
| have hp := policyDepth_interior A hq (policyBlocks_nonempty hq hv.2 hw) | |
| right | |
| dsimp [BranchState.finish] | |
| omega | |
| | @low a t i v hw hm hg => | |
| right | |
| have hpos : 0 < sig*(N:ℝ) := mul_pos hsig (Nat.cast_pos.mpr hN) | |
| dsimp [BranchState.finish] | |
| exact_mod_cast (show (v : ℝ) < t by linarith [hg]) | |
| | high hw hs hm hg => | |
| have hp := policyDepth_interior A hq (policyBlocks_nonempty hq hv.2 hw) | |
| left | |
| dsimp [BranchState.start] | |
| omega | |
| | near hw hs => exact Or.inl hs | |
| | far hw hs hm => | |
| left | |
| have hh := (Finset.mem_Icc.mp hm).1 | |
| dsimp [BranchState.start] | |
| omega | |
| | direct hw hd => exact Or.inl hd.anchor_gt | |
| theorem BranchStep.width_decreases {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} | |
| (hN : 0 < N) (hq : 0 < q) (hsig : 0 < sig) | |
| {s u : BranchState} {label : BranchLabel} | |
| (h : BranchStep A N q offset sig s label u) (hv : s.Valid N sig) | |
| (hu : u.Valid N sig) : | |
| u.finish-u.start < s.finish-s.start := by | |
| have hn := h.nested hq hv | |
| have hp := h.strict_progress hN hq hsig hv | |
| have hd := BranchState.valid_depths hu | |
| omega | |
| theorem valid_step_wellFounded (A : ℕ → ℝ) {N q offset : ℕ} {sig : ℝ} | |
| (hN : 0 < N) (hq : 0 < q) (hsig : 0 < sig) : | |
| WellFounded (fun (u s : {s : BranchState // s.Valid N sig}) => | |
| ∃ label, BranchStep A N q offset sig s.1 label u.1) := by | |
| apply Subrelation.wf (r := (measure fun (s : {s : BranchState // s.Valid N sig}) => | |
| s.1.finish-s.1.start).rel) ?_ (measure _).wf | |
| intro u s h | |
| obtain ⟨label,hh⟩ := h | |
| exact hh.width_decreases hN hq hsig s.2 u.2 | |
| theorem nonterminal_has_step (A : ℕ → ℝ) {N q offset : ℕ} {sig : ℝ} | |
| (hN : 0 < N) (hq : 0 < q) (hsig : 0 < sig) | |
| (hceil : ⌈10*sig*(N:ℝ)⌉₊ < q) | |
| (hslack : sig*(N:ℝ) ≤ q) (hslack10 : 10*sig*(N:ℝ) ≤ q) | |
| (s : BranchState) (hv : s.Valid N sig) (hw : s.start+100*q < s.finish) : | |
| ∃ label u, BranchStep A N q offset sig s label u := by | |
| cases s with | |
| | D a t i => | |
| by_cases hs : a+t < 2*policyDepth A N q a t | |
| · exact ⟨.suffix,_,.suffix hw hs⟩ | |
| · refine ⟨.high,_,.high (v := t) hw (by omega) ?_ ?_⟩ | |
| · exact Finset.mem_Ioc.mpr ⟨by change a+100*q<t at hw; omega,le_rfl⟩ | |
| · have hh : 0 < sig*(N:ℝ) := mul_pos hsig (Nat.cast_pos.mpr hN) | |
| simpa only [sub_self] using hh | |
| | H a₀ t₀ a t i => | |
| by_cases hh : a < (BranchState.H a₀ t₀ a t i).nearDepth A N q sig | |
| · exact ⟨.near,_,.near hw hh⟩ | |
| · have hdir : t-2*sourceFarBuffer N | |
| ((remainingPolicyDescriptors A N q a₀ t₀ a).sup descriptorLength) sig ≤ a := by | |
| simpa only [BranchState.nearDepth,BranchState.finish,BranchState.descriptors] using | |
| (not_lt.mp hh) | |
| obtain ⟨e,he⟩ := actual_direct_policy_witness A hsig.le hq hceil hslack hslack10 | |
| hv.2.2.2.2 hw hdir | |
| exact ⟨.direct,_,.direct hw he⟩ | |
| namespace PolicyBranch | |
| def prepend {A : ℕ → ℝ} {N q offset n : ℕ} {sig : ℝ} | |
| (b : PolicyBranch A N q offset sig n) (s : BranchState) (label : BranchLabel) | |
| (hs : s.Valid N sig) (hstep : BranchStep A N q offset sig s label (b.state 0)) : | |
| PolicyBranch A N q offset sig (n+1) where | |
| state := fun j => match j with | 0 => s | k+1 => b.state k | |
| label := fun j => match j with | 0 => label | k+1 => b.label k | |
| valid := by | |
| intro j hj | |
| cases j with | |
| | zero => exact hs | |
| | succ k => exact b.valid k (by omega) | |
| step := by | |
| intro j hj | |
| cases j with | |
| | zero => exact hstep | |
| | succ k => exact b.step k (by omega) | |
| end PolicyBranch | |
| theorem exists_terminal_branch (A : ℕ → ℝ) {N q offset : ℕ} {sig : ℝ} | |
| (hN : 0 < N) (hq : 0 < q) (hsig : 0 < sig) | |
| (hceil : ⌈10*sig*(N:ℝ)⌉₊ < q) | |
| (hslack : sig*(N:ℝ) ≤ q) (hslack10 : 10*sig*(N:ℝ) ≤ q) | |
| (hbuffer : ∀ L t a : ℕ, a < t-2*sourceFarBuffer N L sig → | |
| t-2*sourceFarBuffer N L sig+offset < t) | |
| (s : BranchState) (hs : s.Valid N sig) : | |
| ∃ n, ∃ b : PolicyBranch A N q offset sig n, | |
| b.state 0 = s ∧ (b.state n).finish ≤ (b.state n).start+100*q := by | |
| have wf := valid_step_wellFounded A (offset := offset) hN hq hsig | |
| suffices hh : ∀ x : {s : BranchState // s.Valid N sig}, | |
| ∃ n, ∃ b : PolicyBranch A N q offset sig n, | |
| b.state 0 = x.1 ∧ (b.state n).finish ≤ (b.state n).start+100*q from hh ⟨s,hs⟩ | |
| intro x | |
| induction x using wf.induction with | |
| | h x ih => | |
| by_cases hw : x.1.start+100*q < x.1.finish | |
| · obtain ⟨label,u,hu⟩ := nonterminal_has_step A hN hq hsig hceil hslack hslack10 x.1 x.2 hw | |
| have huv := hu.valid_successor hq hslack hbuffer x.2 | |
| obtain ⟨n,b,hb,ht⟩ := ih ⟨u,huv⟩ ⟨label,hu⟩ | |
| have hh : BranchStep A N q offset sig x.1 label (b.state 0) := by rw [hb]; exact hu | |
| exact ⟨n+1,b.prepend x.1 label x.2 hh,rfl,ht⟩ | |
| · let b : PolicyBranch A N q offset sig 0 := | |
| ⟨fun _ => x.1,fun _ => .near,fun _ _ => x.2,fun j hj => (Nat.not_lt_zero j hj).elim⟩ | |
| exact ⟨0,b,rfl,not_lt.mp hw⟩ | |
| theorem uniform_terminal_branch (offset : ℕ) {sig kap : ℝ} | |
| (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) (hgap : sig < kap/1000) : | |
| ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ, ∀ s : BranchState, | |
| s.Valid N sig → s.index = 0 → | |
| ∃ n, ∃ b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n, | |
| b.state 0 = s ∧ (b.state n).finish ≤ (b.state n).start+100*sourcePolicyBlock N kap ∧ | |
| (branchNonlowCount b.label n:ℝ) ≤ 20/kap ∧ | |
| (branchCount b.label n .low:ℝ) ≤ 1/sig ∧ (n:ℝ) ≤ 20/kap+1/sig ∧ | |
| ∀ j ≤ n, (b.state j).index+1 < sourceSmoothingLevels sig kap := by | |
| obtain ⟨N₁,hN₁,h₁⟩ := uniform_source_ceiling_slack hsig hgap | |
| obtain ⟨N₂,h₂⟩ := uniform_far_offset_buffer hsig offset | |
| refine ⟨max N₁ N₂,by omega,?_⟩ | |
| intro N hN A s hs hi | |
| have hNp : 0 < N := by omega | |
| have hq := sourcePolicyBlock_pos hNp hkap | |
| obtain ⟨hc,hs10,hsl⟩ := h₁ N (by omega) | |
| obtain ⟨n,b,hb,ht⟩ := exists_terminal_branch A hNp hq hsig hc hsl hs10 | |
| (h₂ N (by omega)) s hs | |
| have hcounts := source_branch_count_bounds hNp hsig hkap hkap1 hc b | |
| refine ⟨n,b,hb,ht,hcounts.1,hcounts.2.1,hcounts.2.2,?_⟩ | |
| intro j hj | |
| exact (source_branch_index_bound hNp hsig hkap hkap1 hc b (by rw [hb]; exact hi) hj).2 | |
| end CurrentFalconer.DimensionalPolicy | |
| end GraphLiteralSupport | |
| end | |
| end | |
| end OAI | |