| import OAI.Analysis.DiamondDistortion.Descent |
|
|
| namespace OAI |
|
|
| universe u v |
|
|
| noncomputable section |
| open scoped BigOperators Classical Topology |
| open Set |
|
|
| namespace DiamondDistortion |
|
|
| open scoped ENNReal |
|
|
| namespace StartModel |
|
|
| section |
| open RecursiveModel PathModel |
| instance repComplete (h : ℕ) : CompleteSpace (Rep h) := by |
| induction h with |
| | zero => infer_instance |
| | succ h ih => |
| change CompleteSpace (WithLp 1 (L1 (h+1) × lp (fun _ : ℕ => Rep h) 2)) |
| infer_instance |
| |
| def outputCoordinate (h : ℕ) (r : Coord h) : Rep h →L[ℝ] ℝ := |
| ((LinearMap.proj r).comp (output h)).mkContinuous 1 (by |
| intro d |
| change ‖output h d r‖ ≤ 1*‖d‖ |
| simpa only [Real.norm_eq_abs,one_mul] using output_coordinate h d r) |
| def outputContinuous (h : ℕ) : Rep h →L[ℝ] (Coord h → ℝ) := |
| ContinuousLinearMap.pi (outputCoordinate h) |
| instance kernelClosed (h : ℕ) : IsClosed (LinearMap.ker (output h) : Set (Rep h)) := |
| (outputContinuous h).isClosed_ker |
| |
| / |
| modulo representations with zero output. -/ |
| abbrev FullComponent (h : ℕ) := Rep h ⧸ LinearMap.ker (output h) |
| instance fullComponentNormed (h : ℕ) : NormedAddCommGroup (FullComponent h) := by |
| letI : IsClosed (LinearMap.ker (output h) : Set (Rep h)) := kernelClosed h |
| exact Submodule.Quotient.normedAddCommGroup _ |
| |
| instance fullComponentNormedSucc (h : ℕ) : NormedAddCommGroup (FullComponent (h+1)) := fullComponentNormed (h+1) |
| instance fullComponentComplete (h : ℕ) : CompleteSpace (FullComponent h) := inferInstance |
| def componentEmbedding (h : ℕ) : Vec h →ₗ[ℝ] FullComponent h := |
| (LinearMap.ker (output h)).mkQ.comp (finiteSection h) |
| lemma componentEmbedding_norm (h : ℕ) (v : Vec h) : ‖componentEmbedding h v‖=finiteCost h v := rfl |
| |
| / |
| def finiteOutputs (h : ℕ) : Submodule ℝ (Rep h) := |
| (LinearMap.range (relation h).value).comap (output h) |
| |
| def rootInjection (h : ℕ) : L1 (h+1) →L[ℝ] Rep (h+1) := |
| (WithLp.prodContinuousLinearEquiv 1 ℝ (L1 (h+1)) (lp (fun _ : ℕ => Rep h) 2)).symm.toContinuousLinearMap.comp |
| (ContinuousLinearMap.inl ℝ _ _) |
| def childrenInjection (h : ℕ) : lp (fun _ : ℕ => Rep h) 2 →L[ℝ] Rep (h+1) := |
| (WithLp.prodContinuousLinearEquiv 1 ℝ (L1 (h+1)) (lp (fun _ : ℕ => Rep h) 2)).symm.toContinuousLinearMap.comp |
| (ContinuousLinearMap.inr ℝ _ _) |
| def childInjection (h i : ℕ) : Rep h →L[ℝ] Rep (h+1) := |
| (childrenInjection h).comp (lp.singleContinuousLinearMap (𝕜 := ℝ) (E := fun _ : ℕ => Rep h) (p := 2) i) |
| lemma output_rootInjection (h : ℕ) (μ : L1 (h+1)) (r : Coord (h+1)) : |
| output (h+1) (rootInjection h μ) r=path (h+1) μ r := by |
| cases r with |
| | inl u => cases u; rfl |
| | inr a => |
| change path (h+1) μ (.inr a)+output h 0 a.2=path (h+1) μ (.inr a) |
| simp only [map_zero,Pi.zero_apply,add_zero] |
| lemma rootInjection_finite (h : ℕ) (s : Coord (h+1)) (c : ℝ) : |
| rootInjection h (lp.single 1 s c) ∈ finiteOutputs (h+1) := by |
| let v : Vec (h+1) := Finsupp.onFinset (ancestors (h+1) s) |
| (fun r => if r ∈ ancestors (h+1) s then c else 0) (fun r hr => by |
| by_contra hn |
| simp only [hn,ite_false,ne_eq,not_true_eq_false] at hr) |
| refine ⟨v,?_⟩ |
| ext r |
| change v r=output (h+1) (rootInjection h (lp.single 1 s c)) r |
| rw [output_rootInjection,path_single] |
| change (if r ∈ ancestors (h+1) s then c else 0)=c*branch (h+1) s r |
| rw [branch_apply] |
| split_ifs <;> ring |
| lemma childInjection_finite (h i : ℕ) (d : Rep h) (hd : d ∈ finiteOutputs h) : |
| childInjection h i d ∈ finiteOutputs (h+1) := by |
| obtain ⟨v,hv⟩ := hd |
| let e : Coord h ↪ Coord (h+1) := ⟨fun r => .inr (i,r),by intro a b hab; exact (Prod.mk.inj (Sum.inr.inj hab)).2⟩ |
| refine ⟨Finsupp.embDomain e v,?_⟩ |
| ext r |
| cases r with |
| | inl u => |
| change (Finsupp.embDomain e v) (.inl u)=path (h+1) 0 (root (h+1)) |
| rw [map_zero] |
| exact Finsupp.embDomain_of_notMem_range e v (.inl u) (by rintro ⟨a,ha⟩; cases ha) |
| | inr a => |
| change (Finsupp.embDomain e v) (.inr a)=path (h+1) 0 (.inr a)+output h ((lp.single 2 i d : lp (fun _ : ℕ => Rep h) 2) a.1) a.2 |
| rw [map_zero] |
| change _=0+_ |
| rw [zero_add] |
| by_cases hi : a.1=i |
| · obtain ⟨j,r⟩ := a |
| change j=i at hi |
| subst j |
| rw [lp.single_apply_self] |
| change (Finsupp.embDomain e v) (e r)=output h d r |
| rw [Finsupp.embDomain_apply_self] |
| exact congrFun hv r |
| · rw [lp.single_apply_ne _ _ _ hi,map_zero] |
| apply Finsupp.embDomain_of_notMem_range |
| rintro ⟨r,hr⟩ |
| exact hi (Prod.mk.inj (Sum.inr.inj hr)).1.symm |
| |
| lemma finiteOutputs_dense (h : ℕ) : Dense (finiteOutputs h : Set (Rep h)) := by |
| induction h with |
| | zero => |
| intro d |
| apply subset_closure |
| refine ⟨Finsupp.single () d,?_⟩ |
| ext r |
| cases r |
| change (Finsupp.single () d : Vec 0) ()=d |
| exact Finsupp.single_eq_same |
| | succ h ih => |
| let K := (finiteOutputs (h+1)).topologicalClosure |
| have hK : IsClosed (K : Set (Rep (h+1))) := (finiteOutputs (h+1)).isClosed_topologicalClosure |
| have hroot (μ : L1 (h+1)) : rootInjection h μ ∈ K := by |
| apply hK.mem_of_tendsto ((rootInjection h).hasSum (lp.hasSum_single (by norm_num : (1:ℝ≥0∞) ≠ ⊤) μ)) |
| exact Filter.Eventually.of_forall (fun S => K.sum_mem (fun s _ => subset_closure (rootInjection_finite h s (μ s)))) |
| have hchild (i : ℕ) (d : Rep h) : childInjection h i d ∈ K := by |
| induction d using ih.denseRange_val.induction_on with |
| | hp => exact hK.preimage (childInjection h i).continuous |
| | ih d => exact subset_closure (childInjection_finite h i d d.property) |
| have hchildren (w : lp (fun _ : ℕ => Rep h) 2) : childrenInjection h w ∈ K := by |
| apply hK.mem_of_tendsto ((childrenInjection h).hasSum (lp.hasSum_single (by norm_num : (2:ℝ≥0∞) ≠ ⊤) w)) |
| exact Filter.Eventually.of_forall (fun S => K.sum_mem (fun i _ => hchild i (w i))) |
| intro d |
| change d ∈ K |
| have he : d=rootInjection h d.fst+childrenInjection h d.snd := by |
| change d=WithLp.toLp 1 (d.fst,0)+WithLp.toLp 1 (0,d.snd) |
| apply (WithLp.equiv 1 _).injective |
| change (d.fst,d.snd)=(d.fst+0,0+d.snd) |
| rw [add_zero,zero_add] |
| rw [he] |
| exact K.add_mem (hroot d.fst) (hchildren d.snd) |
| |
| lemma componentEmbedding_dense (h : ℕ) : DenseRange (componentEmbedding h) := by |
| intro x |
| obtain ⟨d,rfl⟩ := (LinearMap.ker (output h)).mkQ_surjective x |
| induction d using (finiteOutputs_dense h).denseRange_val.induction_on with |
| | hp => exact isClosed_closure.preimage (LinearMap.ker (output h)).mkQL.continuous |
| | ih d => |
| obtain ⟨v,hv⟩ := d.property |
| apply subset_closure |
| refine ⟨v,?_⟩ |
| exact ((relation h).representation_eq hv.symm).symm |
| end |
| |
| open RecursiveModel PathApplications |
| / |
| abbrev FullSpace := lp (fun h : ℕ => FullComponent (h+1)) 2 |
| def fullEmbedding : ForestVec →ₗ[ℝ] FullSpace := |
| outerEmbedding (fun h => componentEmbedding (h+1)) |
| lemma fullEmbedding_norm (v : ForestVec) : ‖fullEmbedding v‖=forestSeminorm v := |
| outerEmbedding_norm _ _ (fun h v => componentEmbedding_norm (h+1) v) v |
| lemma fullEmbedding_dense : DenseRange fullEmbedding := |
| outerEmbedding_dense _ (fun h => componentEmbedding_dense (h+1)) |
| def fullEquiv : Space ≃ₗᵢ[ℝ] FullSpace := data.completionEquiv fullEmbedding fullEmbedding_norm fullEmbedding_dense |
| lemma fullEquiv_embedding (v : ForestVec) : fullEquiv (data.embedding v)=fullEmbedding v := |
| data.completionMap_coe _ _ _ |
| def fullHeads : Midpoint.Heads ForestHead FullSpace := heads.transport fullEquiv |
| |
| theorem full_graph (hinput : StartInput fullHeads) {D s : ℝ} |
| (k : ℕ) (f : Diamond.Vertex k → FullSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/128 ≤ D^2 := start_cost fullHeads hinput k f hf |
| end StartModel |
| |
| namespace PathModel |
| open RecursiveModel PathApplications |
| def linearFullHeads : Midpoint.Heads ForestHead FullLinearSpace := linearHeads.transport linearFullEquiv |
| def quadraticFullHeads : Midpoint.Heads ForestHead FullQuadraticSpace := quadraticHeads.transport quadraticFullEquiv |
| |
| theorem linear_full_flow_graph (hinput : FlowInput linearFullHeads (linearC^2)) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → FullLinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/(2*linearC^2) ≤ D^2 ∧ (k:ℝ) ≤ 2*linearC^2*D^2 := |
| linear_flow linearFullHeads hinput k f hf |
| theorem linear_full_trimming_graph (hinput : FlowInput linearFullHeads 242) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → FullLinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/484 ≤ D^2 := linear_trimming linearFullHeads hinput k f hf |
| theorem linear_full_clipping_graph (hinput : linearFullHeads.ParametricInput (1/2) 4) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → FullLinearSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)*clippingGamma D/(2*clippingQ D) ≤ D := |
| linear_clipping linearFullHeads hinput k f hf |
| theorem linear_full_vanishing_graph (hinput : linearFullHeads.TailVanishing) : |
| ¬ Diamond.UniformEmbeddings FullLinearSpace := linearFullHeads.vanishing_obstruction hinput |
| |
| theorem quadratic_full_graph (hinput : ArbitraryTailInput quadraticFullHeads 8) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| 1+(k:ℝ)/64 ≤ D^2 := quadratic_cost quadraticFullHeads hinput k f hf |
| |
| theorem stopped_full_graph (hinput : StoppedInput quadraticFullHeads) |
| {D s : ℝ} (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| (k:ℝ) ≤ 144*D^2 := stopped_flow quadraticFullHeads hinput k f hf |
| |
| theorem quadratic_full_component_graph (hinput : ComponentSumInput FullQuadraticSpace) |
| {D s e : ℝ} (he : 0 < e) (he16 : e ≤ 1/16) (hsmall : 17*(2*e)^((1:ℝ)/6) < 1/(2*D)) |
| (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| (1+e/2)^k ≤ D := component_sum hinput he he16 hsmall k f hf |
| |
| theorem quadratic_full_relative_graph (hinput : RelativeInput quadraticFullHeads) {D s : ℝ} |
| (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| (1+relativeDelta D)^k ≤ D := relative_cost quadraticFullHeads hinput k f hf |
| |
| theorem quadratic_full_tail_seven_graph (hinput : ArbitraryTailInput quadraticFullHeads 7) {D s : ℝ} |
| (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| D⁻¹ ≤ (1-D⁻¹^2/2000)^k := tail_seven quadraticFullHeads hinput k f hf |
| |
| theorem quadratic_full_pruning_graph (hinput : ArbitraryTailInput quadraticFullHeads 9) {D s γ : ℝ} |
| (hγ : 0 < γ) (hγhalf : γ < 1/2) |
| (hsmall : 9*Real.sqrt ((1+γ)^2-(1-2*γ)^2) < 2*D⁻¹/3) |
| (k : ℕ) (f : Diamond.Vertex k → FullQuadraticSpace) (hf : Diamond.HasDistortion k f D s) : |
| D⁻¹ ≤ (1-γ)^k := tail_pruning quadraticFullHeads hinput hγ hγhalf hsmall k f hf |
| end PathModel |
| |
| namespace Diamond |
| variable {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] |
| |
| / |
| lemma UnitLensBound.mono_separation {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] {ε ε' ρ : ℝ} (h : UnitLensBound X ε ρ) |
| (hε : ε ≤ ε') : UnitLensBound X ε' ρ := |
| fun x z hp hm hs => h x z hp hm (fun i j hij => hε.trans (hs i j hij)) |
| |
| lemma QuadraticLens.positive_gap {X : Type*} [NormedAddCommGroup X] [NormedSpace ℝ X] (hX : QuadraticLens X) {ε : ℝ} (hε : 0 < ε) : |
| ∃ ρ : ℝ,0 < ρ ∧ ρ < 1 ∧ UnitLensBound X ε ρ := by |
| let δ : ℝ := min (1/2) (ε^2/16) |
| have hδ : 0 < δ := lt_min (by norm_num) (by positivity) |
| have hδhalf : δ ≤ 1/2 := min_le_left _ _ |
| have hδε : δ ≤ ε^2/16 := min_le_right _ _ |
| refine ⟨Real.sqrt (1-δ),Real.sqrt_pos.2 (by linarith),?_,?_⟩ |
| · exact (Real.sqrt_lt' (by norm_num)).2 (by linarith) |
| · intro x z hp hm hs |
| have hloss := hX x z 1 ε (by norm_num) hε hp hm hs |
| have hsqrt := Real.sq_sqrt (show 0 ≤ 1-δ by linarith) |
| have hroot := Real.sqrt_nonneg (1-δ) |
| nlinarith [norm_nonneg x] |
| end Diamond |
| |
| end DiamondDistortion |
| |
| end |
| |
| end OAI |
| |
