| import OAI.Dynamics.SmoothObstruction.ProductCoordinates |
| import OAI.Dynamics.SmoothObstruction.MinorTransfer |
| import OAI.Dynamics.SmoothObstruction.AsymptoticSplitting |
|
|
| namespace OAI |
|
|
| section |
|
|
| open Filter Topology |
| open scoped Real |
|
|
| namespace SmoothObstruction.EndpointFrame |
| open Set Matrix |
| open scoped EuclideanGeometry |
| variable {d p : ℕ} |
| local notation "E" => EuclideanSpace ℝ (Fin d) |
|
|
| /-- Finite endpoint coordinates are selected from a genuine ambient orthonormal |
| basis, including the empty and full-dimensional endpoint groups. -/ |
| theorem exists_frame (W : Submodule ℝ E) (hdim : Module.finrank ℝ W=p) : |
| ∃ (b : OrthonormalBasis (Fin d) ℝ E) (r : powersetCard (Fin d) p), |
| (∀ j∈r,b j∈W) ∧ (∀ j∉r,b j∈Wᗮ) ∧ |
| (∀ x∈W,∀ j∉r,b.repr x j=0) := by |
| classical |
| let V : Bool → Submodule ℝ E := fun q => if q then W else Wᗮ |
| have hV : DirectSum.IsInternal V := by |
| apply (DirectSum.isInternal_submodule_iff_isCompl V (i:=true) (j:=false) (by decide) |
| (by ext q; cases q <;> simp)).mpr |
| exact W.isCompl_orthogonal |
| have horth : OrthogonalFamily ℝ (fun q => V q) (fun q => (V q).subtypeₗᵢ) := by |
| intro i j hij x y |
| cases i <;> cases j |
| · exact (hij rfl).elim |
| · exact Submodule.inner_left_of_mem_orthogonal y.property x.property |
| · exact Submodule.inner_right_of_mem_orthogonal x.property y.property |
| · exact (hij rfl).elim |
| have hn : Module.finrank ℝ E=d := finrank_euclideanSpace_fin |
| let b := hV.subordinateOrthonormalBasis hn horth |
| let c : Fin d → Bool := fun j => hV.subordinateOrthonormalBasisIndex hn j horth |
| let r₀ : Finset (Fin d) := Finset.univ.filter (fun j => c j=true) |
| have hc : r₀.card=p := by |
| exact (hV.card_filter_subordinateOrthonormalBasisIndex_eq hn horth true).trans hdim |
| let r : powersetCard (Fin d) p := ⟨r₀,hc⟩ |
| have hb (j : Fin d) : b j∈V (c j) := |
| hV.subordinateOrthonormalBasis_subordinate hn j horth |
| have hmem (j : Fin d) : j∈r ↔ c j=true := by |
| change j∈r₀ ↔ c j=true |
| simp only [r₀,Finset.mem_filter,Finset.mem_univ,true_and] |
| have hy (j : Fin d) (hj : j∈r) : b j∈W := by |
| simpa only [(hmem j).mp hj,V,ite_true] using hb j |
| have hz (j : Fin d) (hj : j∉r) : b j∈Wᗮ := by |
| have ht : c j=false := Bool.eq_false_of_not_eq_true (fun h => hj ((hmem j).mpr h)) |
| simpa only [ht,V,Bool.false_eq_true,ite_false] using hb j |
| refine ⟨b,r,hy,hz,?_⟩ |
| intro x hx j hj |
| rw [b.repr_apply_apply] |
| exact Submodule.inner_left_of_mem_orthogonal hx (hz j hj) |
|
|
| /-- The actual selected orthonormal coordinates, not a formal minor proxy. -/ |
| noncomputable def coordinates (b : OrthonormalBasis (Fin d) ℝ E) |
| (r : powersetCard (Fin d) p) : E →L[ℝ] EuclideanSpace ℝ (Fin p) := |
| LinearMap.toContinuousLinearMap { |
| toFun x := WithLp.toLp 2 (fun i => b.repr x (powersetCard.ofFinEmbEquiv.symm r i)) |
| map_add' x y := by ext i; simp |
| map_smul' c x := by ext i; simp } |
|
|
| @[simp] lemma coordinates_apply (b : OrthonormalBasis (Fin d) ℝ E) |
| (r : powersetCard (Fin d) p) (x : E) (i : Fin p) : |
| coordinates b r x i=b.repr x (powersetCard.ofFinEmbEquiv.symm r i) := rfl |
|
|
| lemma coordinates_projection (W : Submodule ℝ E) |
| (b : OrthonormalBasis (Fin d) ℝ E) (r : powersetCard (Fin d) p) |
| (hr : ∀ j∈r,b j∈W) (x : E) : |
| coordinates b r (W.starProjection x)=coordinates b r x := by |
| ext i |
| simp only [coordinates_apply,b.repr_apply_apply] |
| have hi : powersetCard.ofFinEmbEquiv.symm r i∈r := |
| (powersetCard.mem_range_ofFinEmbEquiv_symm_iff_mem r _).mp ⟨i,rfl⟩ |
| have hh := W.inner_orthogonalProjectionOnto_eq_of_mem_left |
| (⟨b (powersetCard.ofFinEmbEquiv.symm r i),hr _ hi⟩ : W) x |
| exact hh |
|
|
| /-- Endpoint-coordinate equality is precisely the reference projected |
| endpoint datum used by the genuine boundary-value problem. -/ |
| lemma coordinates_eq_iff (W : Submodule ℝ E) |
| (b : OrthonormalBasis (Fin d) ℝ E) (r : powersetCard (Fin d) p) |
| (hr : ∀ j∈r,b j∈W) (hz : ∀ x∈W,∀ j∉r,b.repr x j=0) (x y : E) : |
| coordinates b r x=coordinates b r y ↔ W.starProjection x=W.starProjection y := by |
| classical |
| constructor |
| · intro h |
| apply b.repr.injective |
| ext j |
| by_cases hj : j∈r |
| · obtain ⟨i,rfl⟩ := (powersetCard.mem_range_ofFinEmbEquiv_symm_iff_mem r j).mpr hj |
| have he := (coordinates_projection W b r hr x).trans |
| (h.trans (coordinates_projection W b r hr y).symm) |
| exact congrArg (fun z : EuclideanSpace ℝ (Fin p) => z i) he |
| · rw [hz _ (W.starProjection_apply_mem x) _ hj,hz _ (W.starProjection_apply_mem y) _ hj] |
| · intro h |
| rw [←coordinates_projection W b r hr x,←coordinates_projection W b r hr y,h] |
| end SmoothObstruction.EndpointFrame |
|
|
| namespace SmoothObstruction.ProductBasis |
| variable {E : Type*} [NormedAddCommGroup E] [InnerProductSpace ℝ E] [FiniteDimensional ℝ E] |
| {ι κ : Type*} [Fintype ι] [Fintype κ] |
| lemma blockMap_basis_inl (U V : Submodule ℝ E) (h : IsCompl U V) |
| (bU : OrthonormalBasis ι ℝ U) (bV : OrthonormalBasis κ ℝ V) (i : ι) : |
| blockMap U V h bU bV (EuclideanSpace.basisFun (ι⊕κ) ℝ (Sum.inl i))=bU i := by |
| classical |
| rw [blockMap_apply] |
| have he : EuclideanSpace.sumEquivProd (EuclideanSpace.basisFun (ι⊕κ) ℝ (Sum.inl i))= |
| (EuclideanSpace.basisFun ι ℝ i,0) := by |
| ext j <;> simp [EuclideanSpace.basisFun_apply,EuclideanSpace.sumEquivProd] |
| rw [he] |
| simp only [map_zero,Submodule.coe_zero,add_zero] |
| exact congrArg Subtype.val (bU.repr.symm_apply_eq.mpr (bU.repr_self i).symm) |
|
|
| lemma blockMap_basis_inr (U V : Submodule ℝ E) (h : IsCompl U V) |
| (bU : OrthonormalBasis ι ℝ U) (bV : OrthonormalBasis κ ℝ V) (i : κ) : |
| blockMap U V h bU bV (EuclideanSpace.basisFun (ι⊕κ) ℝ (Sum.inr i))=bV i := by |
| classical |
| rw [blockMap_apply] |
| have he : EuclideanSpace.sumEquivProd (EuclideanSpace.basisFun (ι⊕κ) ℝ (Sum.inr i))= |
| (0,EuclideanSpace.basisFun κ ℝ i) := by |
| ext j <;> simp [EuclideanSpace.basisFun_apply,EuclideanSpace.sumEquivProd] |
| rw [he] |
| simp only [map_zero,Submodule.coe_zero,zero_add] |
| exact congrArg Subtype.val (bV.repr.symm_apply_eq.mpr (bV.repr_self i).symm) |
| end SmoothObstruction.ProductBasis |
|
|
| namespace SmoothObstruction.EndpointFrame |
| open Set Matrix ProductBasis ExteriorStability |
| variable {d p q : ℕ} |
| local notation "E" => EuclideanSpace ℝ (Fin d) |
| local notation "F" => EuclideanSpace ℝ (Fin p ⊕ Fin q) |
|
|
| noncomputable def joint (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| (f g : E → E) (x : E) : F := |
| EuclideanSpace.sumEquivProd.symm (coordinates bF rF (f x),coordinates bP rP (g x)) |
|
|
| noncomputable def jointLinear (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| (A B : E →L[ℝ] E) : E →L[ℝ] F := |
| EuclideanSpace.sumEquivProd.symm.toContinuousLinearMap.comp |
| (((coordinates bF rF).comp A).prod ((coordinates bP rP).comp B)) |
|
|
| lemma joint_hasFDerivAt (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| {f g : E → E} {x : E} {A B : E →L[ℝ] E} |
| (hf : HasFDerivAt f A x) (hg : HasFDerivAt g B x) : |
| HasFDerivAt (joint bF bP rF rP f g) (jointLinear bF bP rF rP A B) x := by |
| exact (EuclideanSpace.sumEquivProd.symm.hasFDerivAt).comp x |
| (((coordinates bF rF).hasFDerivAt.comp x hf).prodMk |
| ((coordinates bP rP).hasFDerivAt.comp x hg)) |
|
|
| lemma joint_matrix (U V : Submodule ℝ E) (h : IsCompl U V) |
| (bU : OrthonormalBasis (Fin p) ℝ U) (bV : OrthonormalBasis (Fin q) ℝ V) |
| (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| (A B : E →L[ℝ] E) : |
| LinearMap.toMatrix (EuclideanSpace.basisFun (Fin p ⊕ Fin q) ℝ).toBasis |
| (EuclideanSpace.basisFun (Fin p ⊕ Fin q) ℝ).toBasis |
| ((jointLinear bF bP rF rP A B).comp (blockMap U V h bU bV).toContinuousLinearMap).toLinearMap= |
| Matrix.fromBlocks (endpointMatrix bF p rF A (fun i => (bU i:E))) |
| (endpointMatrix bF p rF A (fun i => (bV i:E))) |
| (endpointMatrix bP q rP B (fun i => (bU i:E))) |
| (endpointMatrix bP q rP B (fun i => (bV i:E))) := by |
| have hL (j : Fin p) : blockMap U V h bU bV (EuclideanSpace.single (Sum.inl j) 1)=(bU j:E) := |
| by simpa only [EuclideanSpace.basisFun_apply] using blockMap_basis_inl U V h bU bV j |
| have hR (j : Fin q) : blockMap U V h bU bV (EuclideanSpace.single (Sum.inr j) 1)=(bV j:E) := |
| by simpa only [EuclideanSpace.basisFun_apply] using blockMap_basis_inr U V h bU bV j |
| ext i j |
| rcases i with i | i <;> rcases j with j | j <;> |
| simp [LinearMap.toMatrix_apply,jointLinear,hL,hR, |
| endpointMatrix,EuclideanSpace.sumEquivProd] |
|
|
| /-- The determinant of the actual joint endpoint differential in the common |
| product input coordinates is exactly the block determinant estimated by the |
| maximal-minor algebra. No leading volume lower floor is asserted. -/ |
| lemma joint_det (U V : Submodule ℝ E) (h : IsCompl U V) |
| (bU : OrthonormalBasis (Fin p) ℝ U) (bV : OrthonormalBasis (Fin q) ℝ V) |
| (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| (A B : E →L[ℝ] E) : |
| ((jointLinear bF bP rF rP A B).comp (blockMap U V h bU bV).toContinuousLinearMap).det= |
| (Matrix.fromBlocks (endpointMatrix bF p rF A (fun i => (bU i:E))) |
| (endpointMatrix bF p rF A (fun i => (bV i:E))) |
| (endpointMatrix bP q rP B (fun i => (bU i:E))) |
| (endpointMatrix bP q rP B (fun i => (bV i:E)))).det := by |
| rw [←joint_matrix U V h bU bV bF bP rF rP A B,LinearMap.det_toMatrix] |
| end SmoothObstruction.EndpointFrame |
|
|
| namespace SmoothObstruction.EndpointBranch |
| open Filter Topology |
| open scoped ContDiff |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] [CompleteSpace E] |
|
|
| noncomputable def derivative (A B C D : E ≃L[ℝ] E) |
| (σ : (E×E) ≃L[ℝ] (E×E)) : (E×E) ≃L[ℝ] (E×E) := |
| ((A.prodCongr B).trans σ).trans (C.prodCongr D).symm |
|
|
| /-- Smooth local solution of all four endpoint equations, with its ACTUAL |
| nondegenerate derivative. This statement is insensitive to zero-dimensional |
| endpoint groups and keeps all four endpoint derivatives separate. -/ |
| theorem local_branch (f₀ f₁ g₀ g₁ : E → E) (x y z w : E) |
| (A B C D : E ≃L[ℝ] E) (σ : (E×E) ≃L[ℝ] (E×E)) |
| (hf₀ : ContDiffAt ℝ ∞ f₀ x) (hf₁ : ContDiffAt ℝ ∞ f₁ y) |
| (hg₀ : ContDiffAt ℝ ∞ g₀ z) (hg₁ : ContDiffAt ℝ ∞ g₁ w) |
| (hA : HasFDerivAt f₀ (A : E →L[ℝ] E) x) |
| (hB : HasFDerivAt f₁ (B : E →L[ℝ] E) y) |
| (hC : HasFDerivAt g₀ (C : E →L[ℝ] E) z) |
| (hD : HasFDerivAt g₁ (D : E →L[ℝ] E) w) |
| (heq : Prod.map g₀ g₁ (z,w)=σ (Prod.map f₀ f₁ (x,y))) : |
| ∃ Φ : E×E → E×E, Φ (x,y)=(z,w) ∧ ContDiffAt ℝ ∞ Φ (x,y) ∧ |
| HasFDerivAt Φ (derivative A B C D σ : (E×E) →L[ℝ] (E×E)) (x,y) ∧ |
| ∀ᶠ u in 𝓝 (x,y),Prod.map g₀ g₁ (Φ u)=σ (Prod.map f₀ f₁ u) := by |
| let F := Prod.map f₀ f₁ |
| let G := Prod.map g₀ g₁ |
| have hF : ContDiffAt ℝ ∞ F (x,y) := hf₀.prodMap hf₁ |
| have hG : ContDiffAt ℝ ∞ G (z,w) := hg₀.prodMap hg₁ |
| have hFd : HasFDerivAt F (A.prodCongr B : (E×E) →L[ℝ] (E×E)) (x,y) := |
| hA.prodMap (x,y) hB |
| have hGd : HasFDerivAt G (C.prodCongr D : (E×E) →L[ℝ] (E×E)) (z,w) := |
| hC.prodMap (z,w) hD |
| have hn : (∞ : ℕ∞ω)≠0 := by simp |
| let ψ := hG.localInverse hGd hn |
| let Φ := ψ ∘ σ ∘ F |
| have hψ : ContDiffAt ℝ ∞ ψ (G (z,w)) := hG.to_localInverse hGd hn |
| have hψd : HasFDerivAt ψ ((C.prodCongr D).symm : (E×E) →L[ℝ] (E×E)) (G (z,w)) := |
| (hG.hasStrictFDerivAt' hGd hn).to_localInverse.hasFDerivAt |
| have hmid : ContDiffAt ℝ ∞ (σ ∘ F) (x,y) := σ.contDiff.contDiffAt.comp (x,y) hF |
| have hmidD := σ.hasFDerivAt.comp (x,y) hFd |
| have hpt : G (z,w)=(σ ∘ F) (x,y) := heq |
| refine ⟨Φ,?_,?_,?_,?_⟩ |
| · change ψ ((σ ∘ F) (x,y))=(z,w) |
| rw [←hpt] |
| exact hG.localInverse_apply_image hGd hn |
| · rw [hpt] at hψ |
| exact hψ.comp (x,y) hmid |
| · rw [hpt] at hψd |
| exact hψd.comp (x,y) hmidD |
| · have hh := (hG.hasStrictFDerivAt' hGd hn).eventually_right_inverse |
| rw [hpt] at hh |
| exact hmid.continuousAt.tendsto.eventually hh |
|
|
| section Determinant |
| variable [FiniteDimensional ℝ E] |
|
|
| omit [CompleteSpace E] in |
| lemma derivative_det (A B C D : E ≃L[ℝ] E) |
| (σ : (E×E) ≃L[ℝ] (E×E)) : |
| (derivative A B C D σ : (E×E) →L[ℝ] (E×E)).det = |
| (σ : (E×E) →L[ℝ] (E×E)).det * (A : E →L[ℝ] E).det * |
| (B : E →L[ℝ] E).det / ((C : E →L[ℝ] E).det*(D : E →L[ℝ] E).det) := by |
| change LinearMap.det (((C.prodCongr D).symm : (E×E) →L[ℝ] (E×E)).toLinearMap.comp |
| ((σ : (E×E) →L[ℝ] (E×E)).toLinearMap.comp |
| ((A.prodCongr B : (E×E) →L[ℝ] (E×E)).toLinearMap)))=_ |
| rw [LinearMap.det_comp,LinearMap.det_comp] |
| have hinv := LinearEquiv.det_coe_symm (C.prodCongr D).toLinearEquiv |
| change ((C.prodCongr D).symm : (E×E) →L[ℝ] (E×E)).det = |
| ((C.prodCongr D : (E×E) →L[ℝ] (E×E)).det)⁻¹ at hinv |
| change ((C.prodCongr D).symm : (E×E) →L[ℝ] (E×E)).det * |
| ((σ : (E×E) →L[ℝ] (E×E)).det * |
| ((A.prodCongr B : (E×E) →L[ℝ] (E×E)).det))=_ |
| rw [hinv] |
| change ((C : E →L[ℝ] E).toLinearMap.prodMap (D : E →L[ℝ] E).toLinearMap).det⁻¹ * |
| ((σ : (E×E) →L[ℝ] (E×E)).det * |
| ((A : E →L[ℝ] E).toLinearMap.prodMap (B : E →L[ℝ] E).toLinearMap).det)=_ |
| rw [LinearMap.det_prodMap,LinearMap.det_prodMap] |
| ring |
|
|
| omit [CompleteSpace E] in |
| lemma derivative_abs_det (A B C D : E ≃L[ℝ] E) |
| (σ : (E×E) ≃L[ℝ] (E×E)) (hσ : |(σ : (E×E) →L[ℝ] (E×E)).det|=1) : |
| |(derivative A B C D σ : (E×E) →L[ℝ] (E×E)).det| = |
| |(A : E →L[ℝ] E).det| * |(B : E →L[ℝ] E).det| / |
| (|(C : E →L[ℝ] E).det| * |(D : E →L[ℝ] E).det|) := by |
| rw [derivative_det,abs_div,abs_mul,abs_mul,abs_mul,hσ,one_mul] |
| end Determinant |
|
|
| section Exchange |
| variable {F P : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F] |
| [NormedAddCommGroup P] [NormedSpace ℝ P] |
|
|
| /-- Exchange the past coordinates and leave the future coordinates fixed. -/ |
| def exchange : ((F×P)×(F×P)) ≃L[ℝ] ((F×P)×(F×P)) where |
| toFun u := ((u.1.1,u.2.2),(u.2.1,u.1.2)) |
| invFun u := ((u.1.1,u.2.2),(u.2.1,u.1.2)) |
| left_inv _ := rfl |
| right_inv _ := rfl |
| map_add' _ _ := rfl |
| map_smul' _ _ := rfl |
| continuous_toFun := by fun_prop |
| continuous_invFun := by fun_prop |
|
|
| lemma exchange_abs_det [FiniteDimensional ℝ F] [FiniteDimensional ℝ P] : |
| |(exchange (F:=F) (P:=P) : ((F×P)×(F×P)) →L[ℝ] ((F×P)×(F×P))).det|=1 := by |
| let e := exchange (F:=F) (P:=P) |
| have hh := e.toLinearEquiv.det_mul_det_symm |
| change (e : ((F×P)×(F×P)) →L[ℝ] ((F×P)×(F×P))).det * |
| (e : ((F×P)×(F×P)) →L[ℝ] ((F×P)×(F×P))).det=1 at hh |
| have h := congrArg abs hh |
| rw [abs_mul,abs_one] at h |
| nlinarith [abs_nonneg ((e : ((F×P)×(F×P)) →L[ℝ] ((F×P)×(F×P))).det)] |
| end Exchange |
| end SmoothObstruction.EndpointBranch |
|
|
| namespace SmoothObstruction.JacobianBounds |
|
|
| lemma abs_ratio_bounds {a b : ℝ} (hb : b≠0) (h : |a/b-1|≤(1/10:ℝ)) : |
| (9/10:ℝ)*|b|≤|a| ∧ |a|≤(11/10:ℝ)*|b| := by |
| have ha : abs (abs (a/b) - 1)≤(1/10:ℝ) := by |
| simpa only [abs_one] using (abs_abs_sub_abs_le_abs_sub (a/b) 1).trans h |
| have hlo : (9/10:ℝ)≤|a/b| := by linarith [(abs_le.mp ha).1] |
| have hup : |a/b|≤(11/10:ℝ) := by linarith [(abs_le.mp ha).2] |
| rw [abs_div] at hlo hup |
| exact ⟨(le_div_iff₀ (abs_pos.mpr hb)).mp hlo,(div_le_iff₀ (abs_pos.mpr hb)).mp hup⟩ |
|
|
| /-- Four relative maximal-minor errors cancel the actual leading volumes |
| individually. Rates of the two input orbits never need to be compared. -/ |
| theorem four_cancel |
| (a b c d u v w z : ℝ) (ha : 0<a) (hb : 0<b) (hc : 0<c) (hd : 0<d) |
| (hu : |u/(a*b)-1|≤(1/10:ℝ)) (hv : |v/(c*d)-1|≤(1/10:ℝ)) |
| (hw : |w/(a*d)-1|≤(1/10:ℝ)) (hz : |z/(c*b)-1|≤(1/10:ℝ)) : |
| w≠0 ∧ z≠0 ∧ (81/121:ℝ)≤|u| *|v| /(|w| *|z|) ∧ |
| |u| *|v| /(|w| *|z|)≤(121/81:ℝ) := by |
| have hU := abs_ratio_bounds (mul_ne_zero ha.ne' hb.ne') hu |
| have hV := abs_ratio_bounds (mul_ne_zero hc.ne' hd.ne') hv |
| have hW := abs_ratio_bounds (mul_ne_zero ha.ne' hd.ne') hw |
| have hZ := abs_ratio_bounds (mul_ne_zero hc.ne' hb.ne') hz |
| simp only [abs_of_pos (mul_pos ha hb)] at hU |
| simp only [abs_of_pos (mul_pos hc hd)] at hV |
| simp only [abs_of_pos (mul_pos ha hd)] at hW |
| simp only [abs_of_pos (mul_pos hc hb)] at hZ |
| have hwpos : 0 < |w| := lt_of_lt_of_le (by positivity) hW.1 |
| have hzpos : 0 < |z| := lt_of_lt_of_le (by positivity) hZ.1 |
| refine ⟨abs_pos.mp hwpos,abs_pos.mp hzpos,?_,?_⟩ |
| · apply (le_div_iff₀ (mul_pos hwpos hzpos)).mpr |
| have hUV := mul_le_mul hU.1 hV.1 (by positivity) (abs_nonneg u) |
| have hWZ := mul_le_mul hW.2 hZ.2 (abs_nonneg z) (by positivity) |
| nlinarith |
| · apply (div_le_iff₀ (mul_pos hwpos hzpos)).mpr |
| have hUV := mul_le_mul hU.2 hV.2 (abs_nonneg v) (by positivity) |
| have hWZ := mul_le_mul hW.1 hZ.1 (by positivity) (abs_nonneg w) |
| nlinarith |
|
|
| /-- A mild smooth-density error leaves enough room for the unnormalized |
| factor-two pushforward estimate. -/ |
| theorem density_lower {J din dout : ℝ} (hdin : 0≤din) |
| (hJ : (81/121:ℝ)≤J) (hd : (3/4:ℝ)*din≤dout) : din≤2*(J*dout) := by |
| have hdout : 0≤dout := le_trans (by positivity) hd |
| have hh := mul_le_mul hJ hd (by positivity) (by linarith : 0≤J) |
| nlinarith |
|
|
| end SmoothObstruction.JacobianBounds |
|
|
| namespace SmoothObstruction.EndpointBranch |
| open Filter Topology |
| open scoped ContDiff |
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [CompleteSpace E] [FiniteDimensional ℝ E] |
|
|
| noncomputable def equiv_of_det (A : E →L[ℝ] E) (hA : A.det≠0) : E ≃L[ℝ] E := |
| (LinearMap.equivOfIsUnitDet (isUnit_iff_ne_zero.mpr hA)).toContinuousLinearEquiv |
|
|
| omit [CompleteSpace E] in |
| @[simp] lemma equiv_of_det_coe (A : E →L[ℝ] E) (hA : A.det≠0) : |
| (equiv_of_det A hA : E →L[ℝ] E)=A := by |
| ext x |
| exact LinearMap.equivOfIsUnitDet_apply _ x |
|
|
| /-- Construct the true smooth branch from four *absolute*, relative |
| endpoint-minor estimates. None of the four endpoint derivatives is |
| assumed invertible, and no leading volume is bounded away from zero. -/ |
| theorem controlled_branch (f₀ f₁ g₀ g₁ : E → E) (x y z w : E) |
| (A B C D : E →L[ℝ] E) (σ : (E×E) ≃L[ℝ] (E×E)) |
| (hf₀ : ContDiffAt ℝ ∞ f₀ x) (hf₁ : ContDiffAt ℝ ∞ f₁ y) |
| (hg₀ : ContDiffAt ℝ ∞ g₀ z) (hg₁ : ContDiffAt ℝ ∞ g₁ w) |
| (hA : HasFDerivAt f₀ A x) (hB : HasFDerivAt f₁ B y) |
| (hC : HasFDerivAt g₀ C z) (hD : HasFDerivAt g₁ D w) |
| (heq : Prod.map g₀ g₁ (z,w)=σ (Prod.map f₀ f₁ (x,y))) |
| (hσ : |(σ : (E×E) →L[ℝ] (E×E)).det|=1) |
| (a b c d : ℝ) (ha : 0<a) (hb : 0<b) (hc : 0<c) (hd : 0<d) |
| (haA : |(|A.det| / (a*b)-1)|≤(1/10:ℝ)) |
| (hbB : |(|B.det| / (c*d)-1)|≤(1/10:ℝ)) |
| (hcC : |(|C.det| / (a*d)-1)|≤(1/10:ℝ)) |
| (hdD : |(|D.det| / (c*b)-1)|≤(1/10:ℝ)) : |
| ∃ Φ : E×E → E×E,Φ (x,y)=(z,w) ∧ ContDiffAt ℝ ∞ Φ (x,y) ∧ |
| (81/121:ℝ) ≤ |(fderiv ℝ Φ (x,y)).det| ∧ |
| |(fderiv ℝ Φ (x,y)).det| ≤ (121/81:ℝ) ∧ |
| ∀ᶠ u in 𝓝 (x,y),Prod.map g₀ g₁ (Φ u)=σ (Prod.map f₀ f₁ u) := by |
| have hAn : A.det≠0 := by intro h; norm_num [h] at haA |
| have hBn : B.det≠0 := by intro h; norm_num [h] at hbB |
| have hCn : C.det≠0 := by intro h; norm_num [h] at hcC |
| have hDn : D.det≠0 := by intro h; norm_num [h] at hdD |
| obtain ⟨Φ,hpt,hcd,hder,he⟩ := local_branch f₀ f₁ g₀ g₁ x y z w |
| (equiv_of_det A hAn) (equiv_of_det B hBn) (equiv_of_det C hCn) (equiv_of_det D hDn) σ |
| hf₀ hf₁ hg₀ hg₁ (by simpa only [equiv_of_det_coe] using hA) |
| (by simpa only [equiv_of_det_coe] using hB) |
| (by simpa only [equiv_of_det_coe] using hC) |
| (by simpa only [equiv_of_det_coe] using hD) heq |
| have hdet : |(fderiv ℝ Φ (x,y)).det|=|A.det| * |B.det| / (|C.det| * |D.det|) := by |
| rw [hder.fderiv,derivative_abs_det _ _ _ _ σ hσ] |
| simp only [equiv_of_det_coe] |
| have hbound := (JacobianBounds.four_cancel a b c d |A.det| |B.det| |C.det| |D.det| |
| ha hb hc hd haA hbB hcC hdD).2.2 |
| simp only [abs_abs] at hbound |
| exact ⟨Φ,hpt,hcd,hdet.symm ▸ hbound.1,hdet.symm ▸ hbound.2,he⟩ |
| end SmoothObstruction.EndpointBranch |
|
|
| namespace SmoothObstruction.EndpointBranch |
| open Filter Topology |
| open scoped ContDiff |
| variable {p q : ℕ} |
| local notation "F" => EuclideanSpace ℝ (Fin p ⊕ Fin q) |
|
|
| /-- The exact future/past exchange in the orthonormal sum coordinates used |
| for the endpoint block matrices. -/ |
| noncomputable def sumExchange : (F×F) ≃L[ℝ] (F×F) := |
| let e : F ≃L[ℝ] (EuclideanSpace ℝ (Fin p) × EuclideanSpace ℝ (Fin q)) := |
| EuclideanSpace.sumEquivProd |
| (e.prodCongr e).trans (exchange.trans (e.prodCongr e).symm) |
|
|
| lemma sumExchange_abs_det : |(sumExchange (p:=p) (q:=q) : (F×F) →L[ℝ] (F×F)).det|=1 := by |
| let e := sumExchange (p:=p) (q:=q) |
| have he : e.symm=e := by |
| ext x i <;> rfl |
| have hh := e.toLinearEquiv.det_mul_det_symm |
| change (e : (F×F) →L[ℝ] (F×F)).det * (e.symm : (F×F) →L[ℝ] (F×F)).det=1 at hh |
| rw [he] at hh |
| have hab := congrArg abs hh |
| rw [abs_mul,abs_one] at hab |
| nlinarith [abs_nonneg ((e : (F×F) →L[ℝ] (F×F)).det)] |
|
|
| /-- Signed relative determinants give precisely the absolute, relative |
| volume estimates required by the actual inverse-function branch. -/ |
| lemma absolute_relative {u a b ε : ℝ} (h : |u/(a*b)-1|≤ε) : |
| |(|u|/(|a| * |b|))-1|≤ε := by |
| have hh := (abs_abs_sub_abs_le_abs_sub (u/(a*b)) 1).trans h |
| simpa only [abs_div,abs_mul,abs_one] using hh |
|
|
| variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
|
|
| /-- The common starting-basis determinant cancels exactly, without either |
| orthogonality between the two summands or a determinant lower bound. -/ |
| lemma conjugate_det (L : E ≃L[ℝ] F) (A : E →L[ℝ] E) : |
| (L.toContinuousLinearMap.comp (A.comp L.symm.toContinuousLinearMap)).det=A.det := by |
| let b := (EuclideanSpace.basisFun (Fin p ⊕ Fin q) ℝ).toBasis |
| let c := b.map L.symm.toLinearEquiv |
| change LinearMap.det ((L.toContinuousLinearMap.comp (A.comp L.symm.toContinuousLinearMap)).toLinearMap)=LinearMap.det A.toLinearMap |
| rw [←LinearMap.det_toMatrix b,←LinearMap.det_toMatrix c] |
| congr 1 |
| end SmoothObstruction.EndpointBranch |
|
|
| namespace SmoothObstruction.EndpointBranch |
| open Filter Topology |
| open scoped ContDiff |
| variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| [NormedAddCommGroup F] [NormedSpace ℝ F] [FiniteDimensional ℝ F] |
|
|
| lemma linear_conjugate_det (L : E ≃L[ℝ] F) (A : E →L[ℝ] E) : |
| (L.toContinuousLinearMap.comp (A.comp L.symm.toContinuousLinearMap)).det=A.det := by |
| let b := Module.finBasis ℝ F |
| let c := b.map L.symm.toLinearEquiv |
| change LinearMap.det ((L.toContinuousLinearMap.comp (A.comp L.symm.toContinuousLinearMap)).toLinearMap)=LinearMap.det A.toLinearMap |
| rw [←LinearMap.det_toMatrix b,←LinearMap.det_toMatrix c] |
| congr 1 |
|
|
| variable [CompleteSpace F] [FiniteDimensional ℝ E] |
| /-- The controlled endpoint branch in the original physical coordinates. |
| The same (possibly badly conditioned) starting basis is used for all four |
| endpoint maps, and cancels exactly from the joint Jacobian. -/ |
| theorem physical_controlled_branch (L : F ≃L[ℝ] E) |
| (f₀ f₁ g₀ g₁ : E → F) (x y z w : E) |
| (A B C D : E →L[ℝ] F) (σ : (F×F) ≃L[ℝ] (F×F)) |
| (hf₀ : ContDiffAt ℝ ∞ f₀ x) (hf₁ : ContDiffAt ℝ ∞ f₁ y) |
| (hg₀ : ContDiffAt ℝ ∞ g₀ z) (hg₁ : ContDiffAt ℝ ∞ g₁ w) |
| (hA : HasFDerivAt f₀ A x) (hB : HasFDerivAt f₁ B y) |
| (hC : HasFDerivAt g₀ C z) (hD : HasFDerivAt g₁ D w) |
| (heq : Prod.map g₀ g₁ (z,w)=σ (Prod.map f₀ f₁ (x,y))) |
| (hσ : |(σ : (F×F) →L[ℝ] (F×F)).det|=1) |
| (a b c d : ℝ) (ha : 0<a) (hb : 0<b) (hc : 0<c) (hd : 0<d) |
| (haA : |(|(A.comp L.toContinuousLinearMap).det| / (a*b)-1)|≤(1/10:ℝ)) |
| (hbB : |(|(B.comp L.toContinuousLinearMap).det| / (c*d)-1)|≤(1/10:ℝ)) |
| (hcC : |(|(C.comp L.toContinuousLinearMap).det| / (a*d)-1)|≤(1/10:ℝ)) |
| (hdD : |(|(D.comp L.toContinuousLinearMap).det| / (c*b)-1)|≤(1/10:ℝ)) : |
| ∃ Φ : E×E → E×E,Φ (x,y)=(z,w) ∧ ContDiffAt ℝ ∞ Φ (x,y) ∧ |
| (81/121:ℝ) ≤ |(fderiv ℝ Φ (x,y)).det| ∧ |
| |(fderiv ℝ Φ (x,y)).det| ≤ (121/81:ℝ) ∧ |
| ∀ᶠ u in 𝓝 (x,y),Prod.map g₀ g₁ (Φ u)=σ (Prod.map f₀ f₁ u) := by |
| let T := L.prodCongr L |
| have cd {f : E → F} {u : E} (h : ContDiffAt ℝ ∞ f u) : |
| ContDiffAt ℝ ∞ (f ∘ L) (L.symm u) := by |
| have h' : ContDiffAt ℝ ∞ f (L (L.symm u)) := by simpa using h |
| exact h'.comp _ L.contDiff.contDiffAt |
| have der {f : E → F} {u : E} {K : E →L[ℝ] F} (h : HasFDerivAt f K u) : |
| HasFDerivAt (f ∘ L) (K.comp L.toContinuousLinearMap) (L.symm u) := by |
| have h' : HasFDerivAt f K (L (L.symm u)) := by simpa using h |
| exact h'.comp _ L.hasFDerivAt |
| obtain ⟨ψ,hpt,hcd,hlo,hup,he⟩ := controlled_branch (f₀ ∘ L) (f₁ ∘ L) |
| (g₀ ∘ L) (g₁ ∘ L) (L.symm x) (L.symm y) (L.symm z) (L.symm w) |
| (A.comp L.toContinuousLinearMap) (B.comp L.toContinuousLinearMap) |
| (C.comp L.toContinuousLinearMap) (D.comp L.toContinuousLinearMap) σ |
| (cd hf₀) (cd hf₁) (cd hg₀) (cd hg₁) (der hA) (der hB) (der hC) (der hD) |
| (by simpa only [Prod.map_apply,Function.comp_apply,L.apply_symm_apply] using heq) |
| hσ a b c d ha hb hc hd haA hbB hcC hdD |
| let Φ := T ∘ ψ ∘ T.symm |
| have hψd := (hcd.differentiableAt (by norm_num)).hasFDerivAt |
| have hΦcd : ContDiffAt ℝ ∞ Φ (x,y) := |
| T.contDiff.contDiffAt.comp (x,y) (hcd.comp (x,y) T.symm.contDiff.contDiffAt) |
| have hΦd : HasFDerivAt Φ |
| (T.toContinuousLinearMap.comp ((fderiv ℝ ψ (L.symm x,L.symm y)).comp T.symm.toContinuousLinearMap)) |
| (x,y) := T.hasFDerivAt.comp (x,y) (hψd.comp (x,y) T.symm.hasFDerivAt) |
| have hdet : (fderiv ℝ Φ (x,y)).det=(fderiv ℝ ψ (L.symm x,L.symm y)).det := by |
| rw [hΦd.fderiv] |
| exact linear_conjugate_det T _ |
| refine ⟨Φ,?_,hΦcd,hdet.symm ▸ hlo,hdet.symm ▸ hup,?_⟩ |
| · change T (ψ (L.symm x,L.symm y))=(z,w) |
| rw [hpt] |
| exact T.apply_symm_apply (z,w) |
| · have hT : ContinuousAt T.symm (x,y) := T.symm.continuousAt |
| have hh := hT.tendsto.eventually he |
| filter_upwards [hh] with u hu |
| simpa [Φ,T,Function.comp_def,Prod.map] using hu |
| end SmoothObstruction.EndpointBranch |
|
|
| namespace SmoothObstruction.EndpointFrame |
| open Set Matrix ProductBasis ExteriorStability |
| open scoped ContDiff |
| variable {d p q : ℕ} |
| local notation "E" => EuclideanSpace ℝ (Fin d) |
|
|
| lemma joint_contDiffAt (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| {f g : E → E} {x : E} (hf : ContDiffAt ℝ ∞ f x) (hg : ContDiffAt ℝ ∞ g x) : |
| ContDiffAt ℝ ∞ (joint bF bP rF rP f g) x := by |
| exact EuclideanSpace.sumEquivProd.symm.contDiff.contDiffAt.comp x |
| (((coordinates bF rF).contDiff.contDiffAt.comp x hf).prodMk |
| ((coordinates bP rP).contDiff.contDiffAt.comp x hg)) |
|
|
| /-- The true joint endpoint differential inherits the four-volume relative |
| bound from the genuine selected endpoint minors. The modulus is chosen only |
| from the dimensions, and permits either group to be empty. -/ |
| theorem joint_controlled_det : ∃ δ : ℝ,0<δ ∧ |
| ∀ (U V : Submodule ℝ E) (h : IsCompl U V) |
| (bU : OrthonormalBasis (Fin p) ℝ U) (bV : OrthonormalBasis (Fin q) ℝ V) |
| (bF bP : OrthonormalBasis (Fin d) ℝ E) |
| (rF : powersetCard (Fin d) p) (rP : powersetCard (Fin d) q) |
| (f g : E → E) (x : E) (A₀ : Matrix (Fin p) (Fin p) ℝ) |
| (D₀ : Matrix (Fin q) (Fin q) ℝ), |
| DifferentiableAt ℝ f x → DifferentiableAt ℝ g x → |
| A₀.det≠0 → D₀.det≠0 → |
| let A := endpointMatrix bF p rF (fderiv ℝ f x) (fun i => (bU i:E)) |
| let B := endpointMatrix bF p rF (fderiv ℝ f x) (fun i => (bV i:E)) |
| let C := endpointMatrix bP q rP (fderiv ℝ g x) (fun i => (bU i:E)) |
| let D := endpointMatrix bP q rP (fderiv ℝ g x) (fun i => (bV i:E)) |
| |A.det/A₀.det-1|≤(1/100:ℝ) → |D.det/D₀.det-1|≤(1/100:ℝ) → |
| (∀ i j,|(A⁻¹*B) i j|≤δ) → (∀ i j,|(D⁻¹*C) i j|≤δ) → |
| |(|((fderiv ℝ (joint bF bP rF rP f g) x).comp |
| (blockMap U V h bU bV).toContinuousLinearMap).det| / |
| (|A₀.det| * |D₀.det|)-1)|≤(1/10:ℝ) := by |
| obtain ⟨δ,hδ,hbound⟩ := MinorGraph.joint_relative_transfer (m:=Fin p) (n:=Fin q) |
| refine ⟨δ,hδ,?_⟩ |
| intro U V h bU bV bF bP rF rP f g x A₀ D₀ hf hg hA₀ hD₀ A B C D hA hD hAB hDC |
| have hder := joint_hasFDerivAt bF bP rF rP hf.hasFDerivAt hg.hasFDerivAt |
| rw [hder.fderiv,joint_det U V h bU bV bF bP rF rP] |
| exact EndpointBranch.absolute_relative (hbound A₀ D₀ A B C D hA₀ hD₀ hA hD hAB hDC) |
| end SmoothObstruction.EndpointFrame |
|
|
| namespace SmoothObstruction.EndpointFrame |
| open Set Matrix ProductBasis ExteriorStability Filter Topology |
| open scoped ContDiff |
| variable {d p q : ℕ} |
| local notation "E" => EuclideanSpace ℝ (Fin d) |
| local notation "F" => EuclideanSpace ℝ (Fin p ⊕ Fin q) |
|
|
| /-- The same leading minor is used at the old and perturbed point. -/ |
| def GoodEndpoint {r s : ℕ} (δ : ℝ) |
| (b : OrthonormalBasis (Fin d) ℝ E) (a : powersetCard (Fin d) r) |
| (u : Fin r → E) (v : Fin s → E) (f : E → E) (x : E) |
| (D₀ : Matrix (Fin r) (Fin r) ℝ) : Prop := |
| ContDiffAt ℝ ∞ f x ∧ D₀.det≠0 ∧ |
| |(endpointMatrix b r a (fderiv ℝ f x) u).det/D₀.det-1|≤(1/100:ℝ) ∧ |
| ∀ i j,|((endpointMatrix b r a (fderiv ℝ f x) u)⁻¹* |
| endpointMatrix b r a (fderiv ℝ f x) v) i j|≤δ |
|
|
| /-- Four actual endpoint maps produce one smooth two-point exchange germ. |
| This is a relative determinant statement at all ranks, in the original |
| physical coordinates. The common nonorthogonal input-basis determinant |
| cancels, including when either block has rank zero. -/ |
| theorem four_endpoint_branch : ∃ δ : ℝ,0<δ ∧ |
| ∀ (U V : Submodule ℝ E) (_ : IsCompl U V) |
| (u : OrthonormalBasis (Fin p) ℝ U) (v : OrthonormalBasis (Fin q) ℝ V) |
| (b₀ b₁ c₀ c₁ : OrthonormalBasis (Fin d) ℝ E) |
| (r₀ r₁ : powersetCard (Fin d) p) (s₀ s₁ : powersetCard (Fin d) q) |
| (f₀ f₁ g₀ g₁ : E → E) (x y z w : E) |
| (A₀ A₁ : Matrix (Fin p) (Fin p) ℝ) (D₀ D₁ : Matrix (Fin q) (Fin q) ℝ), |
| GoodEndpoint δ b₀ r₀ (fun i => (u i:E)) (fun i => (v i:E)) f₀ x A₀ → |
| GoodEndpoint δ b₀ r₀ (fun i => (u i:E)) (fun i => (v i:E)) f₀ z A₀ → |
| GoodEndpoint δ b₁ r₁ (fun i => (u i:E)) (fun i => (v i:E)) f₁ y A₁ → |
| GoodEndpoint δ b₁ r₁ (fun i => (u i:E)) (fun i => (v i:E)) f₁ w A₁ → |
| GoodEndpoint δ c₀ s₀ (fun i => (v i:E)) (fun i => (u i:E)) g₀ x D₀ → |
| GoodEndpoint δ c₀ s₀ (fun i => (v i:E)) (fun i => (u i:E)) g₀ w D₀ → |
| GoodEndpoint δ c₁ s₁ (fun i => (v i:E)) (fun i => (u i:E)) g₁ y D₁ → |
| GoodEndpoint δ c₁ s₁ (fun i => (v i:E)) (fun i => (u i:E)) g₁ z D₁ → |
| coordinates b₀ r₀ (f₀ z)=coordinates b₀ r₀ (f₀ x) → |
| coordinates b₁ r₁ (f₁ w)=coordinates b₁ r₁ (f₁ y) → |
| coordinates c₀ s₀ (g₀ w)=coordinates c₀ s₀ (g₀ x) → |
| coordinates c₁ s₁ (g₁ z)=coordinates c₁ s₁ (g₁ y) → |
| ∃ Φ : E×E → E×E,Φ (x,y)=(z,w) ∧ ContDiffAt ℝ ∞ Φ (x,y) ∧ |
| (81/121:ℝ)≤|(fderiv ℝ Φ (x,y)).det| ∧ |
| |(fderiv ℝ Φ (x,y)).det|≤(121/81:ℝ) ∧ |
| ∀ᶠ t in 𝓝 (x,y), |
| coordinates b₀ r₀ (f₀ (Φ t).1)=coordinates b₀ r₀ (f₀ t.1) ∧ |
| coordinates b₁ r₁ (f₁ (Φ t).2)=coordinates b₁ r₁ (f₁ t.2) ∧ |
| coordinates c₀ s₀ (g₀ (Φ t).2)=coordinates c₀ s₀ (g₀ t.1) ∧ |
| coordinates c₁ s₁ (g₁ (Φ t).1)=coordinates c₁ s₁ (g₁ t.2) := by |
| obtain ⟨δ,hδ,hdet⟩ := joint_controlled_det (d:=d) (p:=p) (q:=q) |
| refine ⟨δ,hδ,?_⟩ |
| intro U V h u v b₀ b₁ c₀ c₁ r₀ r₁ s₀ s₁ f₀ f₁ g₀ g₁ x y z w A₀ A₁ D₀ D₁ |
| hxF hzF hyF hwF hxP hwP hyP hzP heF heF' heP heP' |
| let F₀ := joint b₀ c₀ r₀ s₀ f₀ g₀ |
| let F₁ := joint b₁ c₁ r₁ s₁ f₁ g₁ |
| let G₀ := joint b₀ c₁ r₀ s₁ f₀ g₁ |
| let G₁ := joint b₁ c₀ r₁ s₀ f₁ g₀ |
| have hd {b c : OrthonormalBasis (Fin d) ℝ E} |
| {r : powersetCard (Fin d) p} {s : powersetCard (Fin d) q} |
| {f g : E → E} {t : E} {A : Matrix (Fin p) (Fin p) ℝ} |
| {D : Matrix (Fin q) (Fin q) ℝ} |
| (hf : GoodEndpoint δ b r (fun i => (u i:E)) (fun i => (v i:E)) f t A) |
| (hg : GoodEndpoint δ c s (fun i => (v i:E)) (fun i => (u i:E)) g t D) := |
| hdet U V h u v b c r s f g t A D |
| (hf.1.differentiableAt (by simp)) (hg.1.differentiableAt (by simp)) |
| hf.2.1 hg.2.1 hf.2.2.1 hg.2.2.1 hf.2.2.2 hg.2.2.2 |
| have hF₀ := joint_contDiffAt b₀ c₀ r₀ s₀ hxF.1 hxP.1 |
| have hF₁ := joint_contDiffAt b₁ c₁ r₁ s₁ hyF.1 hyP.1 |
| have hG₀ := joint_contDiffAt b₀ c₁ r₀ s₁ hzF.1 hzP.1 |
| have hG₁ := joint_contDiffAt b₁ c₀ r₁ s₀ hwF.1 hwP.1 |
| have he : Prod.map G₀ G₁ (z,w)=EndpointBranch.sumExchange (Prod.map F₀ F₁ (x,y)) := by |
| ext i <;> cases i <;> |
| simp [F₀,F₁,G₀,G₁,joint,EndpointBranch.sumExchange,EndpointBranch.exchange, |
| EuclideanSpace.sumEquivProd,heF,heF',heP,heP'] |
| obtain ⟨Φ,hΦ,hcd,hlo,hup,heq⟩ := EndpointBranch.physical_controlled_branch |
| (blockMap U V h u v) F₀ F₁ G₀ G₁ x y z w |
| (fderiv ℝ F₀ x) (fderiv ℝ F₁ y) (fderiv ℝ G₀ z) (fderiv ℝ G₁ w) |
| EndpointBranch.sumExchange hF₀ hF₁ hG₀ hG₁ |
| (hF₀.differentiableAt (by simp)).hasFDerivAt |
| (hF₁.differentiableAt (by simp)).hasFDerivAt |
| (hG₀.differentiableAt (by simp)).hasFDerivAt |
| (hG₁.differentiableAt (by simp)).hasFDerivAt he EndpointBranch.sumExchange_abs_det |
| |A₀.det| |D₀.det| |A₁.det| |D₁.det| |
| (abs_pos.mpr hxF.2.1) (abs_pos.mpr hxP.2.1) |
| (abs_pos.mpr hyF.2.1) (abs_pos.mpr hyP.2.1) |
| (hd hxF hxP) (hd hyF hyP) (hd hzF hzP) (hd hwF hwP) |
| refine ⟨Φ,hΦ,hcd,hlo,hup,?_⟩ |
| filter_upwards [heq] with t ht |
| have h₀ := congrArg (fun t : F×F => EuclideanSpace.sumEquivProd t.1) ht |
| have h₁ := congrArg (fun t : F×F => EuclideanSpace.sumEquivProd t.2) ht |
| simp only [G₀,G₁,F₀,F₁,EndpointBranch.sumExchange, |
| ContinuousLinearEquiv.trans_apply,ContinuousLinearEquiv.prodCongr_apply] at h₀ h₁ |
| exact ⟨congrArg Prod.fst h₀,congrArg Prod.fst h₁,congrArg Prod.snd h₁,congrArg Prod.snd h₀⟩ |
| end SmoothObstruction.EndpointFrame |
|
|
| namespace SmoothObstruction.ExteriorStability |
| open Set Matrix EndpointFrame |
| variable {d p q : ℕ} |
| local notation "E₀" => EuclideanSpace ℝ (Fin d) |
|
|
| lemma endpointMatrix_projection (W : Submodule ℝ E₀) |
| (b : OrthonormalBasis (Fin d) ℝ E₀) (r : powersetCard (Fin d) p) |
| (hr : ∀ j∈r,b j∈W) (A : E₀ →L[ℝ] E₀) (v : Fin q → E₀) : |
| endpointMatrix b p r (W.starProjection*A) v=endpointMatrix b p r A v := by |
| ext i j |
| exact congrArg (fun z : EuclideanSpace ℝ (Fin p) => z i) |
| (coordinates_projection W b r hr (A (v j))) |
| end SmoothObstruction.ExteriorStability |
|
|
| namespace SmoothObstruction.EuclideanSplitting |
| open Set Matrix ExteriorStability |
| open scoped Matrix.Norms.L2Operator |
| variable {d p q : ℕ} |
| local notation "E₀" => EuclideanSpace ℝ (Fin d) |
| /-- Actual endpoint-coordinate matrices with a common input frame. The old |
| leading volume, its perturbed relative value, and every true graph entry are |
| controlled together. No lower volume floor, rate sign, positive rank, or |
| orthogonality between the two input groups is required. -/ |
| theorem endpoint_bounds |
| (U V : ℕ → Matrix (Fin d) (Fin d) ℝ) (lam : Fin d → ℝ) |
| (hUV : ∀ t,U t*V t=1) (hVU : ∀ t,V t*U t=1) |
| (S : Finset (Fin d)) (hSp : S.card=p) (n : ℕ) {γ g K C δ : ℝ} |
| (hg : 0≤g) (hK : 0≤K) (hC : 0≤C) (hδ : 0≤δ) |
| (hfast : ∀ j∈S,γ+g≤lam j) (hslow : ∀ j∉S,lam j≤γ-g) |
| (hUs : ‖U 0‖≤Real.exp K) (hUt : ‖U n‖≤Real.exp K) |
| (hVs : ‖V 0‖≤Real.exp K) (hVt : ‖V n‖≤Real.exp K) |
| (hpoly : ∀ A : E₀ →L[ℝ] E₀,‖exterior p A‖≤C*(max 1 ‖A‖)^p) |
| (W G Gslow : Submodule ℝ E₀) (hdim : Module.finrank ℝ W=p) |
| (hend : ‖(groupSpace (U n) (V n) (hUV n) (hVU n) S).starProjection-W.starProjection‖≤1/2) |
| (hstart : ‖(groupSpace (U 0) (V 0) (hUV 0) (hVU 0) S).starProjection-G.starProjection‖≤δ) |
| (hstartSlow : ‖(groupSpace (U 0) (V 0) (hUV 0) (hVU 0) Sᶜ).starProjection-Gslow.starProjection‖≤δ) |
| (b : OrthonormalBasis (Fin d) ℝ E₀) (r : powersetCard (Fin d) p) |
| (hr : ∀ j∈r,b j∈W) (hcoords : ∀ x∈W,∀ j∉r,b.repr x j=0) |
| (v : Fin p → E₀) (horth : Orthonormal ℝ v) (hv : ∀ i,v i∈G) |
| (z : Fin q → E₀) (hz : ∀ j,z j∈Gslow) (hznorm : ∀ j,‖z j‖≤1) |
| (hsmall : (frameWedgeConstant (E := E₀) p*δ)* |
| (1+((C*(Real.exp K)^p)^2*(C*2^p))* |
| (C*(C^2*(Real.exp K)^(2*p)*(Fintype.card (powersetCard (Fin d) p):ℝ))))≤1/2) |
| (B : E₀ →L[ℝ] E₀) {ζ : ℝ} (hζ : 0≤ζ) |
| (hpert : 2*((C*(Real.exp K)^p)^2*(C*2^p))*C*ζ*‖continuousWedge (E := E₀) p‖<1) |
| (hdiff : ‖exterior p B- |
| exterior p (Matrix.toEuclideanCLM (n := Fin d) (𝕜 := ℝ) (transition U V lam 0 n))‖≤ |
| ζ*Real.exp ((n:ℝ)*(∑ j∈S,lam j))) : |
| let A₀ := endpointMatrix b p r |
| (Matrix.toEuclideanCLM (n := Fin d) (𝕜 := ℝ) (transition U V lam 0 n)) v |
| let A := endpointMatrix b p r B v |
| let H := endpointMatrix b p r B z |
| let L₀ := (C*(Real.exp K)^p)^2*(C*2^p) |
| let N₀ := C*(C^2*(Real.exp K)^(2*p)*(Fintype.card (powersetCard (Fin d) p):ℝ)) |
| let N₁ := C*(C*(Real.exp K)^p)^2*(Fintype.card (powersetCard (Fin d) p):ℝ)*‖continuousWedge (E := E₀) p‖ |
| let θ := 2*L₀*(N₁*Real.exp (-2*g*n)+N₀*unitWedgeConstant (E := E₀) p*δ) |
| let ε := 2*L₀*C*ζ*‖continuousWedge (E := E₀) p‖ |
| A₀.det≠0 ∧ A.det≠0 ∧ |A.det/A₀.det-1|≤ε ∧ ∀ i j,|(A⁻¹*H) i j|≤(θ+ε)/(1-ε) := by |
| subst p |
| have hl := common_leading_relative_transfer U V lam hUV hVU S (Nat.zero_le n) |
| hg hK hC hδ hfast hslow hUs hUt hVs hVt hpoly W G hdim hend hstart b r hcoords |
| v horth hv hsmall B hζ hpert (by simpa only [Nat.cast_zero,sub_zero] using hdiff) |
| have hh := common_perturbed_endpoint_graph_bound U V lam hUV hVU S (Nat.zero_le n) |
| hg hK hC hδ hfast hslow hUs hUt hVs hVt hpoly W G hdim hend hstart b r hcoords |
| v horth hv Gslow hstartSlow z hz hznorm hsmall B hζ hpert |
| (by simpa only [Nat.cast_zero,sub_zero] using hdiff) |
| dsimp only at hl hh ⊢ |
| simp only [←endpointMatrix_det,endpointMatrix_projection W b r hr] at hl |
| simp only [endpointMatrix_projection W b r hr,Nat.cast_zero,sub_zero] at hh |
| exact ⟨hl.1,hl.2.1,hl.2.2,hh.2⟩ |
| end SmoothObstruction.EuclideanSplitting |
|
|
| namespace SmoothObstruction.ManifoldCoordinates |
| open Set Metric EuclideanSplitting ExteriorStability EndpointFrame |
| open scoped ContDiff Matrix.Norms.L2Operator |
| variable {d : ℕ} {H : Type*} [TopologicalSpace H] |
| (I : ModelWithCorners ℝ (EuclideanSpace ℝ (Fin d)) H) |
| {M : Type*} [TopologicalSpace M] [T2Space M] [ChartedSpace H M] [IsManifold I ∞ M] |
| {ι : Type*} [Fintype ι] |
| local notation "E₀" => EuclideanSpace ℝ (Fin d) |
|
|
| /-- A genuine old-chart endpoint map has the controlled minor used in the |
| four-equation inverse theorem. Every nonlinear derivative estimate is derived |
| from the original orbit tube and the real one-step gauge. Constants precede |
| all ranks, bins, times and gauge choices. -/ |
| theorem actual_endpoint_minor (hclosed : IsClosed (range I)) |
| (S : Diffeomorph I I M M ∞) (a : ι → M) (L : ι → Set M) |
| (hL : ∀ i,IsCompact (L i)) (hLU : ∀ i,L i⊆(chartAt H (a i)).source) |
| (Dg : ℝ) (hDg : 0≤Dg) : |
| ∃ r K₀ Crel C₁ : ℝ,0<r ∧ 1≤K₀ ∧ 0≤Crel ∧ 0≤C₁ ∧ |
| ∀ {p q : ℕ} (c : M → ι) (x y : M) (m : ℕ) |
| (U V : ℕ → Matrix (Fin d) (Fin d) ℝ) (lam : Fin d → ℝ) |
| (T : Finset (Fin d)) (_ : T.card=p) (γ g K b n R C δ β : ℝ), |
| (∀ z,z∈L (c z)) → 0≤b → 0≤n → 1≤b*n → 0≤R → |
| 0≤g → 0≤K → K≤Dg*(b*n) → (m : ℝ)≤2*n → 0≤C → 0≤δ → |
| ∀ (hUV : ∀ t,U t*V t=1) (hVU : ∀ t,V t*U t=1), |
| (∀ t < m,(Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ)).symm |
| (coord I S (a (c (S^[t] x))) (a (c (S^[t+1] x))) (S^[t] x))*U t= |
| U (t+1)*rate lam 1) → |
| (∀ i,|lam i|≤R) → (∀ j∈T,γ+g≤lam j) → (∀ j∉T,lam j≤γ-g) → |
| (∀ t ≤ m,‖U t‖≤Real.exp K) → (∀ t ≤ m,‖V t‖≤Real.exp K) → |
| K₀*Real.exp (-(3/2:ℝ)*SmoothScales.B b*n)≤1 → |
| Real.exp (-(3/2:ℝ)*SmoothScales.B b*n)≤r → |
| (∀ t ≤ m,(S^[t]) y∈(extChartAt I (a (c (S^[t] x)))).source) → |
| (∀ t ≤ m,‖(extChartAt I (a (c (S^[t] x)))) (S^[t] y)- |
| (extChartAt I (a (c (S^[t] x)))) (S^[t] x)‖≤ |
| Real.exp (-(3/2:ℝ)*SmoothScales.B b*n)) → |
| (∀ t ≤ m,closedBall ((extChartAt I (a (c (S^[t] x)))) (S^[t] x)) |
| (Real.exp (-(3/2:ℝ)*SmoothScales.B b*n))⊆interior (range I)) → |
| (∀ A : E₀ →L[ℝ] E₀,‖exterior p A‖≤C*(max 1 ‖A‖)^p) → |
| ∀ (W G Gslow : Submodule ℝ E₀) (_ : Module.finrank ℝ W=p), |
| (‖(groupSpace (U m) (V m) (hUV m) (hVU m) T).starProjection- |
| W.starProjection‖≤1/2) → |
| (‖(groupSpace (U 0) (V 0) (hUV 0) (hVU 0) T).starProjection- |
| G.starProjection‖≤δ) → |
| (‖(groupSpace (U 0) (V 0) (hUV 0) (hVU 0) Tᶜ).starProjection- |
| Gslow.starProjection‖≤δ) → |
| ∀ (bE : OrthonormalBasis (Fin d) ℝ E₀) (rE : powersetCard (Fin d) p), |
| (∀ j∈rE,bE j∈W) → (∀ v∈W,∀ j∉rE,bE.repr v j=0) → |
| ∀ (v : Fin p → E₀) (z : Fin q → E₀),Orthonormal ℝ v → |
| (∀ i,v i∈G) → (∀ j,z j∈Gslow) → (∀ j,‖z j‖≤1) → |
| let L₀ := (C*(Real.exp K)^p)^2*(C*2^p) |
| let N₀ := C*(C^2*(Real.exp K)^(2*p)*(Fintype.card (powersetCard (Fin d) p) : ℝ)) |
| let N₁ := C*(C*(Real.exp K)^p)^2*(Fintype.card (powersetCard (Fin d) p) : ℝ)*‖continuousWedge (E := E₀) p‖ |
| let ζ := RelativeAsymptotics.envelope Crel 0 C₁ (d*R) K₀ b n * |
| Real.exp (RelativeAsymptotics.envelope Crel 0 C₁ (d*R) K₀ b n) |
| let ε := 2*L₀*C*ζ*‖continuousWedge (E := E₀) p‖ |
| let θ := 2*L₀*(N₁*Real.exp (-2*g*m)+N₀*unitWedgeConstant (E := E₀) p*δ) |
| (frameWedgeConstant (E := E₀) p*δ)*(1+L₀*N₀)≤1/2 → |
| ε≤1/100 → (θ+ε)/(1-ε)≤β → |
| let F := extChartAt I (a (c (S^[m] x))) ∘ S^[m] ∘ (extChartAt I (a (c x))).symm |
| GoodEndpoint β bE rE v z F ((extChartAt I (a (c x))) y) |
| (endpointMatrix bE p rE (fderiv ℝ F ((extChartAt I (a (c x))) x)) v) := by |
| obtain ⟨r,K₀,Crel,C₁,hr,hK₀,hCrel,hC₁,hrel⟩ := |
| actual_endpoint_relative I hclosed S a L hL hLU Dg hDg |
| refine ⟨r,K₀,Crel,C₁,hr,hK₀,hCrel,hC₁,?_⟩ |
| intro p q c x y m U V lam T hTp γ g K b n R C δ β hc hb hn hbn hR |
| hg hK hKD hm hC hδ hUV hVU hstep hlam hfast hslow hU hV hε hεr |
| hychart htube hsafe hpoly W G Gslow hdim hend hstart hstartSlow bE rE hrE hcoords |
| v z horth hv hz hznorm L₀ N₀ N₁ ζ ε θ hsmall hεsmall hgraph F |
| subst p |
| let p := T.card |
| let ca (t : ℕ) := a (c (S^[t] x)) |
| have hxchart (t : ℕ) : S^[t] x∈(extChartAt I (ca t)).source := by |
| simpa only [extChartAt_source,ca] using hLU (c (S^[t] x)) (hc (S^[t] x)) |
| have hxint (t : ℕ) (ht : t ≤ m) : |
| (extChartAt I (ca t)) (S^[t] x)∈interior (range I) := |
| hsafe t ht (mem_closedBall_self (Real.exp_nonneg _)) |
| have hyint (t : ℕ) (ht : t ≤ m) : |
| (extChartAt I (ca t)) (S^[t] y)∈interior (range I) := |
| hsafe t ht (mem_closedBall.mpr (by simpa only [dist_eq_norm] using htube t ht)) |
| have hd := actual_endpoint_differential I S ca x m U V lam |
| (fun t _ => hxchart t) hxint hUV hVU hstep |
| have hcd := actual_endpoint_smooth I S ca y m hychart hyint |
| have hdf := hd.fderiv |
| change fderiv ℝ F ((extChartAt I (a (c x))) x)=_ at hdf |
| have hpert := hrel c x y m U V lam T γ g K b n 0 R hc hb hn hbn (by norm_num) |
| hR hg hK hKD hm hUV hVU hstep hlam hfast hslow hU hV hε hεr hychart htube hsafe |
| simp only [zero_mul,sub_zero] at hpert |
| rw [hdf] at hpert |
| have hdiff : ‖exterior p (fderiv ℝ F ((extChartAt I (a (c x))) y))- |
| exterior p (Matrix.toEuclideanCLM (n:=Fin d) (𝕜:=ℝ) (transition U V lam 0 m))‖≤ |
| ζ*Real.exp ((m : ℝ)*(∑ j∈T,lam j)) := by |
| simpa only [F,ζ,mul_comm (m : ℝ)] using (div_le_iff₀ (Real.exp_pos _)).mp hpert |
| have hζ : 0≤ζ := by dsimp [ζ,RelativeAsymptotics.envelope]; positivity |
| have heps : ε<1 := lt_of_le_of_lt hεsmall (by norm_num) |
| have hminor := endpoint_bounds U V lam hUV hVU T rfl m hg hK hC hδ hfast hslow |
| (hU 0 (Nat.zero_le m)) (hU m le_rfl) (hV 0 (Nat.zero_le m)) (hV m le_rfl) |
| hpoly W G Gslow hdim hend hstart hstartSlow bE rE hrE hcoords |
| v horth hv z hz hznorm hsmall (fderiv ℝ F ((extChartAt I (a (c x))) y)) hζ heps hdiff |
| change ContDiffAt ℝ ∞ F ((extChartAt I (a (c x))) y) at hcd |
| dsimp only [GoodEndpoint] |
| rw [hdf] |
| exact ⟨hcd,hminor.1,hminor.2.2.1.trans hεsmall, |
| fun i j => (hminor.2.2.2 i j).trans hgraph⟩ |
| end SmoothObstruction.ManifoldCoordinates |
|
|
| end |
|
|
| end OAI |
|
|
