| 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.ActualPolicyPayments |
| import OAI.MeasureTheory.Falconer.Recursion.BranchCounts |
| import OAI.MeasureTheory.Falconer.Recursion.BranchPotential |
| import OAI.MeasureTheory.Falconer.Recursion.BranchRepresentativeCharges |
| import OAI.MeasureTheory.Falconer.Recursion.BranchTransitions |
| import OAI.MeasureTheory.Falconer.Recursion.BranchValidity |
| import OAI.MeasureTheory.Falconer.Recursion.InteriorPolicy |
| import OAI.MeasureTheory.Falconer.Recursion.Ledger |
| import OAI.MeasureTheory.Falconer.Recursion.PolicyInteriorInterval |
| import OAI.MeasureTheory.Falconer.Recursion.Potential |
| import OAI.MeasureTheory.Falconer.Recursion.PrefixPolicyGeometry |
| import OAI.MeasureTheory.Falconer.Recursion.SourceBranchDepth |
| import OAI.MeasureTheory.FalconerCompletion.Estimates.InitialSegment |
|
|
| 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 |
|
|
| theorem high_depth_gap {N q t v : ℕ} {sig : ℝ} (hv : v ≤ t) |
| (hgap : (t:ℝ)-v < sig*N) (hslack : sig*(N:ℝ) ≤ q) : t-v ≤ q := by |
| have hcast : ((t-v:ℕ):ℝ) = (t:ℝ)-v := Nat.cast_sub hv |
| exact Nat.cast_le.mp (by rw [hcast]; exact hgap.le.trans hslack) |
|
|
| theorem BranchStep.valid_successor {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} |
| (hq : 0 < q) (hslack : sig*(N:ℝ) ≤ q) |
| (hbuffer : ∀ L t a : ℕ, a < t-2*sourceFarBuffer N L sig → |
| t-2*sourceFarBuffer N L sig+offset < t) |
| {s u : BranchState} {label : BranchLabel} |
| (h : BranchStep A N q offset sig s label u) (hv : s.Valid N sig) : u.Valid N sig := by |
| cases h with |
| | suffix hw _ => |
| have hp := policyDepth_interior A hq (policyBlocks_nonempty hq hv.2 hw) |
| dsimp only [BranchState.Valid] at * |
| omega |
| | low _ hm _ => |
| have hm := Finset.mem_Ioc.mp hm |
| dsimp only [BranchState.Valid] at * |
| omega |
| | high hw hs hm hg => |
| have hm := Finset.mem_Ioc.mp hm |
| have hgap := high_depth_gap hm.2 hg hslack |
| have hp := actual_prefix_policy_payment A hq hv.2 hw hs hm.2 hgap |
| have hi := policyDepth_interior A hq (policyBlocks_nonempty hq hv.2 hw) |
| exact ⟨by omega,by omega,hm.2,hv.2,by linarith⟩ |
| | near _ hs => |
| dsimp only [BranchState.Valid,BranchState.nearDepth,BranchState.finish,BranchState.descriptors] at * |
| exact ⟨by omega,Nat.sub_le _ _,hv.2.2⟩ |
| | far _ hs hm => |
| have hb := hbuffer _ _ _ hs |
| have hm := Finset.mem_Icc.mp hm |
| dsimp only [BranchState.Valid,BranchState.nearDepth,BranchState.finish,BranchState.descriptors] at * |
| exact ⟨by omega,by omega⟩ |
| | direct _ hw => |
| exact ⟨hv.1.trans hw.anchor_gt.le,hw.anchor_lt.le,hv.2.2⟩ |
|
|
| theorem uniform_branch_successor_validity (offset : ℕ) {sig kap : ℝ} |
| (hsig : 0 < sig) (hkap : 0 < kap) (hgap : sig < kap/1000) : |
| ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ, |
| ∀ s u : BranchState, ∀ label : BranchLabel, |
| s.Valid N sig → BranchStep A N (sourcePolicyBlock N kap) offset sig s label u → |
| u.Valid N sig ∧ s.start ≤ u.start ∧ u.finish ≤ s.finish := 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 u label hv h |
| have hq := sourcePolicyBlock_pos (by omega : 0 < N) hkap |
| have hb : ∀ L t a : ℕ, a < t-2*sourceFarBuffer N L sig → |
| t-2*sourceFarBuffer N L sig+offset < t := by |
| intro L t a ha |
| have hh := h₂ N (by omega) L t a ha |
| omega |
| exact ⟨h.valid_successor hq (h₁ N (by omega)).2.2 hb hv,h.nested hq hv⟩ |
|
|
| noncomputable def branchCost (A : ℕ → ℝ) (s : BranchState) : BranchLabel → BranchState → ℝ |
| | .suffix, u => A u.finish-intervalMin A u.finish s.finish |
| | .high, u | .direct, u => height A s.start u.start |
| | _, _ => 0 |
|
|
| theorem BranchStep.cost_nonneg {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} |
| {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q offset sig s label u) |
| (hq : 0 < q) (hv : s.Valid N sig) : 0 ≤ branchCost A s label u := by |
| have hn := h.nested hq hv |
| cases h <;> simp only [branchCost] |
| · exact sub_nonneg.mpr (intervalMin_le A le_rfl hn.2) |
| · exact le_rfl |
| · exact height_nonneg A hn.1 |
| · exact le_rfl |
| · exact le_rfl |
| · exact height_nonneg A hn.1 |
|
|
| theorem BranchStep.paid_width {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} |
| {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q offset sig s label u) |
| (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q) |
| (hc : label = .suffix ∨ label = .high ∨ label = .direct) : u.start+10*q ≤ u.finish := by |
| cases h with |
| | suffix hw hs => exact (actual_suffix_policy_payment A hq hv.2 hw hs).1 |
| | high hw hs hm hg => |
| have hm := Finset.mem_Ioc.mp hm |
| exact (actual_prefix_policy_payment A hq hv.2 hw hs hm.2 (high_depth_gap hm.2 hg hslack)).1 |
| | direct _ he => exact he.width |
| | _ => simp at hc |
|
|
| theorem BranchStep.potential_payment {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} |
| {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q offset sig s label u) |
| (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q) |
| (hu : u.start+10*q ≤ u.finish) : |
| potential A s.start s.finish (10*q)+branchCost A s label u ≤ |
| potential A u.start u.finish (10*q) := by |
| have hn := h.nested hq hv |
| have hm := potential_mono A (by omega : 0 < 10*q) hu hn.1 hn.2 |
| cases h with |
| | suffix hw hs => exact (actual_suffix_policy_payment A hq hv.2 hw hs).2 |
| | high hw hs hmem hg => |
| have hmem := Finset.mem_Ioc.mp hmem |
| exact (actual_prefix_policy_payment A hq hv.2 hw hs hmem.2 (high_depth_gap hmem.2 hg hslack)).2 |
| | direct _ he => exact he.payment |
| | _ => simpa only [branchCost,add_zero] using hm |
|
|
| theorem BranchStep.short_cost_zero {A : ℕ → ℝ} {N q offset : ℕ} {sig : ℝ} |
| {s u : BranchState} {label : BranchLabel} (h : BranchStep A N q offset sig s label u) |
| (hq : 0 < q) (hv : s.Valid N sig) (hslack : sig*(N:ℝ) ≤ q) |
| (hu : u.finish < u.start+10*q) : branchCost A s label u = 0 := by |
| have hc : ¬ (label = .suffix ∨ label = .high ∨ label = .direct) := by |
| intro hl |
| exact (not_le_of_gt hu) (h.paid_width hq hv hslack hl) |
| cases label <;> simp_all [branchCost] |
|
|
| def DiscreteProfileLipschitz (A : ℕ → ℝ) (N : ℕ) : Prop := |
| ∀ i ≤ N, ∀ j ≤ N, |A i-A j| ≤ |(i:ℝ)-j|/(N:ℝ) |
|
|
| theorem potential_le_final_start {A : ℕ → ℝ} {N a t f Q : ℕ} |
| (hN : 0 < N) (hA : DiscreteProfileLipschitz A N) |
| (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*(Q:ℝ)/N := by |
| have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN |
| have hb := potential_near_final A hQ hw haf hft (e := (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 hd hNR.le) |
| have hh' := (le_abs_self (A j-A f)).trans hh |
| linarith |
|
|
| end CurrentFalconer.DimensionalPolicy |
| end GraphLiteralSupport |
| end |
| end |
|
|
| section |
| section |
| open Set MeasureTheory |
| open scoped ComplexConjugate RealInnerProductSpace |
| namespace GraphLiteralSupport |
| namespace CurrentFalconer.DimensionalPolicy |
| open PlanarFalconer |
| namespace PolicyBranch |
| variable {A : ℕ → ℝ} {N q n offset : ℕ} {sig : ℝ} |
|
|
| theorem costs_le_potential (b : PolicyBranch A N q offset sig n) (hq : 0 < q) |
| (hslack : sig*(N:ℝ) ≤ q) (hfinal : (b.state n).start+10*q ≤ (b.state n).finish) : |
| ∑ j ∈ Finset.range n, branchCost A (b.state j) (b.label j) (b.state (j+1)) ≤ |
| potential A (b.state n).start (b.state n).finish (10*q)- |
| potential A (b.state 0).start (b.state 0).finish (10*q) := by |
| apply branch_cost_bound (fun j => potential A (b.state j).start (b.state j).finish (10*q)) |
| (fun j => branchCost A (b.state j) (b.label j) (b.state (j+1))) n |
| intro j hj |
| apply (b.step j hj).potential_payment hq (b.valid j hj.le) hslack |
| by_cases he : j+1 = n |
| · simpa only [he] using hfinal |
| · have hw := (b.step (j+1) (by omega)).nonterminal |
| omega |
|
|
| theorem costs_le_final_start (b : PolicyBranch A N q offset sig n) (hN : 0 < N) (hq : 0 < q) |
| (hslack : sig*(N:ℝ) ≤ q) (hA : DiscreteProfileLipschitz A N) |
| (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*(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_start hN 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 [initialSegment] at hc |
| have hz := hs.short_cost_zero hq (b.valid n (by omega)) hslack (by omega) |
| have hf := potential_le_final_start hN 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 |
|
|
| end PolicyBranch |
| end CurrentFalconer.DimensionalPolicy |
| end GraphLiteralSupport |
| end |
| end |
|
|
| section |
| section |
| open Set MeasureTheory |
| open scoped ComplexConjugate RealInnerProductSpace |
| namespace GraphLiteralSupport |
| namespace CurrentFalconer.DimensionalPolicy |
| open PlanarFalconer |
|
|
| def branchNonlowCount (label : ℕ → BranchLabel) (n : ℕ) : ℕ := |
| branchCount label n .high + branchCount label n .direct + branchCount label n .near + |
| branchCount label n .far + branchCount label n .suffix |
|
|
| theorem branch_count_total (label : ℕ → BranchLabel) (n : ℕ) : |
| branchNonlowCount label n + branchCount label n .low = n := by |
| induction n with |
| | zero => simp [branchNonlowCount,branchCount] |
| | succ n ih => |
| simp only [branchNonlowCount] at * |
| simp only [branchCount_succ] |
| cases h : label n <;> simp <;> omega |
|
|
| theorem source_branch_count_bounds {A : ℕ → ℝ} {N n offset : ℕ} {sig kap : ℝ} |
| (hN : 0 < N) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) |
| (hceil : ⌈10*sig*(N:ℝ)⌉₊ < sourcePolicyBlock N kap) |
| (b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n) : |
| (branchNonlowCount b.label n:ℝ) ≤ 20/kap ∧ |
| (branchCount b.label n .low:ℝ) ≤ 1/sig ∧ (n:ℝ) ≤ 20/kap+1/sig := by |
| have hq := sourcePolicyBlock_pos hN hkap |
| have hNR : (0:ℝ) < N := Nat.cast_pos.mpr hN |
| have hstart := BranchState.valid_depths (b.valid 0 (Nat.zero_le _)) |
| have hS := b.suffix_total_decrease hq |
| have hSR : (branchCount b.label n .suffix:ℝ)*(sourcePolicyBlock N kap:ℝ) ≤ N := by |
| exact_mod_cast (show branchCount b.label n .suffix*sourcePolicyBlock N kap ≤ N by omega) |
| have hblock := source_policy_block_lower N kap |
| have hSb := mul_le_mul_of_nonneg_left hblock (Nat.cast_nonneg (branchCount b.label n .suffix)) |
| have hSbound : (branchCount b.label n .suffix:ℝ) ≤ 1/kap := by |
| apply (le_div_iff₀ hkap).mpr |
| apply (mul_le_mul_iff_left₀ hNR).mp |
| nlinarith [hSb.trans hSR] |
| have hL := b.low_total_decrease hq |
| have hLR : ((b.state 0).finish:ℝ) ≤ N := Nat.cast_le.mpr hstart.2 |
| have hLbound : (branchCount b.label n .low:ℝ) ≤ 1/sig := by |
| apply (le_div_iff₀ hsig).mpr |
| apply (mul_le_mul_iff_left₀ hNR).mp |
| nlinarith [show (0:ℝ) ≤ (b.state n).finish from Nat.cast_nonneg _] |
| have hG := (b.representative_counts hq).1 |
| have hK := b.near_count hq hceil |
| have hF := b.far_count |
| have hB := source_representatives_real_bound A hN hkap hkap1 |
| have hnonlow : branchNonlowCount b.label n ≤ |
| 2*(policyRepresentatives A N (sourcePolicyBlock N kap)).card + branchCount b.label n .suffix+2 := by |
| dsimp only [branchNonlowCount] |
| omega |
| have hnonlowR : (branchNonlowCount b.label n:ℝ) ≤ |
| 2*((policyRepresentatives A N (sourcePolicyBlock N kap)).card:ℝ) + |
| (branchCount b.label n .suffix:ℝ)+2 := by exact_mod_cast hnonlow |
| have hone : 1 ≤ 1/kap := (le_div_iff₀ hkap).mpr (by simpa using hkap1) |
| have hbound : (branchNonlowCount b.label n:ℝ) ≤ 20/kap := by |
| have he : 20/kap = 20*(1/kap) := by ring |
| have he2 : 2/kap = 2*(1/kap) := by ring |
| rw [he2] at hB |
| rw [he] |
| linarith |
| refine ⟨hbound,hLbound,?_⟩ |
| have ht : (branchNonlowCount b.label n:ℝ)+(branchCount b.label n .low:ℝ) = n := by |
| exact_mod_cast branch_count_total b.label n |
| linarith |
|
|
| theorem source_smoothing_reserve {sig kap : ℝ} (hsig : 0 < sig) (hkap : 0 < kap) : |
| 1+20/kap+1/sig < (sourceSmoothingLevels sig kap:ℝ) := by |
| have hceil : 100*(1/sig+1/kap)+100 ≤ (sourceSmoothingLevels sig kap:ℝ) := Nat.le_ceil _ |
| have he : 20/kap = 20*(1/kap) := by ring |
| rw [he] |
| have hk : 0 < 1/kap := by positivity |
| have hs : 0 < 1/sig := by positivity |
| linarith |
|
|
| theorem source_branch_index_bound {A : ℕ → ℝ} {N n offset : ℕ} {sig kap : ℝ} |
| (hN : 0 < N) (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) |
| (hceil : ⌈10*sig*(N:ℝ)⌉₊ < sourcePolicyBlock N kap) |
| (b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n) (hi : (b.state 0).index = 0) |
| {j : ℕ} (hj : j ≤ n) : |
| ((b.state j).index:ℝ)+1 ≤ 1+20/kap+1/sig ∧ (b.state j).index+1 < sourceSmoothingLevels sig kap := by |
| let c := b.initialSegment j hj |
| have hc := source_branch_count_bounds hN hsig hkap hkap1 hceil c |
| have hind := c.index_identity |
| change (b.state j).index = (b.state 0).index + branchCount b.label j .suffix + |
| branchCount b.label j .low + branchCount b.label j .far at hind |
| rw [hi] at hind |
| have hn : (b.state j).index ≤ branchNonlowCount b.label j + branchCount b.label j .low := by |
| dsimp only [branchNonlowCount] |
| omega |
| have hnR : ((b.state j).index:ℝ) ≤ (branchNonlowCount b.label j:ℝ)+(branchCount b.label j .low:ℝ) := by |
| exact_mod_cast hn |
| change (branchNonlowCount b.label j:ℝ) ≤ _ ∧ (branchCount b.label j .low:ℝ) ≤ _ ∧ _ at hc |
| have hb : ((b.state j).index:ℝ)+1 ≤ 1+20/kap+1/sig := by linarith [hc.1,hc.2.1] |
| refine ⟨hb,?_⟩ |
| have hh := hb.trans_lt (source_smoothing_reserve hsig hkap) |
| exact_mod_cast hh |
|
|
| theorem uniform_source_branch_depth (offset : ℕ) {sig kap : ℝ} |
| (hsig : 0 < sig) (hkap : 0 < kap) (hkap1 : kap ≤ 1) (hgap : sig < kap/1000) : |
| ∃ N₀ : ℕ, 0 < N₀ ∧ ∀ N ≥ N₀, ∀ A : ℕ → ℝ, ∀ n : ℕ, |
| ∀ b : PolicyBranch A N (sourcePolicyBlock N kap) offset sig n, |
| (b.state 0).index = 0 → |
| (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 ≤ 1+20/kap+1/sig ∧ |
| (b.state j).index+1 < sourceSmoothingLevels sig kap := by |
| obtain ⟨N₀,hN₀,h₀⟩ := uniform_source_ceiling_slack hsig hgap |
| refine ⟨N₀,hN₀,?_⟩ |
| intro N hN A n b hi |
| have hNp : 0 < N := hN₀.trans_le hN |
| have hc := source_branch_count_bounds hNp hsig hkap hkap1 (h₀ N hN).1 b |
| exact ⟨hc.1,hc.2.1,hc.2.2,fun j hj => source_branch_index_bound |
| hNp hsig hkap hkap1 (h₀ N hN).1 b hi hj⟩ |
|
|
| end CurrentFalconer.DimensionalPolicy |
| end GraphLiteralSupport |
| end |
| end |
|
|
| end OAI |
|
|
