| import OAI.MeasureTheory.Falconer.Shells.HighShellLeibnizSymbols | |
| namespace OAI | |
| namespace PlanarFalconer | |
| theorem pair_assignment_endpoint_budget (S : Finset PolicyDescriptor) (k : PairMaskIndex → ℕ) | |
| (K : ℕ) (hk : ∑ a ∈ pairMaskIndices S, k a ≤ K) (l : Fin 2) : | |
| ∑ b ∈ S, k (b,l) ≤ K := by | |
| apply le_trans _ hk | |
| change (∑ b ∈ S, k (b,l)) ≤ ∑ a ∈ S.product (Finset.univ : Finset (Fin 2)), k a | |
| rw [Finset.product_eq_sprod,Finset.sum_product S (Finset.univ : Finset (Fin 2)) k] | |
| apply Finset.sum_le_sum | |
| intro b hb | |
| exact Finset.single_le_sum (f := fun y : Fin 2 => k (b,y)) (fun _ _ => Nat.zero_le _) (Finset.mem_univ l) | |
| theorem minimal_assignment_scale (A : ℕ → ℝ) {N q a t j : ℕ} {sig v : ℝ} | |
| (hsig : 0 ≤ sig) (hq : 0 < q) (hqscale : sig*N ≤ (q:ℝ)) | |
| (hw : a+100*q < t) (hv : (t:ℝ)-sig*N ≤ v) | |
| {b : ℂ × (PairMaskIndex → ℕ)} | |
| (hb : b ∈ inverseLeibnizTerms j (pairMaskIndices (policyDescriptorList A N q a t))) : | |
| assignmentScale (policyDescriptorList A N q a t) N sig b.2 ≤ | |
| (2:ℝ)^((j:ℝ)*(v-a)) := by | |
| apply high_shell_extracted_scale _ Prod.fst b.2 hsig N a t j | |
| · intro c hc | |
| exact policyDescriptor_real_length A hq (Finset.mem_product.mp hc).1 | |
| · have hg := high_shell_gap hqscale hw hv | |
| have hn : 0 ≤ sig*(N:ℝ) := mul_nonneg hsig (Nat.cast_nonneg _) | |
| linarith | |
| · exact hv | |
| · exact inverseLeibnizTerms_budget j _ hb | |
| theorem minimal_assignment_scale_absorbed (A : ℕ → ℝ) {N q a t j : ℕ} {sig v : ℝ} | |
| (hsig : 0 ≤ sig) (hq : 0 < q) (hqscale : sig*N ≤ (q:ℝ)) | |
| (hw : a+100*q < t) (hv : (t:ℝ)-sig*N ≤ v) | |
| {b : ℂ × (PairMaskIndex → ℕ)} | |
| (hb : b ∈ inverseLeibnizTerms j (pairMaskIndices (policyDescriptorList A N q a t))) : | |
| 0 ≤ (2:ℝ)^(-(j:ℝ)*(v-a))*assignmentScale (policyDescriptorList A N q a t) N sig b.2 ∧ | |
| (2:ℝ)^(-(j:ℝ)*(v-a))*assignmentScale (policyDescriptorList A N q a t) N sig b.2 ≤ 1 := by | |
| have hpos : 0 ≤ assignmentScale (policyDescriptorList A N q a t) N sig b.2 := | |
| Finset.prod_nonneg (fun c _ => pow_nonneg (inv_nonneg.mpr (sourceAngularRadius_pos _ _ _).le) _) | |
| refine ⟨mul_nonneg (by positivity) hpos,?_⟩ | |
| apply (mul_le_mul_of_nonneg_left (minimal_assignment_scale A hsig hq hqscale hw hv hb) | |
| (by positivity : 0 ≤ (2:ℝ)^(-(j:ℝ)*(v-a)))).trans_eq | |
| rw [← Real.rpow_add (by norm_num : (0:ℝ) < 2)] | |
| convert Real.rpow_zero 2 using 2 | |
| ring | |
| theorem minimal_inverseLeibniz_cost (A : ℕ → ℝ) {N q a t : ℕ} (hq : 0 < q) (j : ℕ) : | |
| ((inverseLeibnizTerms j (pairMaskIndices (policyDescriptorList A N q a t))).map | |
| (fun b => ‖b.1‖)).sum ≤ | |
| (inverseStationaryExpr j).cost * (2*((N:ℝ)+1)^3)^(2*j) := by | |
| apply (inverseLeibnizTerms_cost j _).trans | |
| apply mul_le_mul_of_nonneg_left _ (inverseStationaryExpr j).cost_nonneg | |
| apply pow_le_pow_left₀ (by positivity) | |
| apply max_le | |
| · have hn : 0 ≤ (N:ℝ) := Nat.cast_nonneg N | |
| nlinarith [one_le_pow₀ (by linarith : (1:ℝ) ≤ (N:ℝ)+1) (n := 3)] | |
| · have hc : ((policyDescriptorList A N q a t).card:ℝ) ≤ ((N:ℝ)+1)^3 := by | |
| exact_mod_cast policyDescriptorList_card A hq | |
| change ((Finset.product (policyDescriptorList A N q a t) (Finset.univ : Finset (Fin 2))).card:ℝ) ≤ _ | |
| rw [Finset.product_eq_sprod,Finset.card_product (policyDescriptorList A N q a t) (Finset.univ : Finset (Fin 2))] | |
| simp only [Finset.card_univ,Fintype.card_fin,Nat.cast_mul,Nat.cast_ofNat] | |
| linarith | |
| end PlanarFalconer | |
| end OAI | |