| import OAI.Analysis.DiamondDistortion.InfimalCost |
|
|
| namespace OAI |
|
|
| universe u v |
|
|
| noncomputable section |
| open scoped BigOperators Classical Topology |
| open Set |
|
|
| namespace DiamondDistortion |
|
|
| open scoped ENNReal |
|
|
| namespace PathModel |
| open RecursiveModel |
| abbrev L1 (h : ℕ) := lp (fun _ : Coord h => ℝ) 1 |
| abbrev L2 (h : ℕ) := lp (fun _ : Coord h => ℝ) 2 |
|
|
| def branch (h : ℕ) (s : Coord h) : L2 h := ∑ r ∈ ancestors h s,lp.single 2 r (1:ℝ) |
| @[simp] lemma branch_apply (h : ℕ) (s r : Coord h) : |
| branch h s r=if r ∈ ancestors h s then 1 else 0 := by |
| change (lp.evalₗ (𝕜 := ℝ) (fun _ : Coord h => ℝ) 2 r) (branch h s)=_ |
| rw [branch,map_sum] |
| simp only [lp.evalₗ_apply,lp.single_apply,Finset.sum_pi_single] |
| lemma ancestors_card (h : ℕ) (s : Coord h) : (ancestors h s).card ≤ h+1 := by |
| induction h with |
| | zero => simp [ancestors] |
| | succ h ih => |
| cases s with |
| | inl u => simp [ancestors] |
| | inr a => |
| calc |
| _ ≤ ((ancestors h a.2).image (fun t => Sum.inr (a.1,t))).card+1 := Finset.card_insert_le _ _ |
| _ ≤ (ancestors h a.2).card+1 := Nat.add_le_add_right (Finset.card_image_le) _ |
| _ ≤ _ := by have := ih a.2; omega |
| lemma branch_norm (h : ℕ) (s : Coord h) : ‖branch h s‖ ≤ (h+1:ℝ) := by |
| calc |
| _ ≤ ∑ r ∈ ancestors h s,‖(lp.single 2 r (1:ℝ) : L2 h)‖ := by |
| unfold branch |
| exact norm_sum_le (ancestors h s) (fun r => (lp.single 2 r (1:ℝ) : L2 h)) |
| _ = ((ancestors h s).card:ℝ) := by |
| simp only [lp.norm_single (by norm_num : (0:ℝ≥0∞) < 2),norm_one,Finset.sum_const, nsmul_eq_mul,mul_one] |
| _ ≤ _ := by exact_mod_cast ancestors_card h s |
|
|
| lemma summable_abs {h : ℕ} (μ : L1 h) : Summable (fun s => |μ s|) := by |
| simpa only [ENNReal.toReal_one,Real.rpow_one,Real.norm_eq_abs] using (lp.memℓp μ).summable (by norm_num : 0 < (1:ℝ≥0∞).toReal) |
| lemma tsum_abs {h : ℕ} (μ : L1 h) : ∑' s,|μ s|=‖μ‖ := by |
| simpa only [ENNReal.toReal_one,Real.rpow_one,Real.norm_eq_abs,one_div_one] using (lp.norm_eq_tsum_rpow (by norm_num : 0 < (1:ℝ≥0∞).toReal) μ).symm |
| lemma path_summable_norm {h : ℕ} (μ : L1 h) : Summable (fun s => ‖μ s • branch h s‖) := by |
| apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ ((summable_abs μ).mul_right (h+1:ℝ)) |
| intro s |
| rw [norm_smul,Real.norm_eq_abs] |
| exact mul_le_mul_of_nonneg_left (branch_norm h s) (abs_nonneg _) |
| lemma path_summable {h : ℕ} (μ : L1 h) : Summable (fun s => μ s • branch h s) := |
| (path_summable_norm μ).of_norm |
|
|
| def path (h : ℕ) : L1 h →L[ℝ] L2 h := |
| LinearMap.mkContinuous { |
| toFun μ := ∑' s,μ s • branch h s |
| map_add' μ ν := by |
| simp only [lp.coeFn_add,Pi.add_apply,add_smul] |
| exact (path_summable μ).tsum_add (path_summable ν) |
| map_smul' c μ := by |
| simp only [lp.coeFn_smul,Pi.smul_apply,smul_eq_mul,mul_smul] |
| exact (path_summable μ).tsum_const_smul c } |
| (h+1:ℝ) (by |
| intro μ |
| calc |
| _ ≤ ∑' s,‖μ s • branch h s‖ := norm_tsum_le_tsum_norm (path_summable_norm μ) |
| _ ≤ ∑' s,|μ s| * (h+1:ℝ) := (path_summable_norm μ).tsum_le_tsum (fun s => by |
| rw [norm_smul,Real.norm_eq_abs]; exact mul_le_mul_of_nonneg_left (branch_norm h s) (abs_nonneg _)) ((summable_abs μ).mul_right _) |
| _ = _ := by rw [tsum_mul_right,tsum_abs]; ring) |
| lemma path_apply (h : ℕ) (μ : L1 h) (r : Coord h) : |
| path h μ r=∑' s,if r ∈ ancestors h s then μ s else 0 := by |
| change (lp.evalCLM ℝ (fun _ : Coord h => ℝ) 2 r) (∑' s,μ s • branch h s)=_ |
| rw [ContinuousLinearMap.map_tsum _ (path_summable μ)] |
| simp only [map_smul,lp.evalCLM,LinearMap.mkContinuous_apply,lp.evalₗ_apply,branch_apply,smul_eq_mul,mul_ite,mul_one,mul_zero] |
| lemma path_coordinate (h : ℕ) (μ : L1 h) (r : Coord h) : |path h μ r| ≤ ‖μ‖ := by |
| let ev := lp.evalCLM ℝ (fun _ : Coord h => ℝ) 2 r |
| have hs : Summable (fun s => ev (μ s • branch h s)) := ev.summable (path_summable μ) |
| have hsn : Summable (fun s => ‖ev (μ s • branch h s)‖) := by |
| apply Summable.of_nonneg_of_le (fun _ => norm_nonneg _) _ (summable_abs μ) |
| intro s |
| change |μ s * branch h s r| ≤ |μ s| |
| rw [branch_apply] |
| split_ifs <;> simp |
| have he : |path h μ r|=‖∑' s,ev (μ s • branch h s)‖ := by |
| rw [← ContinuousLinearMap.map_tsum ev (path_summable μ)] |
| rfl |
| rw [he] |
| calc |
| _ ≤ ∑' s,‖ev (μ s • branch h s)‖ := norm_tsum_le_tsum_norm hsn |
| _ ≤ ∑' s,|μ s| := hsn.tsum_le_tsum (fun s => by |
| change |μ s * branch h s r| ≤ |μ s| |
| rw [branch_apply]; split_ifs <;> simp) (summable_abs μ) |
| _ = _ := tsum_abs μ |
|
|
| /-- The admissible decompositions use full ℓ² and ℓ¹, and the norm on their |
| pair is exactly the linear (q=1) or quadratic (q=2) representation cost. -/ |
| def presentation (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) : |
| InfimalCost.Presentation (WithLp q (L2 h × L1 h)) (L2 h) where |
| output := { |
| toFun d := d.fst+path h d.snd |
| map_add' d e := by simp only [WithLp.add_fst,WithLp.add_snd,map_add]; abel |
| map_smul' c d := by simp only [WithLp.smul_fst,WithLp.smul_snd,map_smul,smul_add,RingHom.id_apply] } |
| sectionMap := { |
| toFun v := WithLp.toLp q (v,0) |
| map_add' v w := by |
| apply WithLp.ofLp_injective q |
| simp only [WithLp.ofLp_add,Prod.mk_add_mk,add_zero] |
| map_smul' c v := by |
| apply WithLp.ofLp_injective q |
| simp only [WithLp.ofLp_smul,RingHom.id_apply,Prod.smul_mk,smul_zero] } |
| right_inverse v := by simp |
| @[simp] lemma presentation_output (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) |
| (d : WithLp q (L2 h × L1 h)) : (presentation q h).output d=d.fst+path h d.snd := rfl |
| @[simp] lemma presentation_section (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) (v : L2 h) : |
| (presentation q h).sectionMap v=WithLp.toLp q (v,0) := rfl |
|
|
| /-- Literal infimum over all decompositions z=h+Jμ. -/ |
| def cost (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) : Seminorm ℝ (L2 h) := (presentation q h).seminorm |
| lemma linear_cost_formula (h : ℕ) (v : L2 h) : |
| cost 1 h v=sInf {r : ℝ | ∃ w : L2 h,∃ μ : L1 h,w+path h μ=v ∧ ‖w‖+‖μ‖=r} := by |
| rw [cost,(presentation 1 h).eq_sInf] |
| congr 1 |
| ext r |
| constructor |
| · rintro ⟨d,hd,hr⟩ |
| exact ⟨d.fst,d.snd,hd,(WithLp.prod_norm_eq_of_L1 d).symm.trans hr⟩ |
| · rintro ⟨w,μ,hd,hr⟩ |
| exact ⟨WithLp.toLp 1 (w,μ),hd,(WithLp.prod_norm_eq_of_L1 _).trans hr⟩ |
| lemma quadratic_cost_formula (h : ℕ) (v : L2 h) : |
| cost 2 h v=sInf {r : ℝ | ∃ w : L2 h,∃ μ : L1 h,w+path h μ=v ∧ Real.sqrt (‖w‖^2+‖μ‖^2)=r} := by |
| rw [cost,(presentation 2 h).eq_sInf] |
| congr 1 |
| ext r |
| constructor |
| · rintro ⟨d,hd,hr⟩ |
| exact ⟨d.fst,d.snd,hd,(WithLp.prod_norm_eq_of_L2 d).symm.trans hr⟩ |
| · rintro ⟨w,μ,hd,hr⟩ |
| exact ⟨WithLp.toLp 2 (w,μ),hd,(WithLp.prod_norm_eq_of_L2 _).trans hr⟩ |
|
|
| lemma representation_coordinate (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) |
| (d : WithLp q (L2 h × L1 h)) (r : Coord h) : |
| |(presentation q h).output d r| ≤ ‖d.fst‖+‖d.snd‖ := by |
| change |d.fst r+path h d.snd r| ≤ _ |
| exact (abs_add_le _ _).trans (add_le_add |
| (by simpa only [Real.norm_eq_abs] using lp.norm_apply_le_norm (by norm_num : (2:ℝ≥0∞) ≠ 0) d.fst r) |
| (path_coordinate h d.snd r)) |
| lemma linear_coordinate (h : ℕ) (v : L2 h) (r : Coord h) : |v r| ≤ cost 1 h v := by |
| have hh := (presentation 1 h).bound v (by norm_num : (0:ℝ) ≤ 1) (b := |v r|) (by |
| intro d hd |
| rw [← hd,one_mul,WithLp.prod_norm_eq_of_L1] |
| exact representation_coordinate 1 h d r) |
| simpa only [one_mul,cost] using hh |
| lemma quadratic_coordinate (h : ℕ) (v : L2 h) (r : Coord h) : |v r| ≤ Real.sqrt 2*cost 2 h v := by |
| apply (presentation 2 h).bound v (Real.sqrt_nonneg 2) |
| intro d hd |
| rw [← hd] |
| apply (representation_coordinate 2 h d r).trans |
| have hs := WithLp.prod_norm_sq_eq_of_L2 d |
| have hs2 : (Real.sqrt 2)^2=2 := Real.sq_sqrt (by norm_num) |
| have hnn : 0 ≤ Real.sqrt 2*‖d‖ := mul_nonneg (Real.sqrt_nonneg _) (norm_nonneg _) |
| have hsq : (‖d.fst‖+‖d.snd‖)^2 ≤ (Real.sqrt 2*‖d‖)^2 := by |
| rw [mul_pow,hs2,hs] |
| nlinarith [sq_nonneg (‖d.fst‖-‖d.snd‖)] |
| exact (sq_le_sq₀ (by positivity) hnn).mp hsq |
|
|
| lemma linear_le_norm (h : ℕ) (v : L2 h) : cost 1 h v ≤ ‖v‖ := by |
| have hh := (presentation 1 h).le_representation ((presentation 1 h).right_inverse v) |
| simpa only [cost,presentation_section,WithLp.prod_norm_eq_of_L1,WithLp.fst,WithLp.snd,WithLp.ofLp_toLp,norm_zero,add_zero] using hh |
| lemma quadratic_le_norm (h : ℕ) (v : L2 h) : cost 2 h v ≤ ‖v‖ := by |
| have hh := (presentation 2 h).le_representation ((presentation 2 h).right_inverse v) |
| simpa only [cost,presentation_section,WithLp.prod_norm_eq_of_L2,WithLp.fst,WithLp.snd,WithLp.ofLp_toLp,norm_zero,zero_pow (by decide : 2 ≠ 0),add_zero,Real.sqrt_sq_eq_abs,abs_norm] using hh |
|
|
| /-- Coordinate finite vectors inherit the same exact full-representation infimum. -/ |
| def finiteEmbedding (h : ℕ) : Vec h →ₗ[ℝ] L2 h where |
| toFun := finiteLp 2 |
| map_add' := finiteLp_add 2 |
| map_smul' c v := finiteLp_smul 2 c v |
| def finiteCost (q : ℝ≥0∞) [Fact (1 ≤ q)] (h : ℕ) : Seminorm ℝ (Vec h) := |
| (cost q h).comp (finiteEmbedding h) |
|
|
| end PathModel |
|
|
| namespace RecursiveModel |
| open scoped ENNReal |
| /-- The literal outer ℓ² norm of a family of finite component seminorms. -/ |
| def outerValues (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v : ForestVec) : ℕ →₀ ℝ := |
| componentValues (fun h => ⟨s h,map_zero (s h)⟩) v |
| @[simp] lemma outerValues_apply (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v : ForestVec) (h : ℕ) : |
| outerValues s v h=s h (components v h) := rfl |
| @[simp] lemma outerValues_zero (s : ∀ h,Seminorm ℝ (Vec (h+1))) : outerValues s 0=0 := componentValues_zero _ |
| lemma outerValues_nonneg (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v : ForestVec) (h : ℕ) : |
| 0 ≤ outerValues s v h := apply_nonneg (s h) _ |
| lemma outerValues_add (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v w : ForestVec) (h : ℕ) : |
| outerValues s (v+w) h ≤ (outerValues s v+outerValues s w) h := by |
| simp only [outerValues_apply,map_add,DFinsupp.add_apply,Finsupp.add_apply] |
| exact map_add_le_add (s h) _ _ |
| lemma outerValues_neg (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v : ForestVec) : |
| outerValues s (-v)=outerValues s v := by |
| ext h |
| simp only [outerValues_apply,map_neg,DFinsupp.neg_apply,map_neg_eq_map] |
| lemma outerValues_smul (s : ∀ h,Seminorm ℝ (Vec (h+1))) (t : ℝ) (v : ForestVec) : |
| outerValues s (t • v)=|t| • outerValues s v := by |
| ext h |
| simp only [outerValues_apply,map_smul,DFinsupp.smul_apply,Finsupp.smul_apply,smul_eq_mul,map_smul_eq_mul,Real.norm_eq_abs] |
|
|
| def outerSeminorm (s : ∀ h,Seminorm ℝ (Vec (h+1))) : Seminorm ℝ ForestVec where |
| toFun v := aggregate 2 (outerValues s v) |
| map_zero' := by simp |
| add_le' v w := |
| (aggregate_mono 2 _ _ (outerValues_nonneg s _) (outerValues_add s _ _)).trans (aggregate_add 2 _ _) |
| neg' v := by rw [outerValues_neg] |
| smul' t v := by rw [outerValues_smul,aggregate_smul,abs_abs,Real.norm_eq_abs] |
| lemma component_le_outer (s : ∀ h,Seminorm ℝ (Vec (h+1))) (v : ForestVec) (h : ℕ) : |
| s h (components v h) ≤ outerSeminorm s v := by |
| exact (le_abs_self _).trans (coordinate_le_aggregate 2 (outerValues s v) h) |
| end RecursiveModel |
|
|
| namespace PathModel |
|
|
| section |
| open RecursiveModel |
|
|
| def linearForestSeminorm : Seminorm ℝ ForestVec := outerSeminorm (fun h => finiteCost 1 (h+1)) |
| def quadraticForestSeminorm : Seminorm ℝ ForestVec := outerSeminorm (fun h => finiteCost 2 (h+1)) |
| lemma linear_forest_coordinate (v : ForestVec) (i : ForestCoord) : |v i| ≤ linearForestSeminorm v := by |
| exact (linear_coordinate (i.1+1) (finiteEmbedding _ (components v i.1)) i.2).trans |
| (component_le_outer (fun h => finiteCost 1 (h+1)) v i.1) |
| lemma quadratic_forest_coordinate (v : ForestVec) (i : ForestCoord) : |
| |v i| ≤ Real.sqrt 2*quadraticForestSeminorm v := by |
| exact (quadratic_coordinate (i.1+1) (finiteEmbedding _ (components v i.1)) i.2).trans |
| (mul_le_mul_of_nonneg_left (component_le_outer (fun h => finiteCost 2 (h+1)) v i.1) (Real.sqrt_nonneg _)) |
|
|
| /-- Original component root; this is distinct from a forest component index. -/ |
| def root : (h : ℕ) → Coord h |
| | 0 => () |
| | _+1 => Sum.inl () |
| lemma root_ancestors (h : ℕ) : ancestors h (root h)={root h} := by cases h <;> rfl |
| lemma branch_root (h : ℕ) : branch h (root h)=lp.single 2 (root h) (1:ℝ) := by |
| simp only [branch,root_ancestors,Finset.sum_singleton] |
| lemma path_single (h : ℕ) [DecidableEq (Coord h)] (s : Coord h) (c : ℝ) : |
| path h (lp.single 1 s c)=c • branch h s := by |
| change ∑' t,((lp.single 1 s c : L1 h) t) • branch h t = _ |
| rw [tsum_eq_single s] |
| · rw [lp.single_apply_self] |
| · intro t ht |
| rw [lp.single_apply_ne (E := fun _ : Coord h => ℝ) 1 s c ht,zero_smul] |
| @[simp] lemma linear_root (h : ℕ) : cost 1 h (lp.single 2 (root h) (1:ℝ))=1 := by |
| apply le_antisymm |
| · exact (linear_le_norm h _).trans_eq (by rw [lp.norm_single (by norm_num : (0:ℝ≥0∞)<2),norm_one]) |
| · have hh := linear_coordinate h (lp.single 2 (root h) (1:ℝ)) (root h) |
| simpa only [lp.single_apply_self,abs_one] using hh |
| @[simp] lemma quadratic_root (h : ℕ) : cost 2 h (lp.single 2 (root h) (1:ℝ))=1/Real.sqrt 2 := by |
| have hs : 0 < Real.sqrt 2 := Real.sqrt_pos.mpr (by norm_num) |
| let e : L2 h := lp.single 2 (root h) 1 |
| let μ : L1 h := lp.single 1 (root h) 1 |
| have he : path h μ=e := by rw [path_single,one_smul,branch_root] |
| let d := WithLp.toLp 2 ((1/2:ℝ) • e,(1/2:ℝ) • μ) |
| have hd : (presentation 2 h).output d=e := by |
| change (1/2:ℝ) • e+path h ((1/2:ℝ) • μ)=e |
| rw [map_smul,he] |
| module |
| apply le_antisymm |
| · have hb := (presentation 2 h).le_representation hd |
| have hnorm : ‖d‖=1/Real.sqrt 2 := by |
| dsimp [d] |
| rw [WithLp.prod_norm_eq_of_L2] |
| change Real.sqrt (‖(1/2:ℝ) • e‖^2+‖(1/2:ℝ) • μ‖^2)=_ |
| simp only [norm_smul,Real.norm_eq_abs,e,μ,lp.norm_single (by norm_num : (0:ℝ≥0∞)<2),lp.norm_single (by norm_num : (0:ℝ≥0∞)<1),norm_one,mul_one] |
| norm_num |
| exact hb.trans_eq hnorm |
| · have hh := quadratic_coordinate h e (root h) |
| simp only [e,lp.single_apply_self,abs_one] at hh |
| exact (div_le_iff₀ hs).mpr (by simpa only [mul_comm] using hh) |
| end |
|
|
| open RecursiveModel PathApplications |
| /-- Exact path-cost completions on the original finite-height components. -/ |
| def linearData : CoordinateCompletion.Data ForestCoord where |
| seminorm := linearForestSeminorm |
| coordinate_bound i := ⟨1,fun v => by simpa only [one_mul] using linear_forest_coordinate v i⟩ |
| def quadraticData : CoordinateCompletion.Data ForestCoord where |
| seminorm := quadraticForestSeminorm |
| coordinate_bound i := ⟨Real.sqrt 2,fun v => quadratic_forest_coordinate v i⟩ |
| abbrev LinearSpace := linearData.Space |
| abbrev QuadraticSpace := quadraticData.Space |
| def linearHeads : Midpoint.Heads ForestHead LinearSpace := |
| linearData.heads Subtype.val (fun S => ⟨forestHead S,forestHead_contains S⟩) |
| def quadraticHeads : Midpoint.Heads ForestHead QuadraticSpace := |
| quadraticData.heads Subtype.val (fun S => ⟨forestHead S,forestHead_contains S⟩) |
| lemma linearHeads_commutes : linearHeads.Commutes := linearData.heads_commutes _ _ |
| lemma quadraticHeads_commutes : quadraticHeads.Commutes := quadraticData.heads_commutes _ _ |
|
|
| /-- Positive flow and trimming are retained as independent exact intrinsic inputs. -/ |
| theorem linear_flow_graph (hinput : FlowInput linearHeads (linearC^2)) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → LinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/(2*linearC^2) ≤ D^2 ∧ (k:ℝ) ≤ 2*linearC^2*D^2 := |
| linear_flow linearHeads hinput k f hf |
| theorem linear_trimming_graph (hinput : FlowInput linearHeads 242) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → LinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/484 ≤ D^2 := linear_trimming linearHeads hinput k f hf |
| theorem linear_clipping_graph (hinput : linearHeads.ParametricInput (1/2) 4) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → LinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)*clippingGamma D/(2*clippingQ D) ≤ D := |
| linear_clipping linearHeads hinput k f hf |
| theorem linear_vanishing_graph (hinput : linearHeads.TailVanishing) : |
| ¬ Diamond.UniformEmbeddings LinearSpace := linearHeads.vanishing_obstruction hinput |
| theorem linear_vanishing_weak (hinput : linearHeads.TailVanishing) {ε : ℝ} (hε : 0 < ε) : |
| ∃ ρ : ℝ,0 ≤ ρ ∧ ρ < 1 ∧ |
| ∀ (x : LinearSpace) (z : ℕ → LinearSpace),Midpoint.WeaklyNull z → (∀ i,ε ≤ ‖z i‖) → |
| (∀ i,‖x+z i‖ ≤ 1) → (∀ i,‖x-z i‖ ≤ 1) → ‖x‖ ≤ ρ := |
| linearHeads.vanishing_weak hinput hε |
|
|
| theorem quadratic_graph (hinput : ArbitraryTailInput quadraticHeads 8) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → QuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/64 ≤ D^2 := quadratic_cost quadraticHeads hinput k f hf |
| theorem stopped_graph (hinput : StoppedInput quadraticHeads) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → QuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| (k:ℝ) ≤ 144*D^2 := stopped_flow quadraticHeads hinput k f hf |
| theorem quadratic_component_graph (hinput : ComponentSumInput QuadraticSpace) |
| {D s e : ℝ} (he : 0 < e) (he16 : e ≤ 1/16) (hsmall : 17*(2*e)^((1:ℝ)/6) < 1/(2*D)) |
| (k : ℕ) (f : Diamond.Vertex k → QuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| (1+e/2)^k ≤ D := component_sum hinput he he16 hsmall k f hf |
| end PathModel |
|
|
| end DiamondDistortion |
|
|
| end |
|
|
| end OAI |
|
|
