Add lean source and binary files (part 76)

lean/OAI/Geometry/SplitTangent/GlobalProducts.lean

@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.CoveringProductBackend
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.HolomorphicLocalDiffeomorph
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.ProductCriteria
+
+namespace OAI
+
+/-! Global Products. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+namespace SplitTangent
+universe u
+
+ 
+
+def compact_analytic_diffeomorph {X Y : ComplexManifold.{u}}
+    [CompactSpace X.Carrier] [ConnectedSpace X.Carrier] [SimplyConnectedSpace Y.Carrier]
+    (f : X.Carrier → Y.Carrier)
+    (hf : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω f)
+    (hb : ∀x, Function.Bijective (mfderiv (ModelWithCorners X) (ModelWithCorners Y) f x)) :
+    Diffeomorph (ModelWithCorners X) (ModelWithCorners Y) X.Carrier Y.Carrier ω := by
+  let : LocallyPathConnectedSpace Y.Carrier := ChartedSpace.locallyPathConnectedSpace (Model Y) Y.Carrier
+  have hl : IsLocalDiffeomorph (ModelWithCorners X) (ModelWithCorners Y) ω f :=
+    fun x => HolomorphicLocalDiffeomorph.manifold_ift (hf x) (hb x)
+  exact hl.diffeomorphOfBijective
+    (CoveringProductBackend.compact_local_homeomorph_bijective hl.isLocalHomeomorph)
+
+namespace TangentSplitting
+variable {X : ComplexManifold.{u}} (S : TangentSplitting X)
+
+ 
+
+theorem compatible_product_of_quotients [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+    (e : ProjectiveEmbedding X) (Y Z : ComplexManifold.{u})
+    [SimplyConnectedSpace Y.Carrier] [SimplyConnectedSpace Z.Carrier]
+    (q₁ : X.Carrier → Y.Carrier) (q₂ : X.Carrier → Z.Carrier)
+    (hq₁ : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω q₁)
+    (hq₂ : ContMDiff (ModelWithCorners X) (ModelWithCorners Z) ω q₂)
+    (hs₁ : ∀x, Function.Surjective (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x))
+    (hs₂ : ∀x, Function.Surjective (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x))
+    (hk₁ : ∀x, LinearMap.ker (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x).toLinearMap=
+      S.second x)
+    (hk₂ : ∀x, LinearMap.ker (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x).toLinearMap=
+      S.first x) : HasCompatibleProjectiveProduct X S := by
+  let : ChartedSpace (Model Y × Model Z) (Y.Carrier × Z.Carrier) :=
+    prodChartedSpace (Model Y) Y.Carrier (Model Z) Z.Carrier
+  let : IsManifold 𝓘(ℂ,Model Y × Model Z) ω (Y.Carrier × Z.Carrier) := by
+    rw [modelWithCornersSelf_prod]
+    exact IsManifold.prod Y.Carrier Z.Carrier
+  let q : X.Carrier → Y.Carrier × Z.Carrier := fun x => (q₁ x,q₂ x)
+  let I := (ModelWithCorners Y).prod (ModelWithCorners Z)
+  have hq : ContMDiff (ModelWithCorners X) I ω q := hq₁.prodMk hq₂
+  have hd (x : X.Carrier) : mfderiv (ModelWithCorners X) I q x=
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x).prod
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x) :=
+    mfderiv_prodMk ((hq₁ x).mdifferentiableAt (by simp)) ((hq₂ x).mdifferentiableAt (by simp))
+  have hb (x : X.Carrier) : Function.Bijective (mfderiv (ModelWithCorners X) I q x) := by
+    rw [hd]
+    exact HolomorphicFrobenius.complementary_quotients_bijective
+      (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+      (S.idempotent x) _ _ (hs₁ x) (hs₂ x) (hk₁ x) (hk₂ x)
+  let : SimplyConnectedSpace (Y.Carrier × Z.Carrier) :=
+    CoveringProductBackend.simplyConnected_product
+  let : LocallyPathConnectedSpace Y.Carrier := ChartedSpace.locallyPathConnectedSpace (Model Y) Y.Carrier
+  let : LocallyPathConnectedSpace Z.Carrier := ChartedSpace.locallyPathConnectedSpace (Model Z) Z.Carrier
+  have hl : IsLocalDiffeomorph (ModelWithCorners X) I ω q := by
+    intro x
+    have hI : I=𝓘(ℂ,Model Y × Model Z) := modelWithCornersSelf_prod.symm
+    rw [hI] at hq hb ⊢
+    exact HolomorphicLocalDiffeomorph.manifold_ift (hq x) (hb x)
+  let f : Diffeomorph (ModelWithCorners X) I X.Carrier (Y.Carrier × Z.Carrier) ω :=
+    hl.diffeomorphOfBijective
+      (CoveringProductBackend.compact_local_homeomorph_bijective hl.isLocalHomeomorph)
+  have hf : (f : X.Carrier → Y.Carrier × Z.Carrier)=q := rfl
+  obtain ⟨hY,hZ⟩ := isProjective_factors e f
+  refine ⟨Y,Z,hY,hZ,f,?_⟩
+  intro x
+  change Submodule.map (mfderiv (ModelWithCorners X) I q x).toLinearMap (S.first x)=_ ∧
+    Submodule.map (mfderiv (ModelWithCorners X) I q x).toLinearMap (S.second x)=_
+  rw [hd]
+  exact ⟨HolomorphicFrobenius.image_range_projector_of_quotients
+    (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+    (S.idempotent x) _ _ (hs₁ x) (hk₁ x) (hk₂ x),
+    HolomorphicFrobenius.image_kernel_projector_of_quotients
+    (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+    (S.idempotent x) _ _ (hs₂ x) (hk₁ x) (hk₂ x)⟩
+
+end TangentSplitting
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/GlobalTensorVanishing.lean

@@ -0,0 +1,161 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.FormalBoxes
+import OAI.Geometry.SplitTangent.RationalTrivialization
+import OAI.Geometry.SplitTangent.TwistedCurveTensor
+
+namespace OAI
+
+/-! Global Tensor Vanishing. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+lemma tangentTensorCoordinates_zero_iff {X : ComplexManifold.{u}} {m : ℕ}
+    {g : ℂ → X.Carrier} {A : ℂ → TangentTensor X m} {z₀ z : ℂ}
+    (hz : g z∈(trivializationAt (Model X) (Tangent X) (g z₀)).baseSet) :
+    tangentTensorCoordinates g A z₀ z=0 ↔ A z=0 := by
+  let t := trivializationAt (Model X) (Tangent X) (g z₀)
+  constructor
+  · intro h
+    apply ContinuousMultilinearMap.ext
+    intro v
+    have h' := congrArg (fun B : TangentTensor X m => B (fun i => t.continuousLinearMapAt ℂ (g z) (v i))) h
+    change A z (fun i => t.symmL ℂ (g z) (t.continuousLinearMapAt ℂ (g z) (v i)))=0 at h'
+    have he : (fun i => t.symmL ℂ (g z)
+        (t.continuousLinearMapAt ℂ (g z) (v i))) = v := by
+      funext i
+      exact t.symmL_continuousLinearMapAt hz (v i)
+    rw [he] at h'
+    exact h'
+  · intro h
+    apply ContinuousMultilinearMap.ext
+    intro v
+    simp [tangentTensorCoordinates,h]
+    rfl
+
+namespace TwistedCurveTensor
+variable {X : ComplexManifold.{u}} {g : RationalCurve X} {d m : ℕ}
+
+ 
+
+theorem finite_zero_of_eventually {d : ℤ} (A : TwistedCurveTensor g d m)
+    {z₀ : ℂ} (h : ∀ᶠz in 𝓝 z₀,A.finite z=0) : ∀z,A.finite z=0 := by
+  have hall : (Set.univ : Set ℂ)⊆{z | A.finite z=0} := by
+    apply AnalyticContinuation.subset_of_local_analytic_equations (F := TangentTensor X m) isPreconnected_univ
+    · intro z hz
+      refine ⟨tangentTensorCoordinates g.finite A.finite z,A.finite_holomorphic z,?_⟩
+      let t := trivializationAt (Model X) (Tangent X) (g.finite z)
+      have hbase : g.finite z∈t.baseSet := FiberBundle.mem_baseSet_trivializationAt' _
+      filter_upwards [g.finite_holomorphic.continuous.continuousAt.preimage_mem_nhds
+        (t.open_baseSet.mem_nhds hbase)] with w hw
+      exact (tangentTensorCoordinates_zero_iff hw).symm
+    · exact ⟨z₀,Set.mem_univ _,mem_interior_iff_mem_nhds.mpr h⟩
+  exact fun z => hall (Set.mem_univ z)
+
+ 
+
+theorem finite_zero_of_pointedGenerated (A : TwistedCurveTensor g (d : ℤ) m)
+    (S : TangentSplitting X) (hg : PointedGenerated g S.first) (hdm : d < m)
+    (hSupport : ∀z v,A.finite z (fun i => S.projector (g.finite z) (v i))=A.finite z v) :
+    ∀z,A.finite z=0 := by
+  classical
+  let t := trivializationAt (Model X) (Tangent X) (g.finite 1)
+  let c := chartAt (Model X) (g.finite 1)
+  let b := Pi.basisFun ℂ (Fin X.dim)
+  let a (j : Fin X.dim) := S.projector (g.finite 1) (t.symmL ℂ (g.finite 1) (b j))
+  have ha : ∀j,a j∈S.first (g.finite 1) := fun j => ⟨_,rfl⟩
+  choose σ hσf hσi hσ0 hσ1 using fun j => hg (a j) (ha j)
+  let w (j : Fin X.dim) (z : ℂ) :=
+    (t (⟨g.finite z,(σ j).finite z⟩ : TangentBundle (ModelWithCorners X) X.Carrier)).2
+  let M (z : ℂ) : Model X →L[ℂ] Model X :=
+    ∑j,(ContinuousLinearMap.proj j).smulRight (w j z)
+  let P (z : ℂ) := S.coordinateProjector (g.finite 1) (c (g.finite z))
+  have hMb : ∀z j,M z (b j)=w j z := by
+    intro z j
+    simp [M,b,Pi.basisFun_apply]
+  have hM : ContinuousAt M 1 := by
+    apply tendsto_finsetSum
+    intro j hj
+    exact (ContinuousLinearMap.smulRightL ℂ (Model X) (Model X)
+      (ContinuousLinearMap.proj j)).continuous.continuousAt.comp
+        (section_coordinates_analytic (σ j).finite_holomorphic 1).continuousAt
+  have hP : ContinuousAt P 1 := by
+    have hc : AnalyticAt ℂ (c ∘ g.finite) (1 : ℂ) :=
+      TangentSplitting.coordinateCurve_analytic g.finite_holomorphic (g.finite 1) (mem_chart_source _ _)
+    have hp := (S.coordinateProjector_analytic (g.finite 1) _
+      (c.map_source (mem_chart_source _ _))).comp (f := c ∘ g.finite) (x := (1 : ℂ)) hc
+    exact hp.continuousAt
+  have hbase : ∀ᶠz in 𝓝 (1 : ℂ),g.finite z∈t.baseSet :=
+    g.finite_holomorphic.continuous.continuousAt.preimage_mem_nhds
+      (t.open_baseSet.mem_nhds (FiberBundle.mem_baseSet_trivializationAt' _))
+  have hPw : ∀z,g.finite z∈t.baseSet → ∀j,P z (w j z)=w j z := by
+    intro z hz j
+    change S.coordinateProjector (g.finite 1) (c (g.finite z))
+      (t (⟨g.finite z,(σ j).finite z⟩ : TangentBundle (ModelWithCorners X) X.Carrier)).2=_
+    rw [← t.continuousLinearMapAt_apply_of_mem ℂ hz,S.coordinateProjector_fixed _ hz,
+      (S.mem_first_iff _ _).mp (hσf j z)]
+    exact t.continuousLinearMapAt_apply_of_mem ℂ hz _
+  have hx : M 1=P 1 := by
+    apply ContinuousLinearMap.coe_injective
+    apply b.ext
+    intro j
+    change M 1 (b j)=P 1 (b j)
+    rw [hMb]
+    dsimp only [w]
+    rw [hσ1]
+    change (t (⟨g.finite 1,S.projector (g.finite 1) (t.symmL ℂ (g.finite 1) (b j))⟩ :
+      TangentBundle (ModelWithCorners X) X.Carrier)).2=P 1 (b j)
+    rw [← t.continuousLinearMapAt_apply_of_mem ℂ (FiberBundle.mem_baseSet_trivializationAt' _)]
+    dsimp only [P,TangentSplitting.coordinateProjector]
+    rw [c.left_inv (mem_chart_source _ _)]
+    rfl
+  have hPP : ∀ᶠz in 𝓝 (1 : ℂ),∀v,P z (P z v)=P z v := by
+    filter_upwards [hbase] with z hz
+    exact S.coordinateProjector_idempotent _ (c.map_source hz)
+  have hPM : ∀ᶠz in 𝓝 (1 : ℂ),∀v,P z (M z v)=M z v := by
+    filter_upwards [hbase] with z hz
+    intro v
+    simp only [M,sum_apply,ContinuousLinearMap.smulRight_apply,map_sum,map_smul,
+      hPw z hz]
+  have hRange := ProjectorSpanning.eventually_range_eq hP hM hx hPP hPM
+  apply A.finite_zero_of_eventually (z₀ := 1)
+  filter_upwards [hbase,hRange] with z hz hRange
+  let B := tangentTensorCoordinates g.finite A.finite 1 z
+  have hB : ∀j : Fin m → Fin X.dim,B (fun i => M z (b (j i)))=0 := by
+    intro j
+    have hc := A.contract_zero hdm (fun i => σ (j i)) (fun i => hσ0 (j i))
+    have hv := congrArg (fun s : DiagonalRationality.lineSections (d : ℤ) => s.val.1 z) hc
+    change A.finite z (fun i => (σ (j i)).finite z)=0 at hv
+    have he (i : Fin m) : t.symmL ℂ (g.finite z) (M z (b (j i))) =
+        (σ (j i)).finite z := by
+      rw [hMb]
+      change t.symmL ℂ (g.finite z) (t (⟨g.finite z,(σ (j i)).finite z⟩ :
+        TangentBundle (ModelWithCorners X) X.Carrier)).2=_
+      rw [← t.continuousLinearMapAt_apply_of_mem ℂ hz,t.symmL_continuousLinearMapAt hz]
+    change A.finite z (fun i => t.symmL ℂ (g.finite z) (M z (b (j i)))) = 0
+    exact (congrArg (A.finite z) (funext he)).trans hv
+  apply ContinuousMultilinearMap.ext
+  intro v
+  rw [← hSupport z v]
+  have hv : ∀i,t.continuousLinearMapAt ℂ (g.finite z) (S.projector (g.finite z) (v i))∈
+      LinearMap.range (M z).toLinearMap := by
+    intro i
+    rw [hRange]
+    exact ⟨t.continuousLinearMapAt ℂ (g.finite z) (v i),S.coordinateProjector_fixed _ hz _⟩
+  have h := ProjectorSpanning.multilinear_zero_of_basis_range (M z) B hB _ hv
+  change A.finite z (fun i => t.symmL ℂ (g.finite z)
+    (t.continuousLinearMapAt ℂ (g.finite z) (S.projector (g.finite z) (v i))))=0 at h
+  simpa only [t.symmL_continuousLinearMapAt hz,zero_apply] using h
+
+end TwistedCurveTensor
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/GlobalTopologicalProduct.lean

@@ -0,0 +1,128 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.SwappedProductChart
+import OAI.Geometry.SplitTangent.CompactLeafQuotient
+import OAI.Geometry.SplitTangent.ArbitraryPlaqueLeaves
+import OAI.Geometry.SplitTangent.ComplementaryLeafIntersections
+
+namespace OAI
+
+/-! Global Topological Product. -/
+
+noncomputable section
+open Set Filter Topology TopologicalSpace
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (M : LeafJetAtlas S.swap) (e : ProjectiveEmbedding X)
+  (hRC : RationallyConnected e) (hdim : 0<X.dim)
+
+def leafPair (x : X.Carrier) :
+    L.CompactLeafSpace e hRC hdim × M.CompactLeafSpace e hRC hdim :=
+  (L.leafQuotient e hRC hdim x,M.leafQuotient e hRC hdim x)
+
+lemma continuous_leafPair : Continuous (L.leafPair M e hRC hdim) :=
+  (L.continuous_leafQuotient e hRC hdim).prodMk (M.continuous_leafQuotient e hRC hdim)
+
+lemma leafPair_rectangle_image
+    {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+    [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {U : Set A} {V : Set B}
+    (hUc : IsPreconnected U) (hVc : IsPreconnected V)
+    (hrect : U ×ˢ V ⊆ P.chart.target) :
+    L.leafPair M e hRC hdim '' (P.chart.symm '' (U ×ˢ V))=
+      (L.leafQuotient e hRC hdim '' (P.chart.symm '' (U ×ˢ V))) ×ˢ
+      (M.leafQuotient e hRC hdim '' (P.chart.symm '' (U ×ˢ V))) := by
+  ext t
+  constructor
+  · rintro ⟨x,hx,rfl⟩
+    exact ⟨⟨x,hx,rfl⟩,⟨x,hx,rfl⟩⟩
+  · rintro ⟨⟨x,⟨⟨a,b⟩,⟨ha,hb⟩,rfl⟩,hx⟩,⟨y,⟨⟨c,d⟩,⟨hc,hd⟩,rfl⟩,hy⟩⟩
+    refine ⟨P.chart.symm (c,b),⟨(c,b),⟨hc,hb⟩,rfl⟩,Prod.ext ?_ ?_⟩
+    · change L.leafQuotient e hRC hdim (P.chart.symm (c,b))=t.1
+      rw [←hx]
+      apply (L.leafQuotient_eq_iff e hRC hdim _ _).mpr
+      exact L.arbitrary_plaque_mem_leaf P hUc (fun k hk => hrect ⟨hk,hb⟩) hc ha
+    · change M.leafQuotient e hRC hdim (P.chart.symm (c,b))=t.2
+      rw [←hy]
+      apply (M.leafQuotient_eq_iff e hRC hdim _ _).mpr
+      exact M.arbitrary_plaque_mem_leaf P.swap (b := c) hVc (fun k hk => by
+        rw [AlignedProductChart.swap_target]
+        change (c,k)∈P.chart.target
+        exact hrect ⟨hc,hk⟩) hb hd
+
+lemma leafPair_rectangle_image_open
+    {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+    [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {U : Set A} {V : Set B}
+    (hU : IsOpen U) (hUc : IsPreconnected U) (hV : IsOpen V) (hVc : IsPreconnected V)
+    (hrect : U ×ˢ V ⊆ P.chart.target) :
+    IsOpen (L.leafPair M e hRC hdim '' (P.chart.symm '' (U ×ˢ V))) := by
+  rw [L.leafPair_rectangle_image M e hRC hdim P hUc hVc hrect]
+  have hopen := P.chart.symm.isOpen_image_of_subset_source (hU.prod hV) hrect
+  exact (L.isOpenMap_leafQuotient e hRC hdim _ hopen).prod
+    (M.isOpenMap_leafQuotient e hRC hdim _ hopen)
+
+lemma isOpenMap_leafPair : IsOpenMap (L.leafPair M e hRC hdim) := by
+  intro W hW
+  apply isOpen_iff_mem_nhds.mpr
+  rintro q ⟨x,hx,rfl⟩
+  let P := L.chart x
+  have hxs := L.mem_source x
+  have hxt := P.chart.map_source hxs
+  have hN : P.chart.target ∩ P.chart.symm ⁻¹' W∈𝓝 (P.chart x) :=
+    Filter.inter_mem (P.chart.open_target.mem_nhds hxt)
+      ((P.chart.symm.continuousAt hxt).preimage_mem_nhds (by
+        rw [P.chart.left_inv hxs]
+        exact hW.mem_nhds hx))
+  obtain ⟨r,hr,hsub⟩ := Metric.mem_nhds_iff.mp hN
+  let U := Metric.ball (P.chart x).1 r
+  let V := Metric.ball (P.chart x).2 r
+  have hrect : U ×ˢ V ⊆ P.chart.target ∩ P.chart.symm ⁻¹' W := by
+    intro p hp
+    apply hsub
+    simpa only [U,V,Set.mem_prod,Metric.mem_ball,Prod.dist_eq,max_lt_iff] using hp
+  have hopen := L.leafPair_rectangle_image_open M e hRC hdim P Metric.isOpen_ball
+    (convex_ball _ _).isPreconnected Metric.isOpen_ball (convex_ball _ _).isPreconnected
+    (fun p hp => (hrect hp).1)
+  have hxin : x∈P.chart.symm '' (U ×ˢ V) :=
+    ⟨P.chart x,⟨Metric.mem_ball_self hr,Metric.mem_ball_self hr⟩,P.chart.left_inv hxs⟩
+  apply Filter.mem_of_superset (hopen.mem_nhds ⟨x,hxin,rfl⟩)
+  rintro q ⟨y,⟨p,hp,rfl⟩,rfl⟩
+  exact ⟨P.chart.symm p,(hrect hp).2,rfl⟩
+
+lemma surjective_leafPair : Function.Surjective (L.leafPair M e hRC hdim) := by
+  have hc : IsClopen (range (L.leafPair M e hRC hdim)) :=
+    ⟨(isCompact_range (L.continuous_leafPair M e hRC hdim)).isClosed,
+      by simpa only [Set.image_univ] using L.isOpenMap_leafPair M e hRC hdim Set.univ isOpen_univ⟩
+  exact Set.range_eq_univ.mp (hc.eq_univ (Set.range_nonempty _))
+
+lemma leafPair_fiber_eq (x : X.Carrier) :
+    {y | L.leafPair M e hRC hdim y=L.leafPair M e hRC hdim x}=L.leaf x ∩ M.leaf x := by
+  ext y
+  change ((L.leafQuotient e hRC hdim y,M.leafQuotient e hRC hdim y)=
+    (L.leafQuotient e hRC hdim x,M.leafQuotient e hRC hdim x)) ↔ _
+  rw [Prod.mk.injEq]
+  constructor
+  · intro h
+    exact ⟨(L.leafQuotient_eq_iff e hRC hdim x y).mp h.1.symm,
+      (M.leafQuotient_eq_iff e hRC hdim x y).mp h.2.symm⟩
+  · intro h
+    exact ⟨((L.leafQuotient_eq_iff e hRC hdim x y).mpr h.1).symm,
+      ((M.leafQuotient_eq_iff e hRC hdim x y).mpr h.2).symm⟩
+
+lemma leafPair_fiber_finite (q : L.CompactLeafSpace e hRC hdim × M.CompactLeafSpace e hRC hdim) :
+    {x | L.leafPair M e hRC hdim x=q}.Finite := by
+  obtain ⟨x,rfl⟩ := L.surjective_leafPair M e hRC hdim q
+  rw [L.leafPair_fiber_eq M e hRC hdim x]
+  exact L.complementary_leaves_finite M e hRC hdim x x
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicBasicTransport.lean

@@ -0,0 +1,112 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.LeafPlaques
+import OAI.Geometry.SplitTangent.ArbitraryPlaqueLeaves
+
+namespace OAI
+
+/-! Holomorphic Basic Transport. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+  {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+
+ 
+def Basic (f : X.Carrier → E) : Prop := ∀x y,y∈L.leaf x → f x=f y
+
+variable {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+
+lemma basic_contMDiffAt_rectangle (P : AlignedProductChart S A B)
+    {U : Set A} {V : Set B} (hU : IsOpen U) (hUc : IsPreconnected U) (hV : IsOpen V)
+    (hrect : U ×ˢ V⊆P.chart.target) {a c : A} {b : B}
+    (ha : a∈U) (hc : c∈U) (hb : b∈V)
+    {f : X.Carrier → E} (hbasic : L.Basic f)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (a,b))) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (c,b)) := by
+  let x := P.chart.symm (c,b)
+  let H : X.Carrier → X.Carrier := fun y => P.chart.symm (a,(P.chart y).2)
+  have hxt : (c,b)∈P.chart.target := hrect ⟨hc,hb⟩
+  have hxs : x∈P.chart.source := P.chart.map_target hxt
+  have hx : P.chart x=(c,b) := P.chart.right_inv hxt
+  have hN : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,A × B) ω
+      (fun y => (a,(P.chart y).2)) x :=
+    contMDiffAt_const.prodMk_space
+      ((ContinuousLinearMap.snd ℂ A B).contDiff.contMDiff.contMDiffAt.comp x
+        (P.holomorphicAt hxs))
+  have hH : ContMDiffAt (ModelWithCorners X) (ModelWithCorners X) ω H x := by
+    apply ContMDiffAt.comp x _ hN
+    apply P.inverse_holomorphicAt
+    simpa only [hx] using hrect ⟨ha,hb⟩
+  have hHx : H x=P.chart.symm (a,b) := by simp only [H,hx]
+  have hcomp : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω (f ∘ H) x := by
+    apply ContMDiffAt.comp x _ hH
+    rwa [hHx]
+  apply hcomp.congr_of_eventuallyEq
+  have hnear : ∀ᶠ y in 𝓝 x,y∈P.chart.source ∧ P.chart y∈U ×ˢ V :=
+    Filter.Eventually.and (P.chart.open_source.mem_nhds hxs)
+      ((P.chart.continuousAt hxs).preimage_mem_nhds (by
+        rw [hx]
+        exact (hU.prod hV).mem_nhds ⟨hc,hb⟩))
+  filter_upwards [hnear] with y hy
+  change f y=f (H y)
+  have hmem := L.arbitrary_plaque_mem_leaf P hUc
+    (fun k hk => hrect ⟨hk,hy.2.2⟩) hy.2.1 ha
+  have he : P.chart.symm ((P.chart y).1,(P.chart y).2)=y := P.chart.left_inv hy.1
+  rw [he] at hmem
+  exact hbasic y _ hmem
+
+lemma basic_contMDiffAt_local (P : AlignedProductChart S A B)
+    {a : A} {b : B} (hT : (a,b)∈P.chart.target)
+    {f : X.Carrier → E} (hbasic : L.Basic f) :
+    ∀ᶠ c in 𝓝 a,
+      (ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (c,b)) ↔
+       ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (a,b))) := by
+  obtain ⟨U,V,hU,hUc,hV,hUV,hrect⟩ := UniformPlaqueSlices.connected_rectangle
+    (P.chart.open_target.mem_nhds hT)
+  filter_upwards [hU.mem_nhds hUV.1] with c hc
+  exact ⟨L.basic_contMDiffAt_rectangle P hU hUc hV hrect hc hUV.1 hUV.2 hbasic,
+    L.basic_contMDiffAt_rectangle P hU hUc hV hrect hUV.1 hc hUV.2 hbasic⟩
+
+lemma basic_contMDiffAt_plaque (P : AlignedProductChart S A B)
+    {U : Set A} {b : B} (hUc : IsPreconnected U) (hT : ∀a∈U,(a,b)∈P.chart.target)
+    {a c : A} (ha : a∈U) (hc : c∈U)
+    {f : X.Carrier → E} (hbasic : L.Basic f) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (a,b)) ↔
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (c,b)) := by
+  let : PreconnectedSpace U := isPreconnected_iff_preconnectedSpace.mp hUc
+  let p : U → Prop := fun t => ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f (P.chart.symm (t.val,b))
+  have hp : IsLocallyConstant p := by
+    apply (IsLocallyConstant.iff_eventually_eq _).mpr
+    intro t
+    filter_upwards [continuous_subtype_val.continuousAt.eventually
+      (L.basic_contMDiffAt_local P (hT t.val t.property) hbasic)] with v hv
+    exact propext hv
+  exact Iff.of_eq (hp.apply_eq_of_preconnectedSpace ⟨a,ha⟩ ⟨c,hc⟩)
+
+lemma basic_contMDiffAt_related {f : X.Carrier → E} (hbasic : L.Basic f)
+    {x y : X.Carrier} (hxy : L.plaques.Related x y) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f x ↔
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f y := by
+  obtain ⟨i,b,U,hU,hT,a,ha,c,hc,rfl,rfl⟩ := hxy
+  exact L.basic_contMDiffAt_plaque (L.chart i) hU hT ha hc hbasic
+
+lemma basic_contMDiffAt_leaf {f : X.Carrier → E} (hbasic : L.Basic f)
+    {x y : X.Carrier} (hxy : y∈L.leaf x) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f x ↔
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,E) ω f y := by
+  induction hxy with
+  | refl => exact Iff.rfl
+  | @tail y z _ hyz ih => exact ih.trans (L.basic_contMDiffAt_related hbasic hyz)
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicCommonZeros.lean

@@ -0,0 +1,95 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Holomorphic Common Zeros. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+def LocallyHolomorphicCommonZeros (X : ComplexManifold.{u}) (Z : Set X.Carrier) : Prop :=
+  ∀x,∃U : Set X.Carrier,IsOpen U ∧ x∈U ∧ ∃𝒜 : Set (X.Carrier → ℂ),
+    (∀f∈𝒜,ContMDiffOn (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f U) ∧
+    ∀y∈U,y∈Z ↔ ∀f∈𝒜,f y=0
+
+lemma LocallyHolomorphicCommonZeros.isClosed {X : ComplexManifold.{u}} {Z : Set X.Carrier}
+    (h : LocallyHolomorphicCommonZeros X Z) : IsClosed Z := by
+  rw [←isOpen_compl_iff]
+  apply isOpen_iff_mem_nhds.mpr
+  intro x hx
+  obtain ⟨U,hU,hxU,𝒜,hf,he⟩ := h x
+  have hn : ¬∀f∈𝒜,f x=0 := fun hz => hx ((he x hxU).mpr hz)
+  push Not at hn
+  obtain ⟨f,hfA,hfx⟩ := hn
+  have hn' := ((hf f hfA).contMDiffAt (hU.mem_nhds hxU)).continuousAt.eventually_ne hfx
+  filter_upwards [hn',hU.mem_nhds hxU] with y hy hyU
+  exact fun hz => hy ((he y hyU).mp hz f hfA)
+
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+
+include L in
+lemma commonZeros_closure_interior {Z : Set X.Carrier}
+    (hZ : LocallyHolomorphicCommonZeros X Z) : closure (interior Z) ⊆ interior Z := by
+  intro x hx
+  obtain ⟨U,hU,hxU,𝒜,hf,he⟩ := hZ x
+  let P := L.chart x
+  let a := P.chart x
+  have hxs : x∈P.chart.source := L.mem_source x
+  have hat : a∈P.chart.target := P.chart.map_source hxs
+  have hUx : P.chart.symm ⁻¹' U∈𝓝 a := by
+    apply (P.chart.symm.continuousAt hat).preimage_mem_nhds
+    simpa only [a,P.chart.left_inv hxs] using hU.mem_nhds hxU
+  obtain ⟨r,hr,hrsub⟩ := Metric.mem_nhds_iff.mp
+    (Filter.inter_mem (P.chart.open_target.mem_nhds hat) hUx)
+  have hN : ∀ᶠy in 𝓝 x,y∈P.chart.source ∧ P.chart y∈Metric.ball a r :=
+    Filter.Eventually.and (P.chart.open_source.mem_nhds hxs)
+      ((P.chart.continuousAt hxs).preimage_mem_nhds (Metric.ball_mem_nhds a hr))
+  obtain ⟨y,hy,hys,hyr⟩ := ((mem_closure_iff_frequently.mp hx).and_eventually hN).exists
+  have haF (f : X.Carrier → ℂ) (hfA : f∈𝒜) :
+      AnalyticOnNhd ℂ (f ∘ P.chart.symm) (Metric.ball a r) := by
+    intro b hb
+    exact (((hf f hfA).contMDiffAt (hU.mem_nhds (hrsub hb).2)).comp b
+      (P.inverse_holomorphicAt (hrsub hb).1)).contDiffAt.analyticAt
+  have hzF (f : X.Carrier → ℂ) (hfA : f∈𝒜) :
+      (f ∘ P.chart.symm) =ᶠ[𝓝 (P.chart y)] 0 := by
+    have hc := P.chart.symm.continuousAt (P.chart.map_source hys)
+    have hzN : P.chart.symm ⁻¹' interior Z∈𝓝 (P.chart y) := by
+      apply hc.preimage_mem_nhds
+      simpa only [P.chart.left_inv hys] using isOpen_interior.mem_nhds hy
+    filter_upwards [hzN,Metric.isOpen_ball.mem_nhds hyr] with b hb hbr
+    exact (he _ (hrsub hbr).2).mp (interior_subset hb) f hfA
+  have hall (f : X.Carrier → ℂ) (hfA : f∈𝒜) :=
+    (haF f hfA).eqOn_zero_of_preconnected_of_eventuallyEq_zero
+      (convex_ball a r).isPreconnected hyr (hzF f hfA)
+  rw [mem_interior_iff_mem_nhds]
+  filter_upwards [hN] with z hzs
+  have heq := P.chart.left_inv hzs.1
+  have hzU : z∈U := by
+    have hh := (hrsub hzs.2).2
+    change P.chart.symm (P.chart z)∈U at hh
+    rwa [heq] at hh
+  apply (he z hzU).mpr
+  intro f hfA
+  have hz := hall f hfA hzs.2
+  simpa only [Function.comp_apply,heq,Pi.zero_apply] using hz
+
+include L in
+lemma commonZeros_eq_univ [PreconnectedSpace X.Carrier] {Z : Set X.Carrier}
+    (hZ : LocallyHolomorphicCommonZeros X Z) (h : (interior Z).Nonempty) : Z=univ := by
+  have hc : IsClosed (interior Z) := isClosed_of_closure_subset
+    (L.commonZeros_closure_interior hZ)
+  have he : interior Z=univ := (show IsClopen (interior Z) from ⟨hc,isOpen_interior⟩).eq_univ h
+  exact eq_univ_of_univ_subset (he ▸ interior_subset)
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicHypersurfaces.lean

@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.LeafPlaques
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Holomorphic Hypersurfaces. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+ 
+def LocallyHolomorphicZeroSet (X : ComplexManifold.{u}) (Z : Set X.Carrier) : Prop :=
+  ∀x,∃U : Set X.Carrier,IsOpen U ∧ x∈U ∧ ∃f : X.Carrier → ℂ,
+    ContMDiffOn (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f U ∧ ∀y∈U,y∈Z ↔ f y=0
+
+namespace AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma locally_analytic_plaque_zeroSet (P : AlignedProductChart S A B)
+    {Z : Set X.Carrier} (hZ : LocallyHolomorphicZeroSet X Z) (b : B)
+    (U : Set A) (hU : ∀a∈U,(a,b)∈P.chart.target) :
+    AnalyticGermContinuation.LocallyAnalyticZeroSet
+      {a | P.chart.symm (a,b)∈Z} U := by
+  intro a ha
+  obtain ⟨V,hVo,hx,f,hf,he⟩ := hZ (P.chart.symm (a,b))
+  have hpair : ContinuousAt (fun t : A => (t,b)) a := continuousAt_id.prodMk continuousAt_const
+  have hs : ContinuousAt (fun t : A => P.chart.symm (t,b)) a :=
+    (P.inverse_holomorphicAt (hU a ha)).continuousAt.comp
+      (f := fun t : A => (t,b)) (x := a) hpair
+  have hn : ∀ᶠ t in 𝓝 a,(t,b)∈P.chart.target ∧ P.chart.symm (t,b)∈V :=
+    Filter.Eventually.and
+      (hpair.preimage_mem_nhds (P.chart.open_target.mem_nhds (hU a ha)))
+      (hs.preimage_mem_nhds (hVo.mem_nhds hx))
+  obtain ⟨r,hr,hrS⟩ := Metric.mem_nhds_iff.mp hn
+  refine ⟨r,hr,fun t => f (P.chart.symm (t,b)),?_,fun t ht => he _ (hrS ht).2⟩
+  intro t ht
+  have hf' := hf.contMDiffAt (hVo.mem_nhds (hrS ht).2)
+  have hc : AnalyticAt ℂ (f ∘ P.chart.symm) (t,b) :=
+    (hf'.comp (t,b) (P.inverse_holomorphicAt (hrS ht).1)).contDiffAt.analyticAt
+  exact hc.comp (f := fun a : A => (a,b)) (x := t) (analyticAt_id.prod analyticAt_const)
+
+end AlignedProductChart
+
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+
+lemma germIn_of_related {Z : Set X.Carrier} (hZ : LocallyHolomorphicZeroSet X Z)
+    {y z : X.Carrier} (hy : L.GermIn Z y) (hrel : L.plaques.Related y z) :
+    L.GermIn Z z := by
+  obtain ⟨i,b,U,hUc,hT,a₀,ha₀,a₁,ha₁,h₀,h₁⟩ := hrel
+  let P := L.chart i
+  have hyS : y∈P.chart.source := h₀ ▸ P.chart.map_target (hT a₀ ha₀)
+  have hzS : z∈P.chart.source := h₁ ▸ P.chart.map_target (hT a₁ ha₁)
+  have hyC : P.chart y=(a₀,b) := by rw [←h₀]; exact P.chart.right_inv (hT a₀ ha₀)
+  have hzC : P.chart z=(a₁,b) := by rw [←h₁]; exact P.chart.right_inv (hT a₁ ha₁)
+  have hyP := (L.germIn_iff P hyS).mp hy
+  have hyG : {a | P.chart.symm (a,b)∈Z}∈𝓝 a₀ := by
+    change ∀ᶠ a in 𝓝 a₀,P.chart.symm (a,b)∈Z
+    simpa only [AlignedProductChart.GermIn,hyC] using hyP
+  have hzG := AnalyticGermContinuation.propagate hUc
+    (P.locally_analytic_plaque_zeroSet hZ b U hT) ha₀ ha₁ hyG
+  apply (L.germIn_iff P hzS).mpr
+  change ∀ᶠ a in 𝓝 a₁,P.chart.symm (a,b)∈Z at hzG
+  simpa only [AlignedProductChart.GermIn,hzC] using hzG
+
+lemma germIn_of_reachable {Z : Set X.Carrier} (hZ : LocallyHolomorphicZeroSet X Z)
+    {y z : X.Carrier} (hy : L.GermIn Z y) (hrel : L.plaques.Reachable y z) :
+    L.GermIn Z z := by
+  induction hrel with
+  | refl => exact hy
+  | tail _ h ih => exact L.germIn_of_related hZ ih h
+
+ 
+
+theorem closure_leaf_subset {Z : Set X.Carrier} (hZ : LocallyHolomorphicZeroSet X Z)
+    (hclosed : IsClosed Z) {y : X.Carrier} (hy : L.GermIn Z y) :
+    closure (L.leaf y) ⊆ Z := by
+  apply closure_minimal _ hclosed
+  intro z hz
+  exact L.germIn_mem (L.germIn_of_reachable hZ hy hz)
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicLeafBasic.lean

@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.LeafPlaques
+
+namespace OAI
+
+/-! Holomorphic Leaf Basic. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+namespace AlignedProductChart
+variable {X Y : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B) {f : X.Carrier → Y.Carrier}
+  (hf : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω f)
+  (hz : ∀x v,v∈S.first x → mfderiv (ModelWithCorners X) (ModelWithCorners Y) f x v=0)
+
+include hf hz in
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma map_plaque_eventually_constant {a : A} {b : B} (ht : (a,b)∈P.chart.target) :
+    ∀ᶠ c in 𝓝 a,f (P.chart.symm (c,b))=f (P.chart.symm (a,b)) := by
+  let g : A × B → Y.Carrier := f ∘ P.chart.symm
+  let y := g (a,b)
+  let Q := chartAt (Model Y) y
+  have hy : y∈Q.source := mem_chart_source (Model Y) y
+  have hQa : Q∈IsManifold.maximalAtlas (ModelWithCorners Y) ω Y.Carrier :=
+    IsManifold.chart_mem_maximalAtlas y
+  have hgn : ∀ᶠ z in 𝓝 (a,b),z∈P.chart.target ∧ g z∈Q.source :=
+    Filter.Eventually.and (P.chart.open_target.mem_nhds ht)
+      (((hf _).continuousAt.comp (P.inverse_holomorphicAt ht).continuousAt).preimage_mem_nhds
+        (Q.open_source.mem_nhds hy))
+  have hd : ∀ᶠ z in 𝓝 (a,b),DifferentiableAt ℂ (Q ∘ g) z := by
+    filter_upwards [hgn] with z hz
+    exact (((contMDiffAt_of_mem_maximalAtlas hQa hz.2).comp z
+      ((hf _).comp z (P.inverse_holomorphicAt hz.1))).contDiffAt).differentiableAt (by simp)
+  have hd0 : ∀ᶠ z in 𝓝 (a,b),∀v,fderiv ℂ (Q ∘ g) z (v,0)=0 := by
+    filter_upwards [hgn] with z hzg
+    intro v
+    have hP := (P.inverse_holomorphicAt hzg.1).mdifferentiableAt (by simp)
+    have hfz := (hf (P.chart.symm z)).mdifferentiableAt (by simp)
+    have hQ := (contMDiffAt_of_mem_maximalAtlas hQa hzg.2).mdifferentiableAt (by simp)
+    have hchain := mfderiv_comp z hQ (hfz.comp z hP)
+    rw [mfderiv_eq_fderiv] at hchain
+    rw [hchain]
+    change mfderiv (ModelWithCorners Y) 𝓘(ℂ,Model Y) Q (g z)
+      (mfderiv 𝓘(ℂ,A × B) (ModelWithCorners Y) g z (v,0))=0
+    change mfderiv _ _ Q (g z)
+      (mfderiv _ _ (f ∘ P.chart.symm) z (v,0))=0
+    rw [mfderiv_comp z hfz hP]
+    change mfderiv _ _ Q (g z)
+      (mfderiv _ _ f (P.chart.symm z) (mfderiv _ _ P.chart.symm z (v,0)))=0
+    rw [hz _ _ (P.inverse_first hzg.1 v),map_zero]
+  have he := ProductTransition.eventually_factors_snd hd hd0
+  have hc : Tendsto (fun c : A => (c,b)) (𝓝 a) (𝓝 (a,b)) :=
+    continuousAt_id.prodMk continuousAt_const
+  filter_upwards [hc.eventually hgn,hc.eventually he] with c hcg hce
+  apply Q.injOn hcg.2 hy
+  exact hce
+
+include hf hz in
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma map_plaque_constant {U : Set A} {b : B}
+    (hU : IsPreconnected U) (ht : ∀a∈U,(a,b)∈P.chart.target)
+    {a c : A} (ha : a∈U) (hc : c∈U) :
+    f (P.chart.symm (a,b))=f (P.chart.symm (c,b)) := by
+  let : PreconnectedSpace U := isPreconnected_iff_preconnectedSpace.mp hU
+  have hlocal : IsLocallyConstant (fun a : U => f (P.chart.symm (a.val,b))) := by
+    apply (IsLocallyConstant.iff_eventually_eq _).mpr
+    intro a
+    exact continuous_subtype_val.continuousAt.eventually
+      (P.map_plaque_eventually_constant hf hz (ht a.val a.property))
+  exact hlocal.apply_eq_of_preconnectedSpace ⟨a,ha⟩ ⟨c,hc⟩
+
+end AlignedProductChart
+namespace LeafJetAtlas
+variable {X Y : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+
+lemma holomorphic_map_eq_on_leaf {f : X.Carrier → Y.Carrier}
+    (hf : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω f)
+    (hz : ∀x v,v∈S.first x → mfderiv (ModelWithCorners X) (ModelWithCorners Y) f x v=0)
+    {x y : X.Carrier} (hy : y∈L.leaf x) : f x=f y := by
+  induction hy with
+  | refl => rfl
+  | @tail y z _ h ih =>
+    obtain ⟨i,b,U,hU,hT,a,ha,c,hc,rfl,rfl⟩ := h
+    exact ih.trans ((L.chart i).map_plaque_constant hf hz hU hT ha hc)
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicLocalDiffeomorph.lean

@@ -0,0 +1,156 @@
+import Mathlib
+
+namespace OAI
+
+/-! Holomorphic Local Diffeomorph. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+
+namespace HolomorphicLocalDiffeomorph
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F]
+variable {M N : Type*} [TopologicalSpace M] [TopologicalSpace N]
+  [ChartedSpace E M] [ChartedSpace F N]
+  [IsManifold 𝓘(ℂ,E) ω M] [IsManifold 𝓘(ℂ,F) ω N]
+
+ 
+
+theorem of_analytic_partial_homeomorph (φ : OpenPartialHomeomorph M N)
+    {x : M} (hx : x∈φ.source)
+    (hφ : ContMDiffAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω φ x)
+    (hφs : ContMDiffAt 𝓘(ℂ,F) 𝓘(ℂ,E) ω φ.symm (φ x)) :
+    IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω φ x := by
+  have he : ∀ᶠ y in 𝓝 x,
+      ContMDiffAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω φ y ∧
+      ContMDiffAt 𝓘(ℂ,F) 𝓘(ℂ,E) ω φ.symm (φ y) :=
+    ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).1 hφ).and
+      (hφ.continuousAt.eventually ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).1 hφs))
+  obtain ⟨U,hUsub,hU,hxU⟩ := mem_nhds_iff.mp he
+  let ψ := φ.restrOpen U hU
+  let Φ : PartialDiffeomorph 𝓘(ℂ,E) 𝓘(ℂ,F) M N ω := {
+    ψ.toPartialEquiv with
+    open_source := ψ.open_source
+    open_target := ψ.open_target
+    contMDiffOn_toFun := by
+      intro y hy
+      exact (hUsub hy.2).1.contMDiffWithinAt
+    contMDiffOn_invFun := by
+      intro y hy
+      have hz : φ.symm y∈ψ.source := ψ.map_target hy
+      have hh := (hUsub hz.2).2
+      change ContMDiffWithinAt 𝓘(ℂ,F) 𝓘(ℂ,E) ω φ.symm ψ.target y
+      simpa only [φ.right_inv hy.1] using hh.contMDiffWithinAt }
+  exact ⟨Φ,⟨hx,hxU⟩,fun _ _ => rfl⟩
+
+ 
+
+theorem normed_ift [CompleteSpace E] [CompleteSpace F]
+    {f : E → F} {x : E} (hf : ContDiffAt ℂ ω f x)
+    (L : E ≃L[ℂ] F) (hL : HasFDerivAt f (L : E →L[ℂ] F) x) :
+    IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω f x := by
+  let φ := hf.toOpenPartialHomeomorph f hL (by simp)
+  exact of_analytic_partial_homeomorph φ
+    (hf.mem_toOpenPartialHomeomorph_source hL (by simp))
+    hf.contMDiffAt (hf.to_localInverse hL (by simp)).contMDiffAt
+
+end HolomorphicLocalDiffeomorph
+
+namespace HolomorphicLocalDiffeomorph
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F]
+variable {M N : Type*} [TopologicalSpace M] [TopologicalSpace N]
+  [ChartedSpace E M] [ChartedSpace F N]
+  [IsManifold 𝓘(ℂ,E) ω M] [IsManifold 𝓘(ℂ,F) ω N]
+
+omit [IsManifold 𝓘(ℂ,E) ω M] [IsManifold 𝓘(ℂ,F) ω N] in
+theorem congr_eventually {f g : M → N} {x : M}
+    (hf : IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω f x)
+    (he : f=ᶠ[𝓝 x]g) : IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω g x := by
+  obtain ⟨φ,hx,hφ⟩ := hf
+  obtain ⟨U,hUsub,hU,hxU⟩ := mem_nhds_iff.mp he
+  let ψ := φ.toOpenPartialHomeomorph.restrOpen U hU
+  let Φ : PartialDiffeomorph 𝓘(ℂ,E) 𝓘(ℂ,F) M N ω := {
+    ψ.toPartialEquiv with
+    open_source := ψ.open_source
+    open_target := ψ.open_target
+    contMDiffOn_toFun := φ.contMDiffOn_toFun.mono inter_subset_left
+    contMDiffOn_invFun := φ.contMDiffOn_invFun.mono inter_subset_left }
+  refine ⟨Φ,⟨hx,hxU⟩,?_⟩
+  intro y hy
+  exact (hUsub hy.2).symm.trans (hφ hy.1)
+
+theorem chart_local {x y : M} (hy : y∈(chartAt E x).source) :
+    IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,E) ω (chartAt E x) y :=
+  of_analytic_partial_homeomorph _ hy
+    (contMDiffAt_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I:=𝓘(ℂ,E))
+      (n:=ω) x) hy)
+    (contMDiffAt_symm_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I:=𝓘(ℂ,E))
+      (n:=ω) x) ((chartAt E x).map_source hy))
+
+theorem chart_symm_local {x : M} {y : E} (hy : y∈(chartAt E x).target) :
+    IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,E) ω (chartAt E x).symm y :=
+  of_analytic_partial_homeomorph _ hy
+    (contMDiffAt_symm_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I:=𝓘(ℂ,E))
+      (n:=ω) x) hy)
+    (contMDiffAt_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I:=𝓘(ℂ,E))
+      (n:=ω) x) ((chartAt E x).map_target hy))
+
+ 
+
+theorem manifold_ift [FiniteDimensional ℂ E] [FiniteDimensional ℂ F]
+    {f : M → N} {x : M} (hf : ContMDiffAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω f x)
+    (hb : Function.Bijective (mfderiv 𝓘(ℂ,E) 𝓘(ℂ,F) f x)) :
+    IsLocalDiffeomorphAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω f x := by
+  let c := chartAt E x
+  let d := chartAt F (f x)
+  have hc : x∈c.source := mem_chart_source E x
+  have hd : f x∈d.source := mem_chart_source F (f x)
+  have hcs : c.symm (c x)=x := c.left_inv hc
+  have hdl := chart_local hd
+  have hcsl := chart_symm_local (c.map_source hc)
+  have hcl := chart_local hc
+  let g : E → F := d ∘ f ∘ c.symm
+  have hfcs : ContMDiffAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω f (c.symm (c x)) := by
+    rwa [hcs]
+  have hinner := hfcs.comp (c x) hcsl.contMDiffAt
+  have hdcs : ContMDiffAt 𝓘(ℂ,F) 𝓘(ℂ,F) ω d (f (c.symm (c x))) := by
+    simpa only [hcs] using hdl.contMDiffAt
+  have hgM : ContMDiffAt 𝓘(ℂ,E) 𝓘(ℂ,F) ω g (c x) := hdcs.comp (c x) hinner
+  have hg : ContDiffAt ℂ ω g (c x) := hgM.contDiffAt
+  have hbD : Function.Bijective
+      (mfderiv 𝓘(ℂ,F) 𝓘(ℂ,F) d (f (c.symm (c x)))) := by
+    rw [hcs]
+    exact (hdl.mfderivToContinuousLinearEquiv (by simp)).bijective
+  have hbF : Function.Bijective
+      (mfderiv 𝓘(ℂ,E) 𝓘(ℂ,F) f (c.symm (c x))) := by
+    rw [hcs]
+    exact hb
+  have hbC : Function.Bijective (mfderiv 𝓘(ℂ,E) 𝓘(ℂ,E) c.symm (c x)) :=
+    (hcsl.mfderivToContinuousLinearEquiv (by simp)).bijective
+  have hbg : Function.Bijective (fderiv ℂ g (c x)) := by
+    rw [← mfderiv_eq_fderiv]
+    change Function.Bijective (mfderiv 𝓘(ℂ,E) 𝓘(ℂ,F) (d ∘ (f ∘ c.symm)) (c x))
+    rw [mfderiv_comp (c x) (f := f ∘ c.symm) (g := d) (hdcs.mdifferentiableAt (by simp))
+      (hinner.mdifferentiableAt (by simp)),
+      mfderiv_comp (c x) (f := c.symm) (g := f) (hfcs.mdifferentiableAt (by simp))
+        (hcsl.mdifferentiableAt (by simp))]
+    exact hbD.comp (hbF.comp hbC)
+  let L : E ≃L[ℂ] F :=
+    (LinearEquiv.ofBijective (fderiv ℂ g (c x)).toLinearMap hbg).toContinuousLinearEquiv
+  have hLg : HasFDerivAt g (L : E →L[ℂ] F) (c x) := hg.differentiableAt (by simp) |>.hasFDerivAt
+  have hgl := normed_ift hg L hLg
+  have hdsl : IsLocalDiffeomorphAt 𝓘(ℂ,F) 𝓘(ℂ,F) ω d.symm (g (c x)) := by
+    simpa only [g,Function.comp_apply,hcs] using chart_symm_local (d.map_source hd)
+  apply congr_eventually (hcl.comp 𝓘(ℂ,F) N (hgl.comp 𝓘(ℂ,F) N hdsl))
+  filter_upwards [c.open_source.mem_nhds hc,
+    hf.continuousAt.eventually (d.open_source.mem_nhds hd)] with y hy hfy
+  change d.symm (d (f (c.symm (c y))))=f y
+  rw [c.left_inv hy,d.left_inv hfy]
+
+end HolomorphicLocalDiffeomorph
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicManifoldProduct.lean

@@ -0,0 +1,177 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Holomorphic Manifold Product. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+variable {X : ComplexManifold.{u}}
+namespace TangentSplitting
+variable (S : TangentSplitting X)
+
+lemma coordinateProjector_range (x : X.Carrier) {y : X.Carrier}
+    (hy : y∈(chartAt (Model X) x).source) :
+    Submodule.map (chartDerivative x y).toLinearMap (S.first y)=
+      LinearMap.range (S.coordinateProjector x ((chartAt (Model X) x) y)).toLinearMap := by
+  have hD := chartDerivative_isInvertible x hy
+  ext v
+  rw [S.coordinateProjector_range_iff x hy]
+  constructor
+  · rintro ⟨w,hw,rfl⟩
+    change (chartDerivative x y).inverse ((chartDerivative x y) w) ∈ S.first y
+    rw [hD.inverse_apply_self]
+    exact hw
+  · intro hv
+    exact ⟨(chartDerivative x y).inverse v,hv,hD.self_apply_inverse v⟩
+
+lemma coordinateProjector_kernel (x : X.Carrier) {y : X.Carrier}
+    (hy : y∈(chartAt (Model X) x).source) :
+    Submodule.map (chartDerivative x y).toLinearMap (S.second y)=
+      LinearMap.ker (S.coordinateProjector x ((chartAt (Model X) x) y)).toLinearMap := by
+  rw [← S.swap_first,S.swap.coordinateProjector_range x hy,
+    S.coordinateProjector_swap x ((chartAt (Model X) x).map_source hy)]
+  exact HolomorphicFrobenius.range_complementary_projector _
+    (S.coordinateProjector_idempotent x ((chartAt (Model X) x).map_source hy))
+
+abbrev FirstModel (x : X.Carrier) :=
+  HolomorphicFrobenius.FirstQuotient (S.coordinateProjector x) ((chartAt (Model X) x) x)
+abbrev SecondModel (x : X.Carrier) :=
+  HolomorphicFrobenius.SecondQuotient (S.coordinateProjector x) ((chartAt (Model X) x) x)
+
+ 
+
+theorem exists_local_product_chart (hI₁ : Integrable X S.first)
+    (hI₂ : Integrable X S.second) (x : X.Carrier) :
+    ∃ Φ : OpenPartialHomeomorph X.Carrier (S.FirstModel x × S.SecondModel x),
+      x∈Φ.source ∧ Φ x=0 ∧
+      ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x) ω Φ x ∧
+      ContMDiffAt 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ModelWithCorners X) ω Φ.symm 0 ∧
+      ∀ᶠ y in 𝓝 x,
+        Submodule.map (mfderiv (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x)
+          Φ y).toLinearMap (S.first y)=
+          LinearMap.ker (ContinuousLinearMap.snd ℂ (S.FirstModel x) (S.SecondModel x)).toLinearMap ∧
+        Submodule.map (mfderiv (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x)
+          Φ y).toLinearMap (S.second y)=
+          LinearMap.ker (ContinuousLinearMap.fst ℂ (S.FirstModel x) (S.SecondModel x)).toLinearMap := by
+  let c := chartAt (Model X) x
+  let z := c x
+  have hx : x∈c.source := mem_chart_source (Model X) x
+  have hz : z∈c.target := c.map_source hx
+  have hP := S.coordinateProjector_analytic x z hz
+  have hPid : ∀ᶠ a in 𝓝 z, ∀v, S.coordinateProjector x a (S.coordinateProjector x a v)=
+      S.coordinateProjector x a v :=
+    Filter.Eventually.mono (c.open_target.mem_nhds hz) fun a ha => S.coordinateProjector_idempotent x ha
+  have hPcomp : S.swap.coordinateProjector x=ᶠ[𝓝 z]
+      (fun a => ContinuousLinearMap.id ℂ (Model X)-S.coordinateProjector x a) :=
+    Filter.Eventually.mono (c.open_target.mem_nhds hz) fun a ha => S.coordinateProjector_swap x ha
+  have hIc := (S.swap.coordinateProjector_involutive (by simpa using hI₂) x hz).congr hPcomp
+  obtain ⟨ψ,hzψ,hψ0,hψ,hψs,haxes⟩ := HolomorphicFrobenius.exists_local_product_chart
+    hP hPid (S.coordinateProjector_involutive hI₁ x hz) hIc
+  let Φ := c.trans ψ
+  have hΦx : Φ x=0 := hψ0
+  have hc : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,Model X) ω c x :=
+    contMDiffAt_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X)
+      (n := ω) x) hx
+  have h0t : (0 : S.FirstModel x × S.SecondModel x)∈ψ.target := hψ0 ▸ ψ.map_source hzψ
+  have hψs0 : ψ.symm 0=z := by simpa only [hψ0] using ψ.left_inv hzψ
+  have hcs : ContMDiffAt 𝓘(ℂ,Model X) (ModelWithCorners X) ω c.symm (ψ.symm 0) := by
+    rw [hψs0]
+    exact contMDiffAt_symm_of_mem_maximalAtlas
+      (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) (n := ω) x) hz
+  refine ⟨Φ,⟨hx,hzψ⟩,hΦx,hψ.contDiffAt.contMDiffAt.comp x hc,
+    hcs.comp 0 hψs.contDiffAt.contMDiffAt,?_⟩
+  have ht : Tendsto c (𝓝 x) (𝓝 z) := hc.continuousAt
+  filter_upwards [c.open_source.mem_nhds hx,ht.eventually haxes,
+    ht.eventually hψ.eventually_analyticAt] with y hy hay hψy
+  have hcy : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,Model X) ω c y :=
+    contMDiffAt_of_mem_maximalAtlas (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X)
+      (n := ω) x) hy
+  have hd : mfderiv (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x) Φ y=
+      (fderiv ℂ ψ (c y)).comp (chartDerivative x y) := by
+    change mfderiv (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ψ ∘ c) y=_
+    rw [mfderiv_comp y (hψy.differentiableAt.mdifferentiableAt)
+      (hcy.mdifferentiableAt (by simp)),mfderiv_eq_fderiv]
+    rfl
+  constructor
+  · rw [hd]
+    change Submodule.map ((fderiv ℂ ψ (c y)).toLinearMap.comp
+      (chartDerivative x y).toLinearMap) (S.first y)=_
+    rw [Submodule.map_comp,S.coordinateProjector_range x hy]
+    exact hay.1
+  · rw [hd]
+    change Submodule.map ((fderiv ℂ ψ (c y)).toLinearMap.comp
+      (chartDerivative x y).toLinearMap) (S.second y)=_
+    rw [Submodule.map_comp,S.coordinateProjector_kernel x hy]
+    exact hay.2
+
+end TangentSplitting
+end SplitTangent
+
+namespace SplitTangent
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+
+theorem TangentSplitting.exists_aligned_product_chart (S : TangentSplitting X)
+    (hI₁ : Integrable X S.first) (hI₂ : Integrable X S.second) (x : X.Carrier) :
+    ∃P : AlignedProductChart S (S.FirstModel x) (S.SecondModel x),
+      x∈P.chart.source ∧ P.chart x=0 := by
+  obtain ⟨φ,hx,h0,hφ,hφs,haxes⟩ := S.exists_local_product_chart hI₁ hI₂ x
+  have hs : ContMDiffAt 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ModelWithCorners X) ω φ.symm (φ x) :=
+    h0.symm ▸ hφs
+  have hall := ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).mp hφ).and
+    ((hφ.continuousAt.eventually ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).mp hs)).and haxes)
+  obtain ⟨U,hUsub,hU,hxU⟩ := mem_nhds_iff.mp hall
+  let ψ := φ.restrOpen U hU
+  let P : AlignedProductChart S (S.FirstModel x) (S.SecondModel x) := {
+    chart := ψ
+    holomorphic := by
+      intro y hy
+      exact (hUsub hy.2).1.contMDiffWithinAt
+    inverse_holomorphic := by
+      intro y hy
+      have hz : φ.symm y∈ψ.source := ψ.map_target hy
+      have hh := (hUsub hz.2).2.1
+      change ContMDiffWithinAt 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ModelWithCorners X)
+        ω φ.symm ψ.target y
+      simpa only [φ.right_inv hy.1] using hh.contMDiffWithinAt
+    first := fun y hy => (hUsub hy.2).2.2.1
+    second := fun y hy => (hUsub hy.2).2.2.2 }
+  exact ⟨P,⟨hx,hxU⟩,h0⟩
+
+theorem TangentSplitting.exists_aligned_product_chartAlternative (S : TangentSplitting X)
+    (hI₁ : Integrable X S.first) (hI₂ : Integrable X S.second) (x : X.Carrier) :
+    ∃P : AlignedProductChart S (S.FirstModel x) (S.SecondModel x),
+      x∈P.chart.source ∧ P.chart x=0 := by
+  obtain ⟨φ,hx,h0,hφ,hφs,haxes⟩ := S.exists_local_product_chart hI₁ hI₂ x
+  have hs : ContMDiffAt 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ModelWithCorners X) ω φ.symm (φ x) :=
+    h0.symm ▸ hφs
+  have hall := ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).mp hφ).and
+    ((hφ.continuousAt.eventually ((contMDiffAt_iff_contMDiffAt_nhds (by simp)).mp hs)).and haxes)
+  obtain ⟨U,hUsub,hU,hxU⟩ := _root_.mem_nhds_iff.mp hall
+  let ψ := φ.restrOpen U hU
+  let P : AlignedProductChart S (S.FirstModel x) (S.SecondModel x) := {
+    chart := ψ
+    holomorphic := by
+      intro y hy
+      exact (hUsub hy.2).1.contMDiffWithinAt
+    inverse_holomorphic := by
+      intro y hy
+      have hz : φ.symm y∈ψ.source := ψ.map_target hy
+      have hh := (hUsub hz.2).2.1
+      change ContMDiffWithinAt 𝓘(ℂ,S.FirstModel x × S.SecondModel x) (ModelWithCorners X)
+        ω φ.symm ψ.target y
+      simpa only [φ.right_inv hy.1] using hh.contMDiffWithinAt
+    first := fun y hy => (hUsub hy.2).2.2.1
+    second := fun y hy => (hUsub hy.2).2.2.2 }
+  exact ⟨P,⟨hx,hxU⟩,h0⟩
+
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/HolomorphicTangentMapAt.lean

@@ -0,0 +1,42 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Holomorphic Tangent Map At. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+ 
+
+lemma holomorphicAt_tangentMap {X Y : ComplexManifold.{u}}
+    {f : X.Carrier → Y.Carrier} {x : X.Carrier}
+    (hf : ContMDiffAt (ModelWithCorners X) (ModelWithCorners Y) ω f x)
+    (v : Tangent X x) :
+    ContMDiffAt ((ModelWithCorners X).prod 𝓘(ℂ,Model X))
+      ((ModelWithCorners Y).prod 𝓘(ℂ,Model Y)) ω
+      (tangentMap (ModelWithCorners X) (ModelWithCorners Y) f)
+      (⟨x,v⟩ : TangentBundle (ModelWithCorners X) X.Carrier) := by
+  obtain ⟨s,hs,hfs⟩ := (contMDiffAt_iff_contMDiffOn_nhds (by simp : (ω : WithTop ℕ∞)≠∞)).mp hf
+  obtain ⟨U,hUs,hU,hxU⟩ := mem_nhds_iff.mp hs
+  have hFU := hfs.mono hUs
+  have hTU := hFU.contMDiffOn_tangentMapWithin (m := ω) (by simp) hU.uniqueMDiffOn
+  have hπ : Continuous (fun p : TangentBundle (ModelWithCorners X) X.Carrier => p.proj) :=
+    (contMDiff_proj (IB := ModelWithCorners X) (n := ω) (TangentSpace (ModelWithCorners X))).continuous
+  have hn : (fun p : TangentBundle (ModelWithCorners X) X.Carrier => p.proj) ⁻¹' U ∈
+      𝓝 (⟨x,v⟩ : TangentBundle (ModelWithCorners X) X.Carrier) :=
+    hπ.continuousAt.preimage_mem_nhds (hU.mem_nhds hxU)
+  apply (hTU.contMDiffAt hn).congr_of_eventuallyEq
+  filter_upwards [hn] with p hp
+  exact (tangentMapWithin_eq_tangentMap (hU.uniqueMDiffOn p.proj hp)
+    ((hFU.contMDiffAt (hU.mem_nhds hp)).mdifferentiableAt (by simp))).symm
+
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/IntegrabilityReduction.lean

@@ -0,0 +1,118 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.CompactLeafQuotient
+import OAI.Geometry.SplitTangent.GlobalTopologicalProduct
+import OAI.Geometry.SplitTangent.LeafProducts
+import OAI.Geometry.SplitTangent.HolomorphicLeafBasic
+import OAI.Geometry.SplitTangent.RationalVariation
+
+namespace OAI
+
+/-! Integrability Reduction. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (M : LeafJetAtlas S.swap) (e : ProjectiveEmbedding X)
+  (hRC : RationallyConnected e) (hdim : 0<X.dim)
+
+lemma leafPair_injective_of_compatible_projective_product
+    (hproduct : HasCompatibleProjectiveProduct X S) :
+    Function.Injective (L.leafPair M e hRC hdim) := by
+  obtain ⟨Y,Z,_,_,f,halign⟩ := hproduct
+  let I := (ModelWithCorners Y).prod (ModelWithCorners Z)
+  let p : X.Carrier → Y.Carrier := Prod.fst ∘ f
+  let q : X.Carrier → Z.Carrier := Prod.snd ∘ f
+  have hp : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω p :=
+    contMDiff_fst.comp f.contMDiff
+  have hq : ContMDiff (ModelWithCorners X) (ModelWithCorners Z) ω q :=
+    contMDiff_snd.comp f.contMDiff
+  have hp0 : ∀x v,v∈S.swap.first x →
+      mfderiv (ModelWithCorners X) (ModelWithCorners Y) p x v=0 := by
+    intro x v hv
+    rw [S.swap_first] at hv
+    have hm := Submodule.mem_map_of_mem (f :=
+      (mfderiv (ModelWithCorners X) I f x).toLinearMap) hv
+    rw [(halign x).2] at hm
+    change (mfderiv (ModelWithCorners X) I f x v).1=0 at hm
+    change mfderiv (ModelWithCorners X) (ModelWithCorners Y) (Prod.fst ∘ f) x v=0
+    rw [mfderiv_comp x mdifferentiableAt_fst
+      ((f.contMDiff x).mdifferentiableAt (by simp)),mfderiv_fst]
+    exact hm
+  have hq0 : ∀x v,v∈S.first x →
+      mfderiv (ModelWithCorners X) (ModelWithCorners Z) q x v=0 := by
+    intro x v hv
+    have hm := Submodule.mem_map_of_mem (f :=
+      (mfderiv (ModelWithCorners X) I f x).toLinearMap) hv
+    rw [(halign x).1] at hm
+    change (mfderiv (ModelWithCorners X) I f x v).2=0 at hm
+    change mfderiv (ModelWithCorners X) (ModelWithCorners Z) (Prod.snd ∘ f) x v=0
+    rw [mfderiv_comp x mdifferentiableAt_snd
+      ((f.contMDiff x).mdifferentiableAt (by simp)),mfderiv_snd]
+    exact hm
+  intro x y hxy
+  have hL := (L.leafQuotient_eq_iff e hRC hdim x y).mp (congrArg Prod.fst hxy)
+  have hM := (M.leafQuotient_eq_iff e hRC hdim x y).mp (congrArg Prod.snd hxy)
+  apply f.injective
+  exact Prod.ext (M.holomorphic_map_eq_on_leaf hp hp0 hM)
+    (L.holomorphic_map_eq_on_leaf hq hq0 hL)
+
+ 
+
+theorem compatible_projective_product_iff_leafPair_injective :
+    HasCompatibleProjectiveProduct X S ↔ Function.Injective (L.leafPair M e hRC hdim) :=
+  ⟨L.leafPair_injective_of_compatible_projective_product M e hRC hdim,
+    L.compatible_projective_product_of_leafPair_injective M e hRC hdim⟩
+
+lemma leafPair_injective_iff_single_intersection :
+    Function.Injective (L.leafPair M e hRC hdim) ↔
+      ∀x y,y∈L.leaf x → y∈M.leaf x → y=x := by
+  constructor
+  · intro h x y hL hM
+    apply h
+    exact Prod.ext ((L.leafQuotient_eq_iff e hRC hdim x y).mpr hL).symm
+      ((M.leafQuotient_eq_iff e hRC hdim x y).mpr hM).symm
+  · intro h x y hxy
+    exact (h x y ((L.leafQuotient_eq_iff e hRC hdim x y).mp (congrArg Prod.fst hxy))
+      ((M.leafQuotient_eq_iff e hRC hdim x y).mp (congrArg Prod.snd hxy))).symm
+
+end LeafJetAtlas
+
+ 
+
+def LeafPairOneSheetedStatement : Prop :=
+  ∀ (X : ComplexManifold.{u}) [ConnectedSpace X.Carrier] [CompactSpace X.Carrier],
+    ∀ (hd : 2≤X.dim), ∀(e : ProjectiveEmbedding X) (hRC : RationallyConnected e)
+      (S : TangentSplitting X) (L : LeafJetAtlas S) (M : LeafJetAtlas S.swap),
+      Function.Injective (L.leafPair M e hRC (by omega))
+
+ 
+
+theorem main_iff_leafPair_oneSheeted : MainStatement.{u} ↔ LeafPairOneSheetedStatement.{u} := by
+  constructor
+  · intro h X hc hk hd e hRC S L M
+    let := hc
+    let := hk
+    exact L.leafPair_injective_of_compatible_projective_product M e hRC (by omega)
+      (h X hc hk hd e hRC S).2.2
+  · intro h X hc hk hd e hRC S
+    let := hc
+    let := hk
+    obtain ⟨h₁,h₂⟩ := S.integrable_of_rationallyConnected e hRC hd
+    let L := S.leafJetAtlas h₁ h₂
+    let M := S.swap.leafJetAtlas (by simpa only [S.swap_first] using h₂)
+      (by simpa only [S.swap_second] using h₁)
+    exact ⟨h₁,h₂,L.compatible_projective_product_of_leafPair_injective M e hRC
+      (by omega) (@h X hc hk hd e hRC S L M)⟩
+
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/IntrinsicPositiveLeaf.lean

@@ -0,0 +1,55 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.ProjectivePositiveLeaf
+import OAI.Geometry.SplitTangent.EmbeddedLeafCharts
+import OAI.Geometry.SplitTangent.TangentCurveLeaf
+import OAI.Geometry.SplitTangent.EmbeddedRationalCurve
+import OAI.Geometry.SplitTangent.CompactPositiveLeaf
+
+namespace OAI
+
+/-! Intrinsic Positive Leaf. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S) [PreconnectedSpace X.Carrier] [CompactSpace X.Carrier]
+
+include F in
+ 
+
+theorem exists_intrinsic_positive_leaf (ht : g.TangentTo S.first) (hg : PointedGenerated g S.first) :
+    ∃Y : ComplexManifold.{u}, IsProjective Y ∧ ConnectedSpace Y.Carrier ∧
+      Y.dim=Module.finrank ℂ (S.first (g.finite 1)) ∧
+      ∃i : Y.Carrier → X.Carrier,
+        ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i ∧
+        Function.Injective i ∧ Set.range i=L.leaf (g.finite 1) ∧
+        (∀y,LinearMap.range (mfderiv (ModelWithCorners Y) (ModelWithCorners X) i y).toLinearMap=
+          S.first (i y)) ∧
+        ∃k : RationalCurve Y,PointedGenerated k (fun _ => ⊤) ∧
+          (∀z,i (k.finite z)=g.finite z) ∧ (∀z,i (k.infinity z)=g.infinity z) := by
+  let h := F.leaf_locallySinglePlaque L ht hg
+  let A := L.embeddedAtlas (g.finite 1) h
+  let := A.chartedSpace
+  let := A.isManifold
+  let hf := L.tangent_rational_curve_finite ht
+  let hi := L.tangent_rational_curve_infinity ht
+  let k := A.rationalCurve g hf hi
+  refine ⟨A.manifold,⟨isCompact_iff_compactSpace.mp (F.leaf_isCompact L ht hg),
+    ⟨A.projectiveEmbedding e⟩⟩,isConnected_iff_connectedSpace.mp (L.plaques.leaf_isConnected _),rfl,
+    Subtype.val,A.inclusion_holomorphic,Subtype.val_injective,Subtype.range_coe,
+    L.embedded_inclusion_tangent _ h,k,?_,fun _ => rfl,fun _ => rfl⟩
+  exact A.rationalCurve_pointedGenerated g hf hi S.first hg (L.embedded_inclusion_tangent _ h)
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeadingJetProduct.lean

@@ -0,0 +1,62 @@
+import Mathlib
+
+namespace OAI
+
+/-! Leading Jet Product. -/
+
+noncomputable section
+open Set Filter
+open scoped Topology ContDiff
+namespace SplitTangent.LeadingJet
+variable {E F : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+  [NormedAddCommGroup F] [NormedSpace ℂ F] [CompleteSpace F]
+
+lemma iteratedFDeriv_smul_zero {f : E → F} {u : E → ℂ} {x : E}
+    (hf : AnalyticAt ℂ f x) (hu : AnalyticAt ℂ u x) (m : ℕ)
+    (hu0 : u x=0) (hz : ∀n,n < m → iteratedFDeriv ℂ n f x=0) :
+    iteratedFDeriv ℂ m (fun y => u y • f y) x=0 := by
+  obtain ⟨s,hsub,hs,hxs⟩ := mem_nhds_iff.mp
+    (hu.eventually_analyticAt.and hf.eventually_analyticAt)
+  have hu' : ContDiffOn ℂ ω u s := fun y hy => (hsub hy).1.contDiffAt.contDiffWithinAt
+  have hf' : ContDiffOn ℂ ω f s := fun y hy => (hsub hy).2.contDiffAt.contDiffWithinAt
+  have hb := norm_iteratedFDerivWithin_smul_le hu' hf' hs.uniqueDiffOn hxs
+    (n := m) (by simp only [le_top])
+  have he (n : ℕ) (g : E → F) : iteratedFDerivWithin ℂ n g s x=iteratedFDeriv ℂ n g x :=
+    iteratedFDerivWithin_of_isOpen n hs hxs
+  have heu (n : ℕ) : iteratedFDerivWithin ℂ n u s x=iteratedFDeriv ℂ n u x :=
+    iteratedFDerivWithin_of_isOpen n hs hxs
+  simp only [he,heu] at hb
+  have hs0 : (∑i∈Finset.range (m+1), (m.choose i : ℝ)*‖iteratedFDeriv ℂ i u x‖*
+      ‖iteratedFDeriv ℂ (m-i) f x‖)=0 := by
+    apply Finset.sum_eq_zero
+    intro i hi
+    have him : i ≤ m := Finset.mem_range_succ_iff.mp hi
+    by_cases hi0 : i=0
+    · subst i
+      rw [norm_iteratedFDeriv_zero,hu0,norm_zero,mul_zero,zero_mul]
+    · rw [hz (m-i) (by omega),norm_zero,mul_zero]
+  rw [hs0] at hb
+  exact norm_le_zero_iff.mp hb
+
+ 
+
+theorem iteratedFDeriv_smul_of_lower_zero {f : E → F} {u : E → ℂ} {x : E}
+    (hf : AnalyticAt ℂ f x) (hu : AnalyticAt ℂ u x) (m : ℕ)
+    (hz : ∀n,n < m → iteratedFDeriv ℂ n f x=0) :
+    iteratedFDeriv ℂ m (fun y => u y • f y) x=u x • iteratedFDeriv ℂ m f x := by
+  have hp := iteratedFDeriv_smul_zero hf (hu.sub analyticAt_const) m (sub_self _) hz
+  have huf : ContDiffAt ℂ m (fun y => u y • f y) x := (hu.smul hf).contDiffAt
+  have hcf : ContDiffAt ℂ m (fun y => u x • f y) x :=
+    (hf.const_smul (c := u x)).contDiffAt
+  have he : (fun y => (u y-u x) • f y)=
+      (fun y => u y • f y)-(fun y => u x • f y) := by ext y; simp [sub_smul]
+  change iteratedFDeriv ℂ m (fun y => (u y-u x) • f y) x=0 at hp
+  rw [he,iteratedFDeriv_sub_apply huf hcf,
+    iteratedFDeriv_const_smul_apply' (hf.contDiffAt)] at hp
+  exact sub_eq_zero.mp hp
+
+end SplitTangent.LeadingJet
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafAffineRelations.lean

@@ -0,0 +1,75 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.ProjectiveLinearCoordinates
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.LeafClosureRelations
+
+namespace OAI
+
+/-! Leaf Affine Relations. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B)
+
+include F in
+ 
+
+theorem leaf_closure_affine_relation
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first)
+    (p : (Fin (e.N+1) → ℂ) →ₗ[ℂ] (Fin (Module.finrank ℂ (S.first (g.finite 1))) → ℂ))
+    (i j : Fin (e.N+1)) :
+    ∃q : MvPolynomial (Option (Fin (Module.finrank ℂ (S.first (g.finite 1))))) ℂ,
+      q≠0 ∧ ∀x∈closure (L.leaf (g.finite 1)),(e.map x).rep i≠0 →
+        MvPolynomial.eval (fun t => Option.elim t (projectiveCoordinates i (e.map x) j)
+          (p (projectiveCoordinates i (e.map x)))) q=0 := by
+  classical
+  let r := Module.finrank ℂ (S.first (g.finite 1))
+  let D : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1 :=
+    ⟨MvPolynomial.X i,MvPolynomial.isHomogeneous_X ℂ i⟩
+  let H : Option (Fin r) → MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1 :=
+    fun t => Option.elim t ⟨MvPolynomial.X j,MvPolynomial.isHomogeneous_X ℂ j⟩
+      (fun a => ProjectiveLinearCoordinates.form ((LinearMap.proj a).comp p))
+  obtain ⟨q,hq,hrel⟩ := F.leaf_closure_relation L P hy ht hg D (H ∘ finSuccEquiv r)
+  refine ⟨MvPolynomial.rename (finSuccEquiv r) q,?_,?_⟩
+  · exact fun he => hq ((MvPolynomial.rename_injective _ (finSuccEquiv r).injective)
+      (he.trans (map_zero _).symm))
+  · intro x hx hi
+    have hd : MvPolynomial.eval (e.map x).rep D.val≠0 := by
+      simpa only [D,MvPolynomial.eval_X] using hi
+    have he := hrel x hx hd
+    have hv : ∀t : Option (Fin r),
+        MvPolynomial.eval (e.map x).rep (H t).val/MvPolynomial.eval (e.map x).rep D.val =
+          Option.elim t (projectiveCoordinates i (e.map x) j) (p (projectiveCoordinates i (e.map x))) := by
+      intro t
+      cases t with
+      | none => simp only [H,D,Option.elim_none,MvPolynomial.eval_X,projectiveCoordinates,div_eq_mul_inv,mul_comm]
+      | some a =>
+          simp only [H,D,Option.elim_some,MvPolynomial.eval_X]
+          rw [ProjectiveLinearCoordinates.eval_form_ratio]
+          rfl
+    rw [MvPolynomial.eval_rename]
+    convert he using 1
+    congr 1
+    apply congrArg MvPolynomial.eval
+    funext t
+    exact (hv (finSuccEquiv r t)).symm
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafAlgebraicDependence.lean

@@ -0,0 +1,100 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.BoxMonomials
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.LeafPolynomialGrowth
+
+namespace OAI
+
+/-! Leaf Algebraic Dependence. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B)
+
+abbrev leafFrame (t : A) :=
+  F.finite 1 (P.chart.symm (t,(P.chart (g.finite 1)).2))
+
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma leafFrame_continuousAt (hy : g.finite 1∈P.chart.source) :
+    ContinuousAt (F.leafFrame P) (P.chart (g.finite 1)).1 := by
+  have hh := (P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt.comp
+    (f := fun a : A => (a,(P.chart (g.finite 1)).2))
+    (x := (P.chart (g.finite 1)).1)
+    (continuousAt_id.prodMk continuousAt_const)
+  have hf := (F.finite_holomorphicAt 1).continuousAt
+  have he : P.chart.symm ((P.chart (g.finite 1)).1,(P.chart (g.finite 1)).2)=g.finite 1 :=
+    P.chart.left_inv hy
+  rw [←he] at hf
+  exact hf.comp (f := fun a : A => P.chart.symm (a,(P.chart (g.finite 1)).2))
+    (x := (P.chart (g.finite 1)).1) hh
+
+include L in
+ 
+
+theorem leaf_coordinates_dependent
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first)
+    (j : Fin (e.N+1)) (hj : F.finite 1 (g.finite 1) j≠0)
+    (v : Fin (Module.finrank ℂ (S.first (g.finite 1))+1) → Fin (e.N+1)) :
+    ∃p : MvPolynomial (Fin (Module.finrank ℂ (S.first (g.finite 1))+1)) ℂ,
+      p≠0 ∧ (fun t : A => MvPolynomial.eval (fun i => F.leafFrame P t (v i)/F.leafFrame P t j) p)
+        =ᶠ[𝓝 (P.chart (g.finite 1)).1] 0 := by
+  classical
+  let r := Module.finrank ℂ (S.first (g.finite 1))
+  let C := (F.degree+r+1)^r*(F.degree+1)
+  obtain ⟨t,hbig⟩ := PolynomialGrowthArithmetic.box_exceeds C r
+  let k := (r+1)*t
+  obtain ⟨hfin,hbound⟩ := F.leaf_polynomial_growth L P hy ht hg k
+  let := hfin
+  let q : BoxMonomials.Box (r+1) t → F.LeafPolynomialGerms P k :=
+    fun b => (F.leafPolynomialKernel P k).mkQ (BoxMonomials.homogeneous j v b)
+  have hnot : ¬LinearIndependent ℂ q := by
+    intro hlin
+    have hcard := hlin.fintype_card_le_finrank
+    have hc : (t+1)^(r+1) ≤ Module.finrank ℂ (F.LeafPolynomialGerms P k) := by
+      simpa only [BoxMonomials.Box,Fintype.card_fun,Fintype.card_fin] using hcard
+    exact (Nat.not_lt_of_ge (hc.trans hbound)) hbig
+  obtain ⟨c,hc,i,hi⟩ := Fintype.not_linearIndependent_iff.mp hnot
+  let p : MvPolynomial (Fin (r+1)) ℂ := ∑b,c b • BoxMonomials.affine b
+  have hp : p≠0 := by
+    intro he
+    exact hi (Fintype.linearIndependent_iff.mp (BoxMonomials.affine_independent (r+1) t) c he i)
+  refine ⟨p,hp,?_⟩
+  have hzero : (∑b,c b • BoxMonomials.homogeneous j v b)∈F.leafPolynomialKernel P k := by
+    apply (Submodule.Quotient.mk_eq_zero _).mp
+    change (F.leafPolynomialKernel P k).mkQ (∑b,c b • BoxMonomials.homogeneous j v b)=0
+    simpa only [map_sum,map_smul] using hc
+  have hn : ∀ᶠ a in 𝓝 (P.chart (g.finite 1)).1,F.leafFrame P a j≠0 := by
+    apply ((continuous_apply j).continuousAt.comp (F.leafFrame_continuousAt P hy)).eventually_ne
+    simpa only [Function.comp_apply,leafFrame,Prod.mk.eta,P.chart.left_inv hy] using hj
+  filter_upwards [hzero,hn] with a ha haj
+  change MvPolynomial.eval (F.leafFrame P a) (↑(∑b,c b • BoxMonomials.homogeneous j v b))=0 at ha
+  have he : MvPolynomial.eval (F.leafFrame P a) (↑(∑b,c b • BoxMonomials.homogeneous j v b))=
+      (F.leafFrame P a j)^k *
+        MvPolynomial.eval (fun i => F.leafFrame P a (v i)/F.leafFrame P a j) p := by
+    simp only [Submodule.coe_sum,Submodule.coe_smul,map_sum,MvPolynomial.smul_eval,p,
+      BoxMonomials.eval_homogeneous j v _ _ haj,Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro b hb
+    ring
+  rw [he] at ha
+  exact (mul_eq_zero.mp ha).resolve_left (pow_ne_zero _ haj)
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafClosureRelations.lean

@@ -0,0 +1,78 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.LeafPolynomialGrowth
+import OAI.Geometry.SplitTangent.LeafHomogeneousRelations
+import OAI.Geometry.SplitTangent.ProjectiveHypersurfaces
+
+namespace OAI
+
+/-! Leaf Closure Relations. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B)
+
+lemma polynomialKernel_germIn {k : ℕ}
+    {Q : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k}
+    (hy : g.finite 1∈P.chart.source) (hQ : Q∈F.leafPolynomialKernel P k) :
+    L.GermIn (e.homogeneousZeroLocus Q.val) (g.finite 1) := by
+  apply (L.germIn_iff P hy).mpr
+  have ha := e.linearFrame_denominator_eventually
+    (fun i => (F.a i).eval 1) (F.finite_denominator_ne 1)
+  let s : A → X.Carrier := fun t => P.chart.symm (t,(P.chart (g.finite 1)).2)
+  have hs : ContinuousAt s (P.chart (g.finite 1)).1 :=
+    (P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt.comp
+      (f := fun t : A => (t,(P.chart (g.finite 1)).2)) (x := (P.chart (g.finite 1)).1)
+      (continuousAt_id.prodMk continuousAt_const)
+  have hae : ∀ᶠ t in 𝓝 (P.chart (g.finite 1)).1,
+      (∑i,(F.a i).eval 1*(e.map (s t)).rep i)≠0 :=
+    (by simpa only [s,P.chart.left_inv hy] using hs.tendsto :
+      Tendsto s (𝓝 (P.chart (g.finite 1)).1) (𝓝 (g.finite 1))).eventually ha
+  filter_upwards [hQ,hae] with t ht hta
+  exact (e.linearFrame_zero_iff Q.property _ hta).mp ht
+
+lemma polynomialKernel_closure_zero {k : ℕ}
+    {Q : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k}
+    (hy : g.finite 1∈P.chart.source) (hQ : Q∈F.leafPolynomialKernel P k) :
+    ∀x∈closure (L.leaf (g.finite 1)),MvPolynomial.eval (e.map x).rep Q.val=0 :=
+  L.closure_leaf_subset (e.homogeneousZeroLocus_locally_holomorphic Q.property)
+    (e.homogeneousZeroLocus_isClosed Q.property) (F.polynomialKernel_germIn L P hy hQ)
+
+include F in
+ 
+
+theorem leaf_closure_relation
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first)
+    (D : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1)
+    (H : Fin (Module.finrank ℂ (S.first (g.finite 1))+1) →
+      MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1) :
+    ∃p : MvPolynomial (Fin (Module.finrank ℂ (S.first (g.finite 1))+1)) ℂ,
+      p≠0 ∧ ∀x∈closure (L.leaf (g.finite 1)), MvPolynomial.eval (e.map x).rep D.val≠0 →
+        MvPolynomial.eval (fun i => MvPolynomial.eval (e.map x).rep (H i).val /
+          MvPolynomial.eval (e.map x).rep D.val) p=0 := by
+  obtain ⟨k,Q,hQ,p,hp,he⟩ := F.leaf_homogeneous_relation L P hy ht hg D H
+  refine ⟨p,hp,?_⟩
+  intro x hx hD
+  have hz := F.polynomialKernel_closure_zero L P hy hQ x hx
+  rw [he _ hD] at hz
+  exact (mul_eq_zero_iff_left (pow_ne_zero k hD)).mp hz
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafCompactLimits.lean

@@ -0,0 +1,83 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.CompactSetLimits
+import OAI.Geometry.SplitTangent.FoliationLeaves
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.LeafPlaques
+import OAI.Geometry.SplitTangent.AllCompactLeaves
+
+namespace OAI
+
+/-! Leaf Compact Limits. -/
+
+noncomputable section
+open Set Filter Topology TopologicalSpace
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (e : ProjectiveEmbedding X)
+  (hRC : RationallyConnected e) (hdim : 0<X.dim)
+
+def compactLeaf (x : X.Carrier) : Compacts X.Carrier :=
+  ⟨L.leaf x,L.all_leaf_isCompact e hRC hdim x⟩
+
+def leafLimits : Set (Compacts X.Carrier) := closure (range (L.compactLeaf e hRC hdim))
+
+lemma leafLimits_preconnected {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim) :
+    IsPreconnected (K : Set X.Carrier) := by
+  apply (closure_minimal (t := {K : Compacts X.Carrier | IsPreconnected (K : Set X.Carrier)})
+    ?_ CompactSetLimits.isClosed_preconnected) hK
+  rintro _ ⟨x,rfl⟩
+  exact (L.plaques.leaf_isConnected x).2
+
+lemma leafLimits_nonempty {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim) :
+    (K : Set X.Carrier).Nonempty := by
+  apply Compacts.coe_nonempty.mpr
+  have hh : K∈({⊥} : Set (Compacts X.Carrier))ᶜ :=
+    (closure_minimal (t := ({⊥} : Set (Compacts X.Carrier))ᶜ) (by
+      rintro _ ⟨x,rfl⟩
+      exact Compacts.coe_nonempty.mp ⟨x,PlaqueSystem.Reachable.refl L.plaques x⟩)
+      Compacts.isClopen_singleton_bot.isOpen.isClosed_compl) hK
+  exact hh
+
+lemma leafLimits_saturated {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    {z : X.Carrier} {U : Set (S.FirstModel z)} {V : Set (S.SecondModel z)}
+    (hU : IsOpen U) (hUc : IsPreconnected U) (hV : IsOpen V)
+    (hT : U ×ˢ V⊆(L.chart z).chart.target)
+    {a₀ a₁ : S.FirstModel z} {b : S.SecondModel z}
+    (ha₀ : a₀∈U) (ha₁ : a₁∈U) (hb : b∈V)
+    (hx : (L.chart z).chart.symm (a₀,b)∈(K : Set X.Carrier)) :
+    (L.chart z).chart.symm (a₁,b)∈(K : Set X.Carrier) := by
+  let P := (L.chart z).chart
+  let W := P.source ∩ P ⁻¹' (U ×ˢ V)
+  let f : X.Carrier → X.Carrier := fun y => P.symm (a₁,(P y).2)
+  have hW : IsOpen W := P.continuousOn.isOpen_inter_preimage P.open_source (hU.prod hV)
+  have hf : ContinuousOn f W := by
+    intro y hy
+    apply ContinuousAt.continuousWithinAt
+    exact ContinuousAt.comp (f := fun y => (a₁,(P y).2)) (g := P.symm)
+      (P.symm.continuousAt (hT ⟨ha₁,hy.2.2⟩))
+      (continuousAt_const.prodMk (P.continuousAt hy.1).snd)
+  have hInv : ∀y∈(K : Set X.Carrier),y∈W → f y∈(K : Set X.Carrier) := by
+    apply (closure_minimal (t := {K : Compacts X.Carrier |
+      ∀y∈(K : Set X.Carrier),y∈W → f y∈(K : Set X.Carrier)}) ?_
+      (CompactSetLimits.isClosed_local_invariance hW hf)) hK
+    rintro _ ⟨x,rfl⟩ y hy hyW
+    apply L.plaques.leaf_saturated hy
+    have hh := L.plaques.related_in_rectangle (i := z) hUc hT hyW.2.1 ha₁ hyW.2.2
+    change L.plaques.Related (P.symm (P y)) (f y) at hh
+    rwa [P.left_inv hyW.1] at hh
+  have ht₀ := hT (show (a₀,b)∈U ×ˢ V from ⟨ha₀,hb⟩)
+  have hh := hInv (P.symm (a₀,b)) hx ⟨P.map_target ht₀,by
+    change P (P.symm (a₀,b))∈U ×ˢ V
+    rw [P.right_inv ht₀]
+    exact ⟨ha₀,hb⟩⟩
+  simpa only [f,P.right_inv ht₀] using hh
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafGermIdentity.lean

@@ -0,0 +1,83 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Leaf Germ Identity. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma tangent_curve_snd_derivative (P : AlignedProductChart S A B)
+    {h : ℂ → X.Carrier} {z : ℂ}
+    (hh : ContMDiffAt 𝓘(ℂ,ℂ) (ModelWithCorners X) ω h z)
+    (hy : h z∈P.chart.source)
+    (ht : mfderiv 𝓘(ℂ,ℂ) (ModelWithCorners X) h z (1 : ℂ)∈S.first (h z)) :
+    HasFDerivAt (fun t => (P.chart (h t)).2) (0 : ℂ →L[ℂ] B) z := by
+  have hp := P.holomorphicAt hy
+  have ha := (hp.comp z hh).contDiffAt.analyticAt.differentiableAt
+  have hc := mfderiv_comp z (hp.mdifferentiableAt (by simp)) (hh.mdifferentiableAt (by simp))
+  rw [mfderiv_eq_fderiv] at hc
+  have hd : fderiv ℂ (fun t => (P.chart (h t)).2) z=0 := by
+    change fderiv ℂ (fun x => ((P.chart ∘ h) x).2) z=0
+    rw [fderiv.snd ha,hc]
+    apply ContinuousLinearMap.ext
+    intro w
+    have hw : mfderiv 𝓘(ℂ,ℂ) (ModelWithCorners X) h z w∈S.first (h z) := by
+      have he : w=w • (1 : ℂ) := by simp
+      erw [he,map_smul]
+      exact (S.first (h z)).smul_mem w ht
+    have hm : mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (h z)
+        (mfderiv 𝓘(ℂ,ℂ) (ModelWithCorners X) h z w) ∈
+        Submodule.map (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (h z)).toLinearMap (S.first (h z)) :=
+      ⟨_,hw,rfl⟩
+    rw [P.first _ hy] at hm
+    exact hm
+  rw [←hd]
+  exact ha.snd.hasFDerivAt
+
+omit [CompleteSpace A] [CompleteSpace B] in
+theorem tangent_curve_snd_eventually (P : AlignedProductChart S A B)
+    {h : ℂ → X.Carrier} {z₀ : ℂ}
+    (hh : ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners X) ω h)
+    (hy : h z₀∈P.chart.source)
+    (ht : ∀z,mfderiv 𝓘(ℂ,ℂ) (ModelWithCorners X) h z (1 : ℂ)∈S.first (h z)) :
+    ∀ᶠ z in 𝓝 z₀,(P.chart (h z)).2=(P.chart (h z₀)).2 := by
+  have hnh := (hh z₀).continuousAt.preimage_mem_nhds (P.chart.open_source.mem_nhds hy)
+  obtain ⟨r,hr,hs⟩ := Metric.mem_nhds_iff.mp hnh
+  have hD : ∀z∈Metric.ball z₀ r,
+      HasFDerivAt (fun t => (P.chart (h t)).2) (0 : ℂ →L[ℂ] B) z :=
+    fun z hz => P.tangent_curve_snd_derivative (hh z) (hs hz) (ht z)
+  filter_upwards [Metric.ball_mem_nhds z₀ hr] with z hz
+  exact Metric.isOpen_ball.is_const_of_fderiv_eq_zero (convex_ball z₀ r).isPreconnected
+    (fun z hz => (hD z hz).differentiableAt.differentiableWithinAt)
+    (fun z hz => (hD z hz).fderiv) hz (Metric.mem_ball_self hr)
+
+ 
+
+theorem germ_zero_of_all_jets (P : AlignedProductChart S A B) (L : LeafJetAtlas S)
+    {f : X.Carrier → ℂ} {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hz : ∀m,L.jet f y m=0) :
+    (fun a => f (P.chart.symm (a,(P.chart y).2))) =ᶠ[𝓝 (P.chart y).1] 0 := by
+  apply HorizontalJet.eventually_zero_of_all_zero (P.coordinate_function_analytic hy hf)
+  intro m
+  apply (P.jet_eq_zero_iff f hy m).mp
+  rw [P.jet_independent (L.chart y) hy (L.mem_source y) hf m (fun n hn => hz n)]
+  exact hz m
+
+end SplitTangent.AlignedProductChart
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafHomogeneousRelations.lean

@@ -0,0 +1,75 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.BoxMonomials
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.LeafPolynomialGrowth
+
+namespace OAI
+
+/-! Leaf Homogeneous Relations. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B)
+
+include L in
+theorem leaf_homogeneous_relation
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first)
+    (D : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1)
+    (H : Fin (Module.finrank ℂ (S.first (g.finite 1))+1) →
+      MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1) :
+    ∃(k : ℕ) (Q : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k),
+      Q∈F.leafPolynomialKernel P k ∧
+      ∃p : MvPolynomial (Fin (Module.finrank ℂ (S.first (g.finite 1))+1)) ℂ,
+        p≠0 ∧ ∀x : Fin (e.N+1) → ℂ,MvPolynomial.eval x D.val≠0 →
+          MvPolynomial.eval x Q.val=(MvPolynomial.eval x D.val)^k*
+            MvPolynomial.eval (fun i => MvPolynomial.eval x (H i).val/MvPolynomial.eval x D.val) p := by
+  classical
+  let r := Module.finrank ℂ (S.first (g.finite 1))
+  let C := (F.degree+r+1)^r*(F.degree+1)
+  obtain ⟨t,hbig⟩ := PolynomialGrowthArithmetic.box_exceeds C r
+  let k := (r+1)*t
+  obtain ⟨hfin,hbound⟩ := F.leaf_polynomial_growth L P hy ht hg k
+  let := hfin
+  let q : BoxMonomials.Box (r+1) t → F.LeafPolynomialGerms P k :=
+    fun b => (F.leafPolynomialKernel P k).mkQ (BoxMonomials.homogeneousForms D H b)
+  have hnot : ¬LinearIndependent ℂ q := by
+    intro hlin
+    have hcard := hlin.fintype_card_le_finrank
+    have hc : (t+1)^(r+1) ≤ Module.finrank ℂ (F.LeafPolynomialGerms P k) := by
+      simpa only [BoxMonomials.Box,Fintype.card_fun,Fintype.card_fin] using hcard
+    exact (Nat.not_lt_of_ge (hc.trans hbound)) hbig
+  obtain ⟨c,hc,i,hi⟩ := Fintype.not_linearIndependent_iff.mp hnot
+  let p : MvPolynomial (Fin (r+1)) ℂ := ∑b,c b • BoxMonomials.affine b
+  have hp : p≠0 := by
+    intro he
+    exact hi (Fintype.linearIndependent_iff.mp (BoxMonomials.affine_independent (r+1) t) c he i)
+  refine ⟨k,∑b,c b • BoxMonomials.homogeneousForms D H b,?_,p,hp,?_⟩
+  · apply (Submodule.Quotient.mk_eq_zero _).mp
+    change (F.leafPolynomialKernel P k).mkQ (∑b,c b • BoxMonomials.homogeneousForms D H b)=0
+    simpa only [map_sum,map_smul] using hc
+  · intro x hx
+    simp only [Submodule.coe_sum,Submodule.coe_smul,map_sum,MvPolynomial.smul_eval,p,
+      BoxMonomials.eval_homogeneousForms D H _ _ hx,Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro b hb
+    ring
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafJetAtlas.lean

@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.TwistedCurveTensor
+import OAI.Geometry.SplitTangent.HolomorphicManifoldProduct
+import OAI.Geometry.SplitTangent.ManifoldLeafJets
+import OAI.Geometry.SplitTangent.ManifoldJetAnalytic
+
+namespace OAI
+
+/-! Leaf Jet Atlas. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+ 
+structure LeafJetAtlas {X : ComplexManifold.{u}} (S : TangentSplitting X) where
+  chart : ∀x, AlignedProductChart S (S.FirstModel x) (S.SecondModel x)
+  mem_source : ∀x,x∈(chart x).chart.source
+
+def TangentSplitting.leafJetAtlas {X : ComplexManifold.{u}} (S : TangentSplitting X)
+    (hI₁ : Integrable X S.first) (hI₂ : Integrable X S.second) : LeafJetAtlas S where
+  chart x := (S.exists_aligned_product_chart hI₁ hI₂ x).choose
+  mem_source x := (S.exists_aligned_product_chart hI₁ hI₂ x).choose_spec.1
+
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (A : LeafJetAtlas S)
+
+abbrev jet (f : X.Carrier → ℂ) (y : X.Carrier) (m : ℕ) : TangentTensor X m :=
+  (A.chart y).jet f y m
+
+lemma jet_add {f h : X.Carrier → ℂ} {y : X.Carrier}
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hh : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω h y) (m : ℕ) :
+    A.jet (f+h) y m=A.jet f y m+A.jet h y m :=
+  (A.chart y).jet_add (A.mem_source y) hf hh m
+
+lemma jet_csmul {f : X.Carrier → ℂ} {y : X.Carrier}
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y) (m : ℕ) (c : ℂ) :
+    A.jet (c • f) y m=c • A.jet f y m :=
+  (A.chart y).jet_csmul (A.mem_source y) hf m c
+
+@[simp] lemma jet_zero (y : X.Carrier) (m : ℕ) : A.jet 0 y m=0 :=
+  (A.chart y).jet_zero y m
+
+lemma jet_smul {f v : X.Carrier → ℂ} {y : X.Carrier}
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hv : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω v y)
+    (m : ℕ) (hz : ∀n,n < m → A.jet f y n=0) :
+    A.jet (fun x => v x*f x) y m=v y • A.jet f y m :=
+  (A.chart y).jet_smul (A.mem_source y) hf hv m hz
+
+lemma jet_congr {f h : X.Carrier → ℂ} {y : X.Carrier}
+    (he : f=ᶠ[𝓝 y] h) (m : ℕ) : A.jet f y m=A.jet h y m :=
+  (A.chart y).jet_congr (A.mem_source y) he m
+
+lemma parameter_slice {f : ℂ × X.Carrier → ℂ} {z : ℂ} {y : X.Carrier}
+    (hf : ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,ℂ) ω f (z,y)) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω (fun x => f (z,x)) y :=
+  hf.comp y (contMDiffAt_const.prodMk contMDiffAt_id)
+
+ 
+
+theorem leading_analytic {g : ℂ → X.Carrier} {f : ℂ × X.Carrier → ℂ}
+    (hg : ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g)
+    (hf : ∀z,ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,ℂ) ω f (z,g z))
+    (m : ℕ) (hz : ∀z n,n < m → A.jet (fun x => f (z,x)) (g z) n=0) (z₀ : ℂ) :
+    AnalyticAt ℂ (tangentTensorCoordinates g
+      (fun z => A.jet (fun x => f (z,x)) (g z) m) z₀) z₀ := by
+  let P := A.chart (g z₀)
+  have hp := P.jet_parameter_analytic (hg z₀) (A.mem_source _) (hf z₀) m
+  apply hp.congr
+  filter_upwards [(hg z₀).continuousAt.preimage_mem_nhds
+    (P.chart.open_source.mem_nhds (A.mem_source _))] with z hPz
+  have he := P.jet_independent (A.chart (g z)) hPz (A.mem_source _)
+    (parameter_slice (hf z)) m (hz z)
+  exact congrArg (fun t : TangentTensor X m =>
+    tangentTensorCoordinates g (fun _ => t) z₀ z) he
+
+lemma jet_supported (f : X.Carrier → ℂ) (y : X.Carrier) (m : ℕ)
+    (v : Fin m → Tangent X y) :
+    A.jet f y m (fun i => S.projector y (v i))=A.jet f y m v :=
+  (A.chart y).jet_supported f (A.mem_source _) m v
+
+lemma jet_symmetric {f : X.Carrier → ℂ} {y : X.Carrier}
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (m : ℕ) (v : Fin m → Tangent X y) (σ : Equiv.Perm (Fin m)) :
+    A.jet f y m (v ∘ σ)=A.jet f y m v :=
+  (A.chart y).jet_symmetric (A.mem_source _) hf m v σ
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafLimitRelations.lean

@@ -0,0 +1,105 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.BoxRelationLocus
+import OAI.Geometry.SplitTangent.CompactPolynomialRelations
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PolynomialRelationLocus
+import OAI.Geometry.SplitTangent.ProjectiveLinearCoordinates
+import OAI.Geometry.SplitTangent.LeafCompactLimits
+
+namespace OAI
+
+/-! Leaf Limit Relations. -/
+
+noncomputable section
+open Set Filter Topology TopologicalSpace
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (e : ProjectiveEmbedding X)
+  (hRC : RationallyConnected e) (hdim : 0<X.dim)
+
+lemma leafLimits_relation {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    (x₀ : X.Carrier)
+    (D : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1)
+    (H : Fin (Module.finrank ℂ (S.first x₀)+1) →
+      MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1) :
+    ∃p : MvPolynomial (Fin (Module.finrank ℂ (S.first x₀)+1)) ℂ,p≠0 ∧
+      ∀z∈(K : Set X.Carrier),MvPolynomial.eval (e.map z).rep D.val≠0 →
+        MvPolynomial.eval (fun i => MvPolynomial.eval (e.map z).rep (H i).val /
+          MvPolynomial.eval (e.map z).rep D.val) p=0 := by
+  classical
+  obtain ⟨t,ht⟩ := L.exists_uniform_boxRelationLocus e hRC hdim x₀ D H
+  have hmem : K∈compactRelationLocus e (BoxMonomials.indexedForms D H t) := by
+    apply (closure_minimal ?_ (compactRelationLocus_isClosed e _)) hK
+    rintro _ ⟨y,rfl⟩
+    obtain ⟨c,hc,hzero⟩ := show y∈L.boxRelationLocus e D H t from ht ▸ mem_univ y
+    exact ⟨c,hc,fun z hz => hzero (subset_closure hz)⟩
+  obtain ⟨c,hc,hzero⟩ := hmem
+  let r := Module.finrank ℂ (S.first x₀)
+  let p : MvPolynomial (Fin (r+1)) ℂ := ∑j,c j • BoxMonomials.indexedAffine j
+  refine ⟨p,?_,?_⟩
+  · intro he
+    apply hc
+    funext j
+    exact Fintype.linearIndependent_iff.mp (BoxMonomials.indexedAffine_independent (r+1) t) c he j
+  · intro z hz hD
+    have hh : MvPolynomial.eval (e.map z).rep
+        (relationPolynomial e (BoxMonomials.indexedForms D H t) c).val=0 := hzero hz
+    rw [relation_eval] at hh
+    simp only [BoxMonomials.indexedForms_eval D H _ _ hD,mul_assoc,←Finset.mul_sum] at hh
+    apply (mul_eq_zero_iff_left (pow_ne_zero _ hD)).mp
+    convert hh using 1
+    simp only [p,map_sum,MvPolynomial.smul_eval]
+    congr 1
+    apply Finset.sum_congr rfl
+    intro j hj
+    ring
+
+lemma leafLimits_affine_relation {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    (x₀ : X.Carrier)
+    (p : (Fin (e.N+1) → ℂ) →ₗ[ℂ] (Fin (Module.finrank ℂ (S.first x₀)) → ℂ))
+    (i j : Fin (e.N+1)) :
+    ∃q : MvPolynomial (Option (Fin (Module.finrank ℂ (S.first x₀)))) ℂ,
+      q≠0 ∧ ∀x∈(K : Set X.Carrier),(e.map x).rep i≠0 →
+        MvPolynomial.eval (fun t => Option.elim t (projectiveCoordinates i (e.map x) j)
+          (p (projectiveCoordinates i (e.map x)))) q=0 := by
+  classical
+  let r := Module.finrank ℂ (S.first x₀)
+  let D : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1 :=
+    ⟨MvPolynomial.X i,MvPolynomial.isHomogeneous_X ℂ i⟩
+  let H : Option (Fin r) → MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ 1 :=
+    fun t => Option.elim t ⟨MvPolynomial.X j,MvPolynomial.isHomogeneous_X ℂ j⟩
+      (fun a => ProjectiveLinearCoordinates.form ((LinearMap.proj a).comp p))
+  obtain ⟨q,hq,hrel⟩ := L.leafLimits_relation e hRC hdim hK x₀ D (H ∘ finSuccEquiv r)
+  refine ⟨MvPolynomial.rename (finSuccEquiv r) q,?_,?_⟩
+  · exact fun he => hq ((MvPolynomial.rename_injective _ (finSuccEquiv r).injective)
+      (he.trans (map_zero _).symm))
+  · intro x hx hi
+    have hd : MvPolynomial.eval (e.map x).rep D.val≠0 := by
+      simpa only [D,MvPolynomial.eval_X] using hi
+    have he := hrel x hx hd
+    have hv : ∀t : Option (Fin r),
+        MvPolynomial.eval (e.map x).rep (H t).val/MvPolynomial.eval (e.map x).rep D.val =
+          Option.elim t (projectiveCoordinates i (e.map x) j) (p (projectiveCoordinates i (e.map x))) := by
+      intro t
+      cases t with
+      | none => simp only [H,D,Option.elim_none,MvPolynomial.eval_X,projectiveCoordinates,div_eq_mul_inv,mul_comm]
+      | some a =>
+          simp only [H,D,Option.elim_some,MvPolynomial.eval_X]
+          rw [ProjectiveLinearCoordinates.eval_form_ratio]
+          rfl
+    rw [MvPolynomial.eval_rename]
+    convert he using 1
+    congr 1
+    apply congrArg MvPolynomial.eval
+    funext t
+    exact (hv (finSuccEquiv r t)).symm
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafLimitsSinglePlaque.lean

@@ -0,0 +1,145 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.FoliationLeaves
+import OAI.Geometry.SplitTangent.PlaqueConnectedSets
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.LeafCompactLimits
+import OAI.Geometry.SplitTangent.LeafLimitRelations
+import OAI.Geometry.SplitTangent.AllCompactLeaves
+
+namespace OAI
+
+/-! Leaf Limits Single Plaque. -/
+
+noncomputable section
+open Set Filter Topology TopologicalSpace
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (e : ProjectiveEmbedding X)
+
+lemma leafLimits_locallySinglePlaque (hRC : RationallyConnected e) (hdim : 0<X.dim)
+    {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    (x₀ z : X.Carrier) :
+    L.plaques.LocallySinglePlaque ((K : Set X.Carrier)) z := by
+  classical
+  let P := L.chart z
+  let x := P.chart z
+  have hzs : z∈P.chart.source := L.mem_source z
+  have hxt : x∈P.chart.target := P.chart.map_source hzs
+  obtain ⟨i,hi⟩ := Function.ne_iff.mp (e.map z).rep_nonzero
+  have hi' : (e.map (P.chart.symm x)).rep i≠0 := by
+    simpa only [x,P.chart.left_inv hzs,Pi.zero_apply] using hi
+  let patch := {y : X.Carrier | (e.map y).rep i≠0}
+  have hpatch : P.chart.symm ⁻¹' patch∈𝓝 x :=
+    (P.chart.symm.continuousAt hxt).preimage_mem_nhds ((e.open_patch i).mem_nhds hi')
+  obtain ⟨U,V,hU,hUc,hV,hx,hrect⟩ := UniformPlaqueSlices.connected_rectangle
+    (Filter.inter_mem (P.chart.open_target.mem_nhds hxt) hpatch)
+  have hrectT : U ×ˢ V⊆P.chart.target := fun t hh => (hrect hh).1
+  have hrectP : ∀t∈U ×ˢ V,(e.map (P.chart.symm t)).rep i≠0 := fun t hh => (hrect hh).2
+  obtain ⟨p,Q,hxQ,hQ,_,_⟩ := e.exists_linear_plaque_coordinates P hxt i hi'
+  have hsecond : ∀t,(Q t).2=t.2 := by
+    intro t
+    rw [hQ]
+  obtain ⟨U',V',hU',hUc',hV',hxU',hxV',hVV,hQT,hslice⟩ :=
+    UniformPlaqueSlices.exists_slices Q hxQ hsecond hU hV hx
+  let T : Set (S.SecondModel z) := {b | b∈V' ∧ ∃a∈U,P.chart.symm (a,b)∈(K : Set X.Carrier)}
+  let lift : S.FirstModel z → S.SecondModel z → X.Carrier := fun a b => P.chart.symm (Q.symm (a,b))
+  have hliftUV : ∀a∈U',∀b∈T,Q.symm (a,b)∈U ×ˢ V :=
+    fun a ha b hb => (hslice a ha b hb.1).1
+  have hliftP : ∀a∈U',∀b∈T,(e.map (lift a b)).rep i≠0 :=
+    fun a ha b hb => hrectP _ (hliftUV a ha b hb)
+  have hliftW : ∀a∈U',∀b∈T,lift a b∈(K : Set X.Carrier) := by
+    intro a ha b hb
+    obtain ⟨a₀,ha₀,hw⟩ := hb.2
+    have hs := hslice a ha b hb.1
+    have hh := L.leafLimits_saturated e hRC hdim hK hU hUc hV hrectT ha₀ hs.1.1 (hVV hb.1) hw
+    change P.chart.symm _∈(K : Set X.Carrier)
+    have he : ((Q.symm (a,b)).1,b)=Q.symm (a,b) := by
+      exact Prod.ext rfl hs.2.symm
+    rwa [he] at hh
+  let r := Module.finrank ℂ (S.first x₀)
+  have hr : Module.finrank ℂ (S.FirstModel z)=Module.finrank ℂ (Fin r → ℂ) := by
+    rw [←P.first_finrank hzs]
+    simpa only [Module.finrank_fintype_fun_eq_card,Fintype.card_fin,r] using
+      L.first_rank_eq z x₀
+  let E : S.FirstModel z ≃L[ℂ] (Fin r → ℂ) := ContinuousLinearEquiv.ofFinrankEq hr
+  let coord : X.Carrier → Fin (e.N+1) → ℂ := fun y => projectiveCoordinates i (e.map y)
+  let first : X.Carrier → Fin r → ℂ := fun y => E (p (coord y))
+  have hfirst : ∀a∈U',∀b∈T,first (lift a b)=E a := by
+    intro a ha b hb
+    have hh := congrArg Prod.fst (Q.right_inv (hQT (show (a,b)∈U' ×ˢ V' from ⟨ha,hb.1⟩)))
+    rw [hQ] at hh
+    exact congrArg E hh
+  have hinj : ∀a∈U',InjOn (fun b => coord (lift a b)) T := by
+    intro a ha b hb c hc he
+    have he' := e.coordinates_injOn i (hliftP a ha b hb) (hliftP a ha c hc) he
+    have hP₁ := P.chart.right_inv (hrectT (hliftUV a ha b hb))
+    have hP₂ := P.chart.right_inv (hrectT (hliftUV a ha c hc))
+    have hh := congrArg (fun y => (P.chart y).2) he'
+    change (P.chart (P.chart.symm (Q.symm (a,b)))).2=
+      (P.chart (P.chart.symm (Q.symm (a,c)))).2 at hh
+    rw [hP₁,hP₂,(hslice a ha b hb.1).2,(hslice a ha c hc.1).2] at hh
+    exact hh
+  have hrels := fun j => L.leafLimits_affine_relation e hRC hdim hK x₀ (E.toLinearMap.comp p.toLinearMap) i j
+  choose q hq hroot using hrels
+  have hT : T.Finite := PolynomialSpecialization.finite_transversal T hU' ⟨(Q x).1,hxU'⟩
+    E lift coord first hfirst hinj q hq (by
+      intro a ha b hb j
+      exact hroot j (lift a b) (hliftW a ha b hb) (hliftP a ha b hb))
+  apply L.plaques.locallySinglePlaque_of_finite_transversal hU hUc hV'
+    (fun t ht => hrectT ⟨ht.1,hVV ht.2⟩) hzs ⟨hx.1,hxV'⟩ hT
+  intro y hy hys hyUV
+  refine ⟨hyUV.2,(P.chart y).1,hyUV.1,?_⟩
+  change P.chart.symm (P.chart y)∈(K : Set X.Carrier)
+  simpa only [P.chart.left_inv hys] using hy
+
+lemma leafLimits_subset_leaf (hRC : RationallyConnected e) (hdim : 0<X.dim)
+    {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    {x : X.Carrier} (hx : x∈(K : Set X.Carrier)) : (K : Set X.Carrier)⊆L.leaf x :=
+  L.plaques.preconnected_subset_leaf (L.leafLimits_preconnected e hRC hdim hK)
+    (fun z _ => L.leafLimits_locallySinglePlaque e hRC hdim hK x z) hx
+
+lemma leafLimits_eq_leaf (hRC : RationallyConnected e) (hdim : 0<X.dim)
+    {K : Compacts X.Carrier} (hK : K∈L.leafLimits e hRC hdim)
+    {x : X.Carrier} (hx : x∈(K : Set X.Carrier)) : (K : Set X.Carrier)=L.leaf x := by
+  apply subset_antisymm (L.leafLimits_subset_leaf e hRC hdim hK hx)
+  let Y := L.leaf x
+  let : PreconnectedSpace Y := isPreconnected_iff_preconnectedSpace.mp (L.plaques.leaf_isConnected x).2
+  let W : Set Y := {y | y.val∈(K : Set X.Carrier)}
+  have hWc : IsClosed W := K.isCompact.isClosed.preimage continuous_subtype_val
+  have hWo : IsOpen W := by
+    apply isOpen_iff_mem_nhds.mpr
+    intro y hy
+    obtain ⟨i,U,V,hU,hUc,hV,hT,hys,hyUV,huniq⟩ :=
+      L.all_leaf_locallySinglePlaque e hRC hdim x y.val y.property
+    let P := (L.chart i).chart
+    have hn : ∀ᶠ z : Y in 𝓝 y,z.val∈P.source ∧ P z.val∈U ×ˢ V :=
+      (continuous_subtype_val.tendsto y).eventually
+        (Filter.Eventually.and (P.open_source.mem_nhds hys)
+          ((P.continuousAt hys).preimage_mem_nhds ((hU.prod hV).mem_nhds hyUV)))
+    filter_upwards [hn] with z hz
+    have he := huniq z.val z.property hz.1 hz.2
+    have hh := L.leafLimits_saturated e hRC hdim hK hU hUc hV hT
+      hyUV.1 hz.2.1 hyUV.2 (show P.symm ((P y.val).1,(P y.val).2)∈(K : Set X.Carrier) by
+        simpa only [Prod.mk.eta,P.left_inv hys] using (show y.val∈(K : Set X.Carrier) from hy))
+    change (P z.val).2=(P y.val).2 at he
+    have hze : P.symm ((P z.val).1,(P y.val).2)=z.val := by
+      rw [←he]
+      exact P.left_inv hz.1
+    change P.symm ((P z.val).1,(P y.val).2)∈(K : Set X.Carrier) at hh
+    change z.val∈(K : Set X.Carrier)
+    rwa [hze] at hh
+  have hWu : W=univ := IsClopen.eq_univ ⟨hWc,hWo⟩
+    ⟨⟨x,PlaqueSystem.Reachable.refl L.plaques x⟩,hx⟩
+  intro z hz
+  exact show (⟨z,hz⟩ : Y)∈W from hWu ▸ mem_univ _
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafPlaques.lean

@@ -0,0 +1,111 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.FoliationLeaves
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.ManifoldLeafJets
+
+namespace OAI
+
+/-! Leaf Plaques. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+namespace AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B C D : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B]
+  [NormedAddCommGroup C] [NormedSpace ℂ C] [CompleteSpace C]
+  [NormedAddCommGroup D] [NormedSpace ℂ D] [CompleteSpace D]
+
+def GermIn (P : AlignedProductChart S A B) (Z : Set X.Carrier) (y : X.Carrier) : Prop :=
+  ∀ᶠ a in 𝓝 (P.chart y).1,P.chart.symm (a,(P.chart y).2)∈Z
+
+lemma germIn_transfer [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (Q : AlignedProductChart S C D)
+    {Z : Set X.Carrier} {y : X.Carrier} (hy : y∈P.chart.source) (hq : y∈Q.chart.source)
+    (h : Q.GermIn Z y) : P.GermIn Z y := by
+  let s : A → X.Carrier := fun a => P.chart.symm (a,(P.chart y).2)
+  have hs : s (P.chart y).1=y := P.chart.left_inv hy
+  have hsc : ContinuousAt s (P.chart y).1 := by
+    exact (P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt.comp
+      (f := fun a : A => (a,(P.chart y).2)) (x := (P.chart y).1)
+      (continuousAt_id.prodMk continuousAt_const)
+  have ht : ContinuousAt (Q.chart ∘ s) (P.chart y).1 :=
+    (Q.chart.continuousAt hq).comp_of_eq hsc hs
+  have hQ : ∀ᶠ a in 𝓝 (P.chart y).1,s a∈Q.chart.source :=
+    hsc.preimage_mem_nhds (by rw [hs]; exact Q.chart.open_source.mem_nhds hq)
+  have hpi : Tendsto (fun a : A => (a,(P.chart y).2)) (𝓝 (P.chart y).1) (𝓝 (P.chart y)) :=
+    continuousAt_id.prodMk continuousAt_const
+  have haxes := hpi.eventually (P.transition_product Q (P.chart.map_source hy)
+    (by simpa only [P.chart.left_inv hy] using hq))
+  have hfirst : Tendsto (fun a => (Q.chart (s a)).1) (𝓝 (P.chart y).1) (𝓝 (Q.chart y).1) := by
+    simpa only [ContinuousAt,Function.comp_apply,hs] using ht.fst
+  filter_upwards [hQ,haxes,hfirst.eventually h] with a hQa hax ha
+  have hb : (Q.chart (s a)).2=(Q.chart y).2 := by
+    have hb := congrArg Prod.snd hax
+    simpa only [Function.comp_apply,Prod.mk.eta,P.chart.left_inv hy,s] using hb
+  change s a∈Z
+  have he : Q.chart.symm ((Q.chart (s a)).1,(Q.chart y).2)=s a := by
+    rw [←hb,Prod.mk.eta,Q.chart.left_inv hQa]
+  rwa [he] at ha
+
+lemma germIn_iff [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (Q : AlignedProductChart S C D)
+    {Z : Set X.Carrier} {y : X.Carrier} (hy : y∈P.chart.source) (hq : y∈Q.chart.source) :
+    P.GermIn Z y ↔ Q.GermIn Z y :=
+  ⟨Q.germIn_transfer P hq hy,P.germIn_transfer Q hy hq⟩
+
+lemma all_jets_of_germ_zero [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (L : LeafJetAtlas S)
+    {f : X.Carrier → ℂ} {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hz : (fun a => f (P.chart.symm (a,(P.chart y).2))) =ᶠ[𝓝 (P.chart y).1] 0) :
+    ∀m,L.jet f y m=0 := by
+  have hP : ∀m,P.jet f y m=0 := by
+    intro m
+    apply (P.jet_eq_zero_iff f hy m).mpr
+    apply (HorizontalJet.value_eq_zero_iff _ _ _).mpr
+    have he := (hz.iteratedFDeriv ℂ m).self_of_nhds
+    simpa only [Function.comp_apply,iteratedFDeriv_zero,Pi.zero_apply] using he
+  intro m
+  induction m using Nat.strong_induction_on with
+  | h m ih =>
+    change (L.chart y).jet f y m=0
+    rw [← P.jet_independent (L.chart y) hy (L.mem_source y) hf m (fun n hn => ih n hn)]
+    exact hP m
+
+end AlignedProductChart
+
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+
+def plaques : PlaqueSystem X.Carrier S.FirstModel S.SecondModel where
+  chart x := (L.chart x).chart
+  covering x := ⟨x,L.mem_source x⟩
+
+abbrev leaf (x : X.Carrier) : Set X.Carrier := L.plaques.leaf x
+
+def GermIn (Z : Set X.Carrier) (y : X.Carrier) : Prop := (L.chart y).GermIn Z y
+
+lemma germIn_iff {A B : Type*}
+    [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+    [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {Z : Set X.Carrier} {y : X.Carrier}
+    (hy : y∈P.chart.source) : L.GermIn Z y ↔ P.GermIn Z y :=
+  (L.chart y).germIn_iff P (L.mem_source y) hy
+
+lemma germIn_mem {Z : Set X.Carrier} {y : X.Carrier} (h : L.GermIn Z y) : y∈Z := by
+  have he := h.self_of_nhds
+  simpa only [Prod.mk.eta,(L.chart y).chart.left_inv (L.mem_source y)] using he
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafPolynomialGrowth.lean

@@ -0,0 +1,125 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.AmbientLeafSectionBound
+import OAI.Geometry.SplitTangent.CurveHomogeneousSections
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.PolynomialLeafGerms
+
+namespace OAI
+
+/-! Leaf Polynomial Growth. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+  (P : AlignedProductChart S A B)
+
+def leafPolynomialKernel (k : ℕ) :
+    Submodule ℂ (MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k) where
+  carrier := {p | (fun t : A => MvPolynomial.eval
+      (F.finite 1 (P.chart.symm (t,(P.chart (g.finite 1)).2))) p.val)
+        =ᶠ[𝓝 (P.chart (g.finite 1)).1] 0}
+  zero_mem' := by
+    filter_upwards [] with t
+    simp
+  add_mem' := by
+    intro p q hp hq
+    filter_upwards [hp,hq] with t ht ht'
+    simp only [Submodule.coe_add,MvPolynomial.eval_add,ht,ht',Pi.zero_apply,add_zero]
+  smul_mem' := by
+    intro c p hp
+    filter_upwards [hp] with t ht
+    simp only [Submodule.coe_smul,MvPolynomial.smul_eval,ht,Pi.zero_apply,mul_zero]
+
+abbrev LeafPolynomialGerms (k : ℕ) :=
+  (MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k) ⧸ F.leafPolynomialKernel P k
+
+def coefficientQuotient (a k : ℕ) : HomogeneousTuple (e := e) a k →ₗ[ℂ]
+    (Fin (a+1) → F.LeafPolynomialGerms P k) where
+  toFun p i := (F.leafPolynomialKernel P k).mkQ (p i)
+  map_add' _ _ := by ext i; exact map_add _ _ _
+  map_smul' c p := by
+    funext i
+    exact (F.leafPolynomialKernel P k).mkQ.map_smul c (p i)
+
+omit [CompleteSpace A] [CompleteSpace B] in
+lemma coefficientQuotient_surjective (a k : ℕ) :
+    Function.Surjective (F.coefficientQuotient P a k) := by
+  intro q
+  choose p hp using fun i => (F.leafPolynomialKernel P k).mkQ_surjective (q i)
+  exact ⟨p,funext hp⟩
+
+def sectionGermMap (a k : ℕ) : HomogeneousTuple (e := e) a k →ₗ[ℂ]
+    (F.ambientTransition a k).GermSpace L :=
+  (SeparatedQuotientFiltration.zeroPart ((F.ambientTransition a k).contact L)).mkQ.comp (F.sections a k)
+
+lemma sectionGermMap_ker_le (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (a k : ℕ) : (F.sectionGermMap L a k).ker ≤ (F.coefficientQuotient P a k).ker := by
+  intro p hp
+  have hf : F.sections a k p∈SeparatedQuotientFiltration.zeroPart
+      ((F.ambientTransition a k).contact L) := (Submodule.Quotient.mk_eq_zero _).mp hp
+  have hc := F.flat_section_coefficients L P hy ht p hf
+  change F.coefficientQuotient P a k p=0
+  funext i
+  exact (Submodule.Quotient.mk_eq_zero _).mpr (hc i)
+
+include L in
+ 
+
+theorem leaf_polynomial_finite_and_bound
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first) (a k : ℕ) :
+    Module.Finite ℂ (F.LeafPolynomialGerms P k) ∧
+      (a+1)*Module.finrank ℂ (F.LeafPolynomialGerms P k) ≤
+        (a+k*F.degree+Module.finrank ℂ (S.first (g.finite 1))).choose
+          (Module.finrank ℂ (S.first (g.finite 1)))*(a+k*F.degree+1) := by
+  obtain ⟨hfin,hbound⟩ := (F.ambientTransition a k).germ_finite_and_bound L hg
+  let := hfin
+  obtain ⟨hQ,hb⟩ := LinearKernelDimension.finite_and_bound (F.sectionGermMap L a k)
+    (F.coefficientQuotient P a k) (F.sectionGermMap_ker_le L P hy ht a k)
+    (F.coefficientQuotient_surjective P a k)
+  let := hQ
+  let ev : (Fin (a+1) → F.LeafPolynomialGerms P k) →ₗ[ℂ] F.LeafPolynomialGerms P k :=
+    LinearMap.proj (0 : Fin (a+1))
+  have hev : Function.Surjective ev := fun v => ⟨fun _ => v,rfl⟩
+  let : Module.Finite ℂ (F.LeafPolynomialGerms P k) := Module.Finite.of_surjective ev hev
+  refine ⟨inferInstance,?_⟩
+  let : AddCommGroup (F.LeafPolynomialGerms P k) :=
+    Module.addCommMonoidToAddCommGroup ℂ
+  have he : Module.finrank ℂ (Fin (a+1) → F.LeafPolynomialGerms P k)=
+      (a+1)*Module.finrank ℂ (F.LeafPolynomialGerms P k) := by
+    rw [Module.finrank_pi_fintype]
+    simp
+  rw [he] at hb
+  exact hb.trans hbound
+
+include L in
+ 
+
+theorem leaf_polynomial_growth
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    (hg : PointedGenerated g S.first) (k : ℕ) :
+    Module.Finite ℂ (F.LeafPolynomialGerms P k) ∧
+      Module.finrank ℂ (F.LeafPolynomialGerms P k) ≤
+        (F.degree+Module.finrank ℂ (S.first (g.finite 1))+1)^
+          (Module.finrank ℂ (S.first (g.finite 1)))*(F.degree+1)*
+            (k+1)^(Module.finrank ℂ (S.first (g.finite 1))) := by
+  obtain ⟨hf,hb⟩ := F.leaf_polynomial_finite_and_bound L P hy ht hg k k
+  exact ⟨hf,PolynomialGrowthArithmetic.cancel_graph_dimension _ _ _ _ hb⟩
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafProducts.lean

@@ -0,0 +1,107 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.LeafPlaques
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.SmoothLeafManifold
+import OAI.Geometry.SplitTangent.SmoothLeafProjection
+import OAI.Geometry.SplitTangent.EverywhereSmoothLeafQuotient
+import OAI.Geometry.SplitTangent.ProductCriteria
+
+namespace OAI
+
+/-! Leaf Products. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+lemma TangentSplitting.ext_projector {X : ComplexManifold.{u}} {S T : TangentSplitting X}
+    (h : S.projector=T.projector) : S=T := by
+  cases S
+  cases T
+  cases h
+  rfl
+
+lemma TangentSplitting.swap_swap_eq {X : ComplexManifold.{u}} (S : TangentSplitting X) :
+    S.swap.swap=S := by
+  apply TangentSplitting.ext_projector
+  funext x
+  ext v
+  change v-(v-S.projector x v)=S.projector x v
+  abel
+
+namespace LeafJetAtlas
+
+lemma leaf_cast {X : ComplexManifold.{u}} {S T : TangentSplitting X}
+    (h : S=T) (L : LeafJetAtlas S) (x : X.Carrier) :
+    (h ▸ L).leaf x=L.leaf x := by
+  cases h
+  rfl
+
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  (L : LeafJetAtlas S) (M : LeafJetAtlas S.swap) (e : ProjectiveEmbedding X)
+  (hRC : RationallyConnected e) (hdim : 0<X.dim)
+
+ 
+
+theorem compatible_projective_product_of_leafPair_injective
+    (hinj : Function.Injective (L.leafPair M e hRC hdim)) :
+    HasCompatibleProjectiveProduct X S := by
+  let N : LeafJetAtlas S.swap.swap := S.swap_swap_eq.symm ▸ L
+  have hinj' : Function.Injective (M.leafPair N e hRC hdim) := by
+    intro x y hxy
+    apply hinj
+    apply Prod.ext
+    · have he := congrArg Prod.snd hxy
+      change N.leafQuotient e hRC hdim x=N.leafQuotient e hRC hdim y at he
+      have hm := (N.leafQuotient_eq_iff e hRC hdim x y).mp he
+      apply (L.leafQuotient_eq_iff e hRC hdim x y).mpr
+      change y∈N.leaf x at hm
+      rw [leaf_cast S.swap_swap_eq.symm L x] at hm
+      exact hm
+    · exact congrArg Prod.fst hxy
+  have hL : ∀x,L.leafQuotient e hRC hdim x∈L.smoothLeafLocus e hRC hdim := by
+    intro x
+    rw [L.smoothLeafLocus_eq_univ_of_pair_injective M e hRC hdim hinj]
+    exact mem_univ _
+  have hM : ∀x,M.leafQuotient e hRC hdim x∈M.smoothLeafLocus e hRC hdim := by
+    intro x
+    rw [M.smoothLeafLocus_eq_univ_of_pair_injective N e hRC hdim hinj']
+    exact mem_univ _
+  let x₀ := Classical.arbitrary X.Carrier
+  let Y := SmoothLeafManifold.manifold (L := M) (e := e) (hRC := hRC) (hdim := hdim) N x₀
+  let Z := SmoothLeafManifold.manifold (L := L) (e := e) (hRC := hRC) (hdim := hdim) M x₀
+  let p : X.Carrier → Y.Carrier := SmoothLeafManifold.projection N x₀ hM
+  let q : X.Carrier → Z.Carrier := SmoothLeafManifold.projection M x₀ hL
+  have hp := SmoothLeafManifold.projection_holomorphic N x₀ hM
+  have hq := SmoothLeafManifold.projection_holomorphic M x₀ hL
+  have hk₁ (x) : LinearMap.ker
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Y) p x).toLinearMap=S.second x := by
+    have h := SmoothLeafManifold.projection_kernel N x₀ hM x
+    rw [S.swap_first] at h
+    exact h
+  have hk₂ (x) : LinearMap.ker
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q x).toLinearMap=S.first x :=
+    SmoothLeafManifold.projection_kernel M x₀ hL x
+  have hb : Function.Bijective (fun x => (p x,q x)) := by
+    constructor
+    · intro x y hxy
+      apply hinj
+      exact Prod.ext (congrArg (fun z => z.2.val) hxy) (congrArg (fun z => z.1.val) hxy)
+    · intro yz
+      obtain ⟨x,hx⟩ := L.surjective_leafPair M e hRC hdim (yz.2.val,yz.1.val)
+      exact ⟨x,Prod.ext (Subtype.ext (congrArg Prod.snd hx))
+        (Subtype.ext (congrArg Prod.fst hx))⟩
+  exact S.compatible_product_of_bijective_quotients e Y Z p q hp hq
+    (SmoothLeafManifold.projection_submersion N x₀ hM)
+    (SmoothLeafManifold.projection_submersion M x₀ hL) hk₁ hk₂ hb
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafRank.lean

@@ -0,0 +1,71 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Leaf Rank. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+namespace AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B]
+
+def firstLinearMap (P : AlignedProductChart S A B) (y : X.Carrier) : S.first y →ₗ[ℂ] A :=
+  (ContinuousLinearMap.fst ℂ A B).toLinearMap.comp
+    ((mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y).toLinearMap.comp (S.first y).subtype)
+
+lemma firstLinearMap_bijective (P : AlignedProductChart S A B) {y : X.Carrier}
+    (hy : y∈P.chart.source) : Function.Bijective (P.firstLinearMap y) := by
+  have hz : ∀ v : S.first y,
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y v.val).2=0 := by
+    intro v
+    have hm := Submodule.mem_map_of_mem (f :=
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y).toLinearMap) v.property
+    rw [P.first y hy] at hm
+    exact hm
+  constructor
+  · intro v w he
+    apply Subtype.ext
+    apply P.mdifferentiable.mfderiv_injective hy
+    exact Prod.ext he ((hz v).trans (hz w).symm)
+  · intro a
+    have ha : (a,0)∈Submodule.map
+        (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y).toLinearMap (S.first y) := by
+      rw [P.first y hy]
+      rfl
+    obtain ⟨v,hv,he⟩ := ha
+    exact ⟨⟨v,hv⟩,congrArg Prod.fst he⟩
+
+lemma first_finrank (P : AlignedProductChart S A B) {y : X.Carrier}
+    (hy : y∈P.chart.source) : Module.finrank ℂ (S.first y)=Module.finrank ℂ A :=
+  (LinearEquiv.ofBijective (P.firstLinearMap y) (P.firstLinearMap_bijective hy)).finrank_eq
+
+end AlignedProductChart
+namespace LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} (L : LeafJetAtlas S)
+
+include L in
+lemma first_rank_locally_constant : IsLocallyConstant (fun x => Module.finrank ℂ (S.first x)) := by
+  apply (IsLocallyConstant.iff_eventually_eq _).mpr
+  intro x
+  filter_upwards [(L.chart x).chart.open_source.mem_nhds (L.mem_source x)] with y hy
+  exact ((L.chart x).first_finrank hy).trans ((L.chart x).first_finrank (L.mem_source x)).symm
+
+include L in
+lemma first_rank_eq [PreconnectedSpace X.Carrier] (x y : X.Carrier) :
+    Module.finrank ℂ (S.first x)=Module.finrank ℂ (S.first y) :=
+  L.first_rank_locally_constant.apply_eq_of_preconnectedSpace x y
+
+end LeafJetAtlas
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/LeafTopology.lean

@@ -0,0 +1,54 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.FoliationLeaves
+
+namespace OAI
+
+/-! Leaf Topology. -/
+
+noncomputable section
+open Set Filter Topology
+universe u v w
+namespace PlaqueSystem
+variable {ι : Type v} {X : Type u} [TopologicalSpace X]
+  {A B : ι → Type w} [∀i,TopologicalSpace (A i)] [∀i,TopologicalSpace (B i)]
+  (P : PlaqueSystem X A B)
+
+lemma related_connected_subset {x y : X} (h : P.Related x y) :
+    ∃Z, Z⊆P.leaf x ∧ x∈Z ∧ y∈Z ∧ IsPreconnected Z := by
+  obtain ⟨i,b,U,hU,hT,a,ha,c,hc,hx,hy⟩ := h
+  let f : A i → X := fun t => (P.chart i).symm (t,b)
+  have hf : ContinuousOn f U := (P.chart i).symm.continuousOn.comp
+    ((continuous_id.prodMk continuous_const).continuousOn) (fun t ht => hT t ht)
+  refine ⟨f '' U,?_,⟨a,ha,hx⟩,⟨c,hc,hy⟩,hU.image f hf⟩
+  rintro z ⟨d,hd,rfl⟩
+  apply Relation.ReflTransGen.single
+  exact ⟨i,b,U,hU,hT,a,ha,d,hd,hx,rfl⟩
+
+lemma reachable_connected_subset {x y : X} (h : P.Reachable x y) :
+    ∃Z, Z⊆P.leaf x ∧ x∈Z ∧ y∈Z ∧ IsPreconnected Z := by
+  induction h with
+  | refl => exact ⟨{x},by intro z hz; subst z; exact Relation.ReflTransGen.refl,by simp,by simp,isPreconnected_singleton⟩
+  | @tail y z hyz h ih =>
+    obtain ⟨U,hU,hx,hy,hUc⟩ := ih
+    obtain ⟨V,hV,hy',hz,hVc⟩ := P.related_connected_subset h
+    refine ⟨U∪V,?_,Or.inl hx,Or.inr hz,hUc.union y hy hy' hVc⟩
+    intro w hw
+    rcases hw with hw | hw
+    · exact hU hw
+    · exact Relation.ReflTransGen.trans hyz (hV hw)
+
+lemma leaf_isConnected (x : X) : IsConnected (P.leaf x) := by
+  refine ⟨⟨x,Relation.ReflTransGen.refl⟩,isPreconnected_of_forall x ?_⟩
+  intro y hy
+  exact P.reachable_connected_subset hy
+
+lemma leaf_eq_of_mem {x y : X} (h : y∈P.leaf x) : P.leaf y=P.leaf x := by
+  ext z
+  exact ⟨fun hz => Relation.ReflTransGen.trans h hz,
+    fun hz => Relation.ReflTransGen.trans (Reachable.symm P h) hz⟩
+
+end PlaqueSystem
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ManifoldJetAnalytic.lean

@@ -0,0 +1,114 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.TwistedCurveTensor
+import OAI.Geometry.SplitTangent.ManifoldLeafJets
+
+namespace OAI
+
+/-! Manifold Jet Analytic. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+
+lemma derivative_coordinates_analytic (P : AlignedProductChart S A B)
+    {g : ℂ → X.Carrier} {z₀ : ℂ}
+    (hg : ContMDiffAt 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g z₀)
+    (hy : g z₀∈P.chart.source) :
+    AnalyticAt ℂ (F := Model X →L[ℂ] A × B) (fun z : ℂ =>
+      ((mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (g z) : Model X →L[ℂ] A × B).comp
+        ((trivializationAt (Model X) (Tangent X) (g z₀)).symmL ℂ (g z)) : Model X →L[ℂ] A × B)) z₀ := by
+  let c := chartAt (Model X) (g z₀)
+  let t := trivializationAt (Model X) (Tangent X) (g z₀)
+  have hc0 : g z₀∈c.source := mem_chart_source _ _
+  have hcinv := contMDiffAt_symm_of_mem_maximalAtlas
+    (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) (n := ω) (g z₀))
+    (c.map_source hc0)
+  have hP : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,A × B) ω P.chart (c.symm (c (g z₀))) := by
+    simpa only [c.left_inv hc0] using P.holomorphicAt hy
+  have hpc : AnalyticAt ℂ (P.chart ∘ c.symm) (c (g z₀)) :=
+    (hP.comp _ hcinv).contDiffAt.analyticAt
+  have hcg : AnalyticAt ℂ (c ∘ g) z₀ :=
+    ((contMDiffAt_of_mem_maximalAtlas
+      (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) (n := ω) (g z₀)) hc0).comp _ hg).contDiffAt.analyticAt
+  have h := AnalyticAt.comp (g := fderiv ℂ (P.chart ∘ c.symm)) (f := c ∘ g) hpc.fderiv hcg
+  apply h.congr
+  filter_upwards [hg.continuousAt.preimage_mem_nhds (c.open_source.mem_nhds hc0),
+    hg.continuousAt.preimage_mem_nhds (P.chart.open_source.mem_nhds hy)] with z hcz hpz
+  have ht : t.symmL ℂ (g z)=mfderiv 𝓘(ℂ,Model X) (ModelWithCorners X) c.symm (c (g z)) := by
+    simpa [t,c,extChartAt_coe_symm,extChartAt_coe,ModelWithCorners] using
+      (TangentBundle.symmL_trivializationAt (I := ModelWithCorners X) hcz)
+  have hci := (contMDiffAt_symm_of_mem_maximalAtlas
+    (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) (n := ω) (g z₀))
+    (c.map_source hcz)).mdifferentiableAt (by simp)
+  have hpi : MDifferentiableAt (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (c.symm (c (g z))) := by
+    simpa only [c.left_inv hcz] using (P.holomorphicAt hpz).mdifferentiableAt (by simp)
+  change fderiv ℂ (P.chart ∘ c.symm) (c (g z))=_
+  rw [←mfderiv_eq_fderiv,mfderiv_comp _ hpi hci,c.left_inv hcz,←ht]
+  rfl
+
+ 
+lemma jet_analytic (P : AlignedProductChart S A B)
+    {g : ℂ → X.Carrier} {z₀ : ℂ} {f : X.Carrier → ℂ}
+    (hg : ContMDiffAt 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g z₀)
+    (hy : g z₀∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f (g z₀)) (m : ℕ) :
+    AnalyticAt ℂ (tangentTensorCoordinates g (fun z => P.jet f (g z) m) z₀) z₀ := by
+  have hv := AnalyticAt.comp (f := P.chart ∘ g) (g := fun y => HorizontalJet.value (f ∘ P.chart.symm) y m)
+    (HorizontalJet.analytic_value (P.coordinate_function_analytic hy hf) m)
+    (((P.holomorphicAt hy).comp _ hg).contDiffAt.analyticAt)
+  have hd := P.derivative_coordinates_analytic hg hy
+  have hdp : AnalyticAt ℂ (F := Fin m → (Model X →L[ℂ] A × B)) (fun z : ℂ => fun _ : Fin m =>
+      ((mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (g z) : Model X →L[ℂ] A × B).comp
+        ((trivializationAt (Model X) (Tangent X) (g z₀)).symmL ℂ (g z)) : Model X →L[ℂ] A × B)) z₀ :=
+    analyticAt_pi_iff.mpr fun _ => hd
+  have hh := ContinuousMultilinearMap.analyticAt_uncurry_compContinuousLinearMap.comp
+    (hdp.prod hv)
+  exact hh
+
+ 
+
+lemma jet_parameter_analytic (P : AlignedProductChart S A B)
+    {g : ℂ → X.Carrier} {z₀ : ℂ} {f : ℂ × X.Carrier → ℂ}
+    (hg : ContMDiffAt 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g z₀)
+    (hy : g z₀∈P.chart.source)
+    (hf : ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,ℂ) ω f (z₀,g z₀))
+    (m : ℕ) :
+    AnalyticAt ℂ (tangentTensorCoordinates g
+      (fun z => P.jet (fun x => f (z,x)) (g z) m) z₀) z₀ := by
+  let h : ℂ × (A × B) → ℂ := fun w => f (w.1,P.chart.symm w.2)
+  have hf' : ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,ℂ) ω
+      f (z₀,P.chart.symm (P.chart (g z₀))) := by
+    simpa only [P.chart.left_inv hy] using hf
+  have hh : AnalyticAt ℂ h (z₀,P.chart (g z₀)) := by
+    have hi : ContMDiffAt 𝓘(ℂ,ℂ × (A × B)) (ModelWithCorners X) ω
+        (fun w : ℂ × (A × B) => P.chart.symm w.2) (z₀,P.chart (g z₀)) :=
+      (P.inverse_holomorphicAt (P.chart.map_source hy)).comp (z₀,P.chart (g z₀))
+        (show ContMDiffAt 𝓘(ℂ,ℂ × (A × B)) 𝓘(ℂ,A × B) ω Prod.snd _ from
+          contDiff_snd.contDiffAt.contMDiffAt)
+    exact (hf'.comp (z₀,P.chart (g z₀))
+      ((show ContMDiffAt 𝓘(ℂ,ℂ × (A × B)) 𝓘(ℂ,ℂ) ω Prod.fst _ from
+        contDiff_fst.contDiffAt.contMDiffAt).prodMk hi)).contDiffAt.analyticAt
+  have hv := HorizontalJet.analytic_parameter_value (g := P.chart ∘ g) hh
+    (((P.holomorphicAt hy).comp _ hg).contDiffAt.analyticAt) m
+  have hd := P.derivative_coordinates_analytic hg hy
+  have hdp : AnalyticAt ℂ (F := Fin m → (Model X →L[ℂ] A × B))
+      (fun z : ℂ => fun _ : Fin m =>
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (g z) : Model X →L[ℂ] A × B).comp
+        ((trivializationAt (Model X) (Tangent X) (g z₀)).symmL ℂ (g z))) z₀ :=
+    analyticAt_pi_iff.mpr fun _ => hd
+  exact ContinuousMultilinearMap.analyticAt_uncurry_compContinuousLinearMap.comp
+    (hdp.prod hv)
+
+end SplitTangent.AlignedProductChart
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ManifoldLeafJets.lean

@@ -0,0 +1,205 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Manifold Leaf Jets. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.AlignedProductChart
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {A B C D : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B]
+  [NormedAddCommGroup C] [NormedSpace ℂ C]
+  [NormedAddCommGroup D] [NormedSpace ℂ D]
+
+ 
+def jet (P : AlignedProductChart S A B) (f : X.Carrier → ℂ)
+    (y : X.Carrier) (m : ℕ) :
+    ContinuousMultilinearMap ℂ (fun _ : Fin m => Tangent X y) ℂ :=
+  (HorizontalJet.value (f ∘ P.chart.symm) (P.chart y) m).compContinuousLinearMap
+    (fun _ => mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y)
+
+lemma jet_eq_zero_iff [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (f : X.Carrier → ℂ)
+    {y : X.Carrier} (hy : y∈P.chart.source) (m : ℕ) :
+    P.jet f y m=0 ↔ HorizontalJet.value (f ∘ P.chart.symm) (P.chart y) m=0 := by
+  constructor
+  · intro h
+    ext w
+    choose v hv using fun i => P.mdifferentiable.mfderiv_surjective hy (w i)
+    have he := congrArg (fun K => K v) h
+    change HorizontalJet.value (f ∘ P.chart.symm) (P.chart y) m
+      (fun i => mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i))=0 at he
+    have hw : (fun i => mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i))=w := funext hv
+    rwa [hw] at he
+  · intro h
+    ext v
+    simp only [jet,h]
+    rfl
+
+lemma coordinate_function_analytic [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B)
+    {f : X.Carrier → ℂ} {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y) :
+    AnalyticAt ℂ (f ∘ P.chart.symm) (P.chart y) := by
+  have hf' : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f
+      (P.chart.symm (P.chart y)) := by simpa only [P.chart.left_inv hy] using hf
+  exact (hf'.comp _ (P.inverse_holomorphicAt (P.chart.map_source hy))).contDiffAt.analyticAt
+
+lemma transition_derivative [CompleteSpace A] [CompleteSpace B]
+    [CompleteSpace C] [CompleteSpace D] (P : AlignedProductChart S A B)
+    (Q : AlignedProductChart S C D) {y : X.Carrier}
+    (hy : y∈P.chart.source) (hq : y∈Q.chart.source) :
+    (fderiv ℂ (Q.chart ∘ P.chart.symm) (P.chart y)).comp
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y) =
+        mfderiv (ModelWithCorners X) 𝓘(ℂ,C × D) Q.chart y := by
+  have hq' : P.chart.symm (P.chart y)∈Q.chart.source := by simpa only [P.chart.left_inv hy] using hq
+  have ht := (Q.holomorphicAt hq').comp _ (P.inverse_holomorphicAt (P.chart.map_source hy))
+  have hc := mfderiv_comp y (ht.mdifferentiableAt (by simp))
+    ((P.holomorphicAt hy).mdifferentiableAt (by simp))
+  rw [mfderiv_eq_fderiv] at hc
+  have he : ((Q.chart ∘ P.chart.symm) ∘ P.chart) =ᶠ[𝓝 y] Q.chart := by
+    filter_upwards [P.chart.open_source.mem_nhds hy] with z hz
+    exact congrArg Q.chart (P.chart.left_inv hz)
+  exact hc.symm.trans he.mfderiv_eq
+
+ 
+
+theorem jet_independent [CompleteSpace A] [CompleteSpace B]
+    [CompleteSpace C] [CompleteSpace D] (P : AlignedProductChart S A B)
+    (Q : AlignedProductChart S C D) {f : X.Carrier → ℂ} {y : X.Carrier}
+    (hy : y∈P.chart.source) (hq : y∈Q.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (m : ℕ) (hz : ∀n,n < m → Q.jet f y n=0) :
+    P.jet f y m=Q.jet f y m := by
+  let T : A × B → C × D := Q.chart ∘ P.chart.symm
+  have hq' : P.chart.symm (P.chart y)∈Q.chart.source := by simpa only [P.chart.left_inv hy] using hq
+  have hT : AnalyticAt ℂ T (P.chart y) :=
+    ((Q.holomorphicAt hq').comp _ (P.inverse_holomorphicAt (P.chart.map_source hy))).contDiffAt.analyticAt
+  have hx : T (P.chart y)=Q.chart y := congrArg Q.chart (P.chart.left_inv hy)
+  have hfc : AnalyticAt ℂ (f ∘ Q.chart.symm) (T (P.chart y)) :=
+    hx.symm ▸ Q.coordinate_function_analytic hq hf
+  have hzero (n : ℕ) (hn : n < m) :
+      HorizontalJet.value (f ∘ Q.chart.symm) (T (P.chart y)) n=0 :=
+    hx.symm ▸ (Q.jet_eq_zero_iff f hq n).mp (hz n hn)
+  have hcomp := HorizontalJet.value_comp hfc hT
+    (P.transition_axes Q (P.chart.map_source hy) hq') m hzero
+  have he : (f ∘ P.chart.symm) =ᶠ[𝓝 (P.chart y)] ((f ∘ Q.chart.symm) ∘ T) := by
+    filter_upwards [(P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt.preimage_mem_nhds
+      (Q.chart.open_source.mem_nhds hq')] with z hz
+    exact congrArg f (Q.chart.left_inv hz).symm
+  have hval := (HorizontalJet.value_congr he m).trans hcomp
+  have hd := P.transition_derivative Q hy hq
+  ext v
+  change HorizontalJet.value (f ∘ P.chart.symm) (P.chart y) m
+    (fun i => mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i)) = _
+  rw [hval]
+  change HorizontalJet.value (f ∘ Q.chart.symm) (T (P.chart y)) m
+    (fun i => ((fderiv ℂ T (P.chart y)).comp
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y)) (v i)) = _
+  rw [hx,hd]
+  rfl
+
+ 
+
+theorem jet_smul [CompleteSpace A] [CompleteSpace B] (P : AlignedProductChart S A B)
+    {f v : X.Carrier → ℂ} {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hv : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω v y)
+    (m : ℕ) (hz : ∀n,n < m → P.jet f y n=0) :
+    P.jet (fun z => v z*f z) y m=v y • P.jet f y m := by
+  have he := HorizontalJet.value_smul (P.coordinate_function_analytic hy hf)
+    (P.coordinate_function_analytic hy hv) m
+    (fun n hn => (P.jet_eq_zero_iff f hy n).mp (hz n hn))
+  ext w
+  change HorizontalJet.value (fun z => (v ∘ P.chart.symm) z • (f ∘ P.chart.symm) z)
+    (P.chart y) m _ = _
+  rw [he]
+  simp only [smul_apply,Function.comp_apply,P.chart.left_inv hy]
+  rfl
+
+ 
+
+lemma jet_supported [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (f : X.Carrier → ℂ)
+    {y : X.Carrier} (hy : y∈P.chart.source) (m : ℕ)
+    (v : Fin m → Tangent X y) :
+    P.jet f y m (fun i => S.projector y (v i))=P.jet f y m v := by
+  have he (w : Tangent X y) :
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (S.projector y w)).1=
+        (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y w).1 := by
+    have hk : w-S.projector y w∈S.second y := by
+      change S.projector y (w-S.projector y w)=0
+      rw [map_sub,S.idempotent,sub_self]
+    have hm := Submodule.mem_map_of_mem (f :=
+      (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y).toLinearMap) hk
+    rw [P.second y hy] at hm
+    change (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (w-S.projector y w)).1=0 at hm
+    erw [map_sub,Prod.fst_sub,sub_eq_zero] at hm
+    exact hm.symm
+  change iteratedFDeriv ℂ m (fun a => (f ∘ P.chart.symm) (a,(P.chart y).2)) (P.chart y).1
+    (fun i => (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (S.projector y (v i))).1)=_
+  simp only [he]
+  rfl
+
+lemma jet_symmetric [CompleteSpace A] [CompleteSpace B] (P : AlignedProductChart S A B)
+    {f : X.Carrier → ℂ} {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (m : ℕ) (v : Fin m → Tangent X y) (σ : Equiv.Perm (Fin m)) :
+    P.jet f y m (v ∘ σ)=P.jet f y m v := by
+  exact (HorizontalJet.slice_analytic (P.coordinate_function_analytic hy hf)).contDiffAt.iteratedFDeriv_comp_perm
+    (fun i => (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i)).1) σ
+
+lemma jet_congr [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {f h : X.Carrier → ℂ}
+    {y : X.Carrier} (hy : y∈P.chart.source) (he : f=ᶠ[𝓝 y] h) (m : ℕ) :
+    P.jet f y m=P.jet h y m := by
+  have hi : Tendsto P.chart.symm (𝓝 (P.chart y)) (𝓝 y) := by
+    simpa only [P.chart.left_inv hy] using
+      (P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt.tendsto
+  have hc' := he.comp_tendsto hi
+  unfold jet
+  rw [HorizontalJet.value_congr hc' m]
+
+lemma jet_add [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {f h : X.Carrier → ℂ}
+    {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y)
+    (hh : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω h y) (m : ℕ) :
+    P.jet (f+h) y m=P.jet f y m+P.jet h y m := by
+  have hf' := (HorizontalJet.slice_analytic (P.coordinate_function_analytic hy hf)).contDiffAt (n := m)
+  have hh' := (HorizontalJet.slice_analytic (P.coordinate_function_analytic hy hh)).contDiffAt (n := m)
+  ext v
+  exact congrArg (fun K => K (fun i =>
+    (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i)).1))
+      (iteratedFDeriv_add_apply hf' hh')
+
+lemma jet_csmul [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) {f : X.Carrier → ℂ}
+    {y : X.Carrier} (hy : y∈P.chart.source)
+    (hf : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,ℂ) ω f y) (m : ℕ) (c : ℂ) :
+    P.jet (c • f) y m=c • P.jet f y m := by
+  ext v
+  have hf' := (HorizontalJet.slice_analytic (P.coordinate_function_analytic hy hf)).contDiffAt (n := m)
+  exact congrArg (fun K => K (fun i =>
+    (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart y (v i)).1))
+      (iteratedFDeriv_const_smul_apply (a := c) hf')
+
+@[simp] lemma jet_zero [CompleteSpace A] [CompleteSpace B]
+    (P : AlignedProductChart S A B) (y : X.Carrier) (m : ℕ) :
+    P.jet 0 y m=0 := by
+  ext v
+  simp [jet,HorizontalJet.value]
+  rfl
+
+end SplitTangent.AlignedProductChart
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/OpenManifold.lean

@@ -0,0 +1,58 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Open Manifold. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped ContDiff Manifold
+universe u
+namespace SplitTangent
+namespace OpenManifold
+variable {d : ℕ} (U : Set (Fin d → ℂ)) (hU : IsOpen U) (hne : U.Nonempty)
+
+abbrev Carrier := ULift.{u} U
+include hne in
+theorem nonempty : Nonempty (Carrier.{u} U) := ⟨⟨⟨hne.choose,hne.choose_spec⟩⟩⟩
+def val (x : Carrier.{u} U) : Fin d → ℂ := x.down.val
+include hU in
+lemma isOpenEmbedding_val : IsOpenEmbedding (val (U := U) : Carrier.{u} U → _) :=
+  hU.isOpenEmbedding_subtypeVal.comp Homeomorph.ulift.isOpenEmbedding
+
+def manifold : ComplexManifold.{u} where
+  dim := d
+  Carrier := Carrier.{u} U
+  charts := by
+    letI := nonempty U hne
+    exact (isOpenEmbedding_val U hU).singletonChartedSpace
+  secondCountable := Homeomorph.ulift.isInducing.secondCountableTopology
+  holomorphicAtlas := by
+    let := nonempty U hne
+    exact (isOpenEmbedding_val U hU).isManifold_singleton
+
+lemma val_holomorphic : ContMDiff (ModelWithCorners (manifold.{u} U hU hne))
+    𝓘(ℂ, Fin d → ℂ) ω (fun x : (manifold.{u} U hU hne).Carrier => val U x) := by
+  let := nonempty U hne
+  exact contMDiff_isOpenEmbedding (isOpenEmbedding_val U hU)
+
+lemma val_mem (x : (manifold.{u} U hU hne).Carrier) : val (U := U) x∈U := x.down.property
+
+lemma range_val : Set.range (val (U := U) : (manifold.{u} U hU hne).Carrier → _)=U := by
+  ext x
+  exact ⟨fun ⟨y,hy⟩ => hy ▸ y.down.property, fun hx => ⟨⟨⟨x,hx⟩⟩,rfl⟩⟩
+
+lemma val_mfderiv_bijective (x : (manifold.{u} U hU hne).Carrier) :
+    Function.Bijective (mfderiv (ModelWithCorners (manifold.{u} U hU hne))
+      𝓘(ℂ, Fin d → ℂ) (fun y : (manifold.{u} U hU hne).Carrier => val U y) x) := by
+  have H := (mdifferentiable_chart (I := ModelWithCorners (manifold.{u} U hU hne)) x).mfderiv_bijective
+    (mem_chart_source (Model (manifold.{u} U hU hne)) x)
+  exact H
+
+end OpenManifold
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/OpenPositiveLeaves.lean

@@ -0,0 +1,87 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.BracketIntegrability
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.CompactPositiveLeaf
+import OAI.Geometry.SplitTangent.ProjectivePositiveLeaf
+
+namespace OAI
+
+/-! Open Positive Leaves. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+namespace RationalFamily
+variable {X T : ComplexManifold.{u}} (G : RationalFamily X T)
+
+def evaluation (a : ℂ) (τ : T.Carrier) : X.Carrier := G.finite (a,τ)
+
+lemma evaluation_holomorphic (a : ℂ) :
+    ContMDiff (ModelWithCorners T) (ModelWithCorners X) ω (G.evaluation a) :=
+  G.finite_holomorphic.comp (contMDiff_const.prodMk contMDiff_id)
+
+lemma evaluation_surjective_derivative {τ : T.Carrier}
+    (hs : Function.Surjective (mfderiv (ModelWithCorners T)
+      ((ModelWithCorners X).prod (ModelWithCorners X)) (G.twoPointEvaluation 0 1) τ)) :
+    Function.Surjective (mfderiv (ModelWithCorners T) (ModelWithCorners X) (G.evaluation 1) τ) := by
+  intro w
+  obtain ⟨v,hv⟩ := hs (0,w)
+  refine ⟨v,?_⟩
+  rw [G.twoPointEvaluation_derivative] at hv
+  exact congrArg Prod.snd hv
+
+lemma evaluation_open
+    (hs : ∀τ,Function.Surjective (mfderiv (ModelWithCorners T)
+      ((ModelWithCorners X).prod (ModelWithCorners X)) (G.twoPointEvaluation 0 1) τ)) :
+    IsOpenMap (G.evaluation 1) :=
+  HolomorphicLocalDiffeomorph.isOpenMap_of_surjective_mfderiv (G.evaluation_holomorphic 1)
+    (fun τ => G.evaluation_surjective_derivative (hs τ))
+
+end RationalFamily
+namespace TangentSplitting
+variable {X : ComplexManifold.{u}} [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+    (S : TangentSplitting X) (e : ProjectiveEmbedding X)
+
+ 
+
+omit [ConnectedSpace X.Carrier] in
+theorem exists_open_positive_leaves (hRC : RationallyConnected e) (hdim : 0<X.dim) :
+    ∃U : Set X.Carrier,IsOpen U ∧ U.Nonempty ∧
+      ∀x∈U,∃g : RationalCurve X,g.finite 1=x ∧ g.TangentTo S.first ∧ PointedGenerated g S.first := by
+  obtain ⟨T,hT,G,hs⟩ := hRC.exists_submersive_family e hdim
+  let := hT
+  refine ⟨Set.range (G.evaluation 1),(G.evaluation_open hs).isOpen_range,
+    Set.range_nonempty _,?_⟩
+  rintro x ⟨τ,rfl⟩
+  obtain ⟨B⟩ := S.exists_projective_tangent_box e (G.curve τ)
+  exact ⟨B.firstFactor 1,B.firstFactor_diagonal 1,B.firstFactor_tangentTo 1,
+    B.firstFactor_pointedGenerated (G.pointedGenerated_of_submersive S τ (hs τ))⟩
+
+ 
+
+theorem exists_open_compact_leaves (hRC : RationallyConnected e) (hdim : 2≤X.dim) :
+    ∃L : LeafJetAtlas S,∃U : Set X.Carrier,IsOpen U ∧ U.Nonempty ∧
+      ∀x∈U,IsCompact (L.leaf x) ∧
+        ∀y∈L.leaf x,L.plaques.LocallySinglePlaque (L.leaf x) y := by
+  obtain ⟨hI₁,hI₂⟩ := S.integrable_of_rationallyConnected e hRC hdim
+  let L := S.leafJetAtlas hI₁ hI₂
+  obtain ⟨U,hU,hUn,hg⟩ := S.exists_open_positive_leaves e hRC (by omega)
+  refine ⟨L,U,hU,hUn,?_⟩
+  intro x hx
+  obtain ⟨g,he,ht,hp⟩ := hg x hx
+  obtain ⟨F⟩ := g.exists_frames e
+  rw [←he]
+  exact ⟨F.leaf_isCompact L ht hp,F.leaf_locallySinglePlaque L ht hp⟩
+
+end TangentSplitting
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PlaqueConnectedSets.lean

@@ -0,0 +1,58 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.FoliationLeaves
+
+namespace OAI
+
+/-! Plaque Connected Sets. -/
+
+noncomputable section
+open Set Filter Topology
+universe u v w
+namespace PlaqueSystem
+variable {ι : Type v} {X : Type u} [TopologicalSpace X]
+  {A B : ι → Type w} [∀i,TopologicalSpace (A i)] [∀i,TopologicalSpace (B i)]
+  (P : PlaqueSystem X A B)
+
+lemma LocallySinglePlaque.eventually_reachable {Z : Set X} {z : X}
+    (h : P.LocallySinglePlaque Z z) : ∀ᶠ y in 𝓝[Z] z,P.Reachable z y := by
+  obtain ⟨i,U,V,hU,hUc,hV,hT,hzs,hzUV,huniq⟩ := h
+  have hn : ∀ᶠ y in 𝓝 z,y∈(P.chart i).source ∧ (P.chart i) y∈U ×ˢ V :=
+    Filter.Eventually.and ((P.chart i).open_source.mem_nhds hzs)
+      (((P.chart i).continuousAt hzs).preimage_mem_nhds ((hU.prod hV).mem_nhds hzUV))
+  filter_upwards [hn.filter_mono nhdsWithin_le_nhds,self_mem_nhdsWithin] with y hy hyZ
+  have he := huniq y hyZ hy.1 hy.2
+  have hr := P.related_in_rectangle hUc hT hzUV.1 hy.2.1 hzUV.2
+  have hy' : (P.chart i).symm (((P.chart i) y).1,((P.chart i) z).2)=y := by
+    rw [←he]
+    exact (P.chart i).left_inv hy.1
+  change P.Related ((P.chart i).symm ((P.chart i) z))
+    ((P.chart i).symm (((P.chart i) y).1,((P.chart i) z).2)) at hr
+  rw [(P.chart i).left_inv hzs,hy'] at hr
+  exact Relation.ReflTransGen.single hr
+
+ 
+
+lemma preconnected_subset_leaf {Z : Set X} (hZ : IsPreconnected Z)
+    (hlocal : ∀z∈Z,P.LocallySinglePlaque Z z) {x : X} (hx : x∈Z) : Z⊆P.leaf x := by
+  let : PreconnectedSpace Z := isPreconnected_iff_preconnectedSpace.mp hZ
+  let f : Z → Prop := fun y => P.Reachable x y.val
+  have hf : IsLocallyConstant f := by
+    apply (IsLocallyConstant.iff_eventually_eq f).mpr
+    intro y
+    have ht : Tendsto (Subtype.val : Z → X) (𝓝 y) (𝓝[Z] y.val) :=
+      tendsto_inf.mpr ⟨continuous_subtype_val.tendsto y,
+        tendsto_principal.mpr (Filter.Eventually.of_forall (fun z : Z => z.property))⟩
+    have hh := ht.eventually
+      ((hlocal y.val y.property).eventually_reachable P)
+    filter_upwards [hh] with z hz
+    apply propext
+    exact ⟨fun hxz => Reachable.trans P hxz (Reachable.symm P hz),fun hxy => Reachable.trans P hxy hz⟩
+  intro y hy
+  have hh := hf.apply_eq_of_preconnectedSpace (⟨y,hy⟩ : Z) ⟨x,hx⟩
+  exact hh.mpr (Reachable.refl P x)
+
+end PlaqueSystem
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PlaqueTangentImage.lean

@@ -0,0 +1,54 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Plaque Tangent Image. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u v
+namespace SplitTangent.AlignedProductChart
+variable {X : ComplexManifold.{u}} {Y : ComplexManifold.{v}} {S : TangentSplitting X}
+  {A B : Type*} [NormedAddCommGroup A] [NormedSpace ℂ A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B]
+
+lemma mfderiv_into_first (P : AlignedProductChart S A B) {f : Y.Carrier → X.Carrier}
+    {y : Y.Carrier} (hf : ContMDiffAt (ModelWithCorners Y) (ModelWithCorners X) ω f y)
+    (hy : f y∈P.chart.source)
+    (hplaque : ∀ᶠ z in 𝓝 y,(P.chart (f z)).2=(P.chart (f y)).2)
+    (v : Tangent Y y) :
+    mfderiv (ModelWithCorners Y) (ModelWithCorners X) f y v∈S.first (f y) := by
+  have hp := P.holomorphicAt hy
+  have hcomp := hp.comp y hf
+  have hzero : mfderiv (ModelWithCorners Y) 𝓘(ℂ,B) (fun z => (P.chart (f z)).2) y=0 := by
+    have he : (fun z => (P.chart (f z)).2) =ᶠ[𝓝 y] (fun _ => (P.chart (f y)).2) := hplaque
+    rw [he.mfderiv_eq,mfderiv_const]
+    simp
+  have hds := mfderiv_comp y ((ContinuousLinearMap.snd ℂ A B).differentiableAt.mdifferentiableAt)
+    (hcomp.mdifferentiableAt (by simp))
+  have hdc := mfderiv_comp y (hp.mdifferentiableAt (by simp)) (hf.mdifferentiableAt (by simp))
+  have hs : (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (f y)
+      (mfderiv (ModelWithCorners Y) (ModelWithCorners X) f y v)).2=0 := by
+    have he := DFunLike.congr_fun hzero v
+    change mfderiv (ModelWithCorners Y) 𝓘(ℂ,B) ((ContinuousLinearMap.snd ℂ A B) ∘ P.chart ∘ f) y v=0 at he
+    rw [hds,hdc,mfderiv_eq_fderiv] at he
+    simp only [ContinuousLinearMap.fderiv] at he
+    exact he
+  have hm : mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (f y)
+      (mfderiv (ModelWithCorners Y) (ModelWithCorners X) f y v) ∈
+      Submodule.map (mfderiv (ModelWithCorners X) 𝓘(ℂ,A × B) P.chart (f y)).toLinearMap
+        (S.first (f y)) := by
+    rw [P.first _ hy]
+    exact hs
+  obtain ⟨w,hw,he⟩ := hm
+  have he' := P.mdifferentiable.mfderiv_injective hy he
+  exact he' ▸ hw
+
+end SplitTangent.AlignedProductChart
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PolynomialLeafGerms.lean

@@ -0,0 +1,96 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.AmbientLeafGerm
+import OAI.Geometry.SplitTangent.CurveHomogeneousSections
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.ProjectiveLineFrame
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+
+namespace OAI
+
+/-! Polynomial Leaf Germs. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+
+def baseMultiplier (q : ℂ × X.Carrier) : ℂ :=
+  ∑i,(F.a i).eval 1*F.finite q.1 q.2 i
+
+lemma baseMultiplier_holomorphic :
+    ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,ℂ) ω
+      F.baseMultiplier (1,g.finite 1) := by
+  apply contMDiffAt_finsetSum
+  intro i hi
+  exact (contMDiffAt_const (I' := 𝓘(ℂ,ℂ))).mul
+    (contMDiffAt_pi_space.mp (F.finite_joint_holomorphicAt 1) i)
+
+lemma baseMultiplier_one : F.baseMultiplier (1,g.finite 1)=1 := by
+  simp only [baseMultiplier,F.finite_on_curve]
+  exact F.finite_unit 1
+
+lemma base_frame_eventually : ∀ᶠ q : ℂ × X.Carrier in 𝓝 (1,g.finite 1),
+    F.finite q.1 q.2=F.baseMultiplier q • F.finite 1 q.2 ∧ F.baseMultiplier q≠0 := by
+  have hn : F.baseMultiplier (1,g.finite 1)≠0 := by rw [F.baseMultiplier_one]; exact one_ne_zero
+  filter_upwards [F.baseMultiplier_holomorphic.continuousAt.eventually_ne hn] with q hq
+  have he : F.baseMultiplier q=
+      (∑i,(F.a i).eval q.1*(e.map q.2).rep i)⁻¹ *
+        (∑i,(F.a i).eval 1*(e.map q.2).rep i) := by
+    simp only [baseMultiplier,finite,ProjectiveEmbedding.linearFrame,Pi.smul_apply,smul_eq_mul]
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i hi
+    ring
+  have hb : (∑i,(F.a i).eval 1*(e.map q.2).rep i)≠0 := by
+    rw [he] at hq
+    exact (mul_ne_zero_iff.mp hq).2
+  exact ⟨e.linearFrame_change _ _ q.2 hb,hq⟩
+
+variable (L : LeafJetAtlas S)
+  {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [CompleteSpace A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [CompleteSpace B]
+
+ 
+
+theorem flat_section_coefficients (P : AlignedProductChart S A B)
+    (hy : g.finite 1∈P.chart.source) (ht : g.TangentTo S.first)
+    {a k : ℕ} (p : HomogeneousTuple (e := e) a k)
+    (hf : F.sections a k p∈SeparatedQuotientFiltration.zeroPart ((F.ambientTransition a k).contact L)) :
+    ∀i,(fun t : A => MvPolynomial.eval (F.finite 1 (P.chart.symm (t,(P.chart (g.finite 1)).2))) (p i).val)
+      =ᶠ[𝓝 (P.chart (g.finite 1)).1] 0 := by
+  let b := (P.chart (g.finite 1)).2
+  let t₀ := (P.chart (g.finite 1)).1
+  have hh := (F.ambientTransition a k).flat_joint_germ L (F.sections a k p) hf ht P hy
+  have hm : Tendsto (fun q : ℂ × A => (q.1,P.chart.symm (q.2,b)))
+      (𝓝 (1,t₀)) (𝓝 (1,g.finite 1)) := by
+    have hInv : ContinuousAt P.chart.symm (t₀,b) :=
+      (P.inverse_holomorphicAt (P.chart.map_source hy)).continuousAt
+    have hP : ContinuousAt (fun q : ℂ × A => P.chart.symm (q.2,b)) (1,t₀) :=
+      hInv.comp (f := fun q : ℂ × A => (q.2,b)) (x := (1,t₀))
+        (continuousAt_snd.prodMk continuousAt_const)
+    simpa only [ContinuousAt,t₀,b,Prod.mk.eta,P.chart.left_inv hy] using continuousAt_fst.prodMk hP
+  apply PolynomialCoefficientGerms.coefficient_germs _ (1 : ℂ)
+  filter_upwards [hh,hm.eventually F.base_frame_eventually] with q hq hframe
+  change (∑i : Fin (a+1),q.1^i.val*MvPolynomial.eval (F.finite q.1 (P.chart.symm (q.2,b))) (p i).val)=0 at hq
+  have he : (∑i : Fin (a+1),q.1^i.val*MvPolynomial.eval (F.finite q.1 (P.chart.symm (q.2,b))) (p i).val)=
+      (F.baseMultiplier (q.1,P.chart.symm (q.2,b)))^k*
+        (∑i : Fin (a+1),q.1^i.val*MvPolynomial.eval (F.finite 1 (P.chart.symm (q.2,b))) (p i).val) := by
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i hi
+    rw [hframe.1,_root_.OAI.MvPolynomial.IsHomogeneous.eval_scale (p i).property]
+    ring
+  rw [he] at hq
+  exact (mul_eq_zero.mp hq).resolve_left (pow_ne_zero _ hframe.2)
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PolynomialRelationLocus.lean

@@ -0,0 +1,122 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.HolomorphicCommonZeros
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.ProjectiveHypersurfaces
+
+namespace OAI
+
+/-! Polynomial Relation Locus. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  (L : LeafJetAtlas S) (e : ProjectiveEmbedding X) {n k : ℕ}
+  (Q : Fin n → MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k)
+
+def relationPolynomial (c : Fin n → ℂ) : MvPolynomial.homogeneousSubmodule (Fin (e.N+1)) ℂ k :=
+  ∑j,c j • Q j
+
+def relationLocus : Set X.Carrier := {x | ∃c : Fin n → ℂ,c≠0 ∧
+  closure (L.leaf x) ⊆ e.homogeneousZeroLocus (relationPolynomial e Q c).val}
+
+lemma relation_eval (c : Fin n → ℂ) (w : Fin (e.N+1) → ℂ) :
+    MvPolynomial.eval w (relationPolynomial e Q c).val=∑j,MvPolynomial.eval w (Q j).val*c j := by
+  simp only [relationPolynomial,Submodule.coe_sum,Submodule.coe_smul,map_sum,MvPolynomial.smul_eval]
+  apply Finset.sum_congr rfl
+  intro j hj
+  simp only [mul_comm]
+
+lemma relation_rectangle_iff {x z : X.Carrier} (i : Fin (e.N+1))
+    {U : Set (S.FirstModel x)} {V : Set (S.SecondModel x)}
+    (hU : IsOpen U) (hUc : IsPreconnected U)
+    (hrect : U ×ˢ V ⊆ (L.chart x).chart.target)
+    (hpatch : ∀t∈U ×ˢ V,(e.map ((L.chart x).chart.symm t)).rep i≠0)
+    (hz : z∈(L.chart x).chart.source) (hzUV : (L.chart x).chart z∈U ×ˢ V) :
+    z∈L.relationLocus e Q ↔ ∃c : Fin n → ℂ,c≠0 ∧ ∀a : U,
+      ∑j,MvPolynomial.eval (projectiveCoordinates i (e.map ((L.chart x).chart.symm
+        (a.val,((L.chart x).chart z).2)))) (Q j).val*c j=0 := by
+  let P := L.chart x
+  constructor
+  · rintro ⟨c,hc,hzero⟩
+    refine ⟨c,hc,fun a => ?_⟩
+    have hrel := L.plaques.related_in_rectangle hUc hrect hzUV.1 a.property hzUV.2
+    change L.plaques.Related (P.chart.symm (P.chart z))
+      (P.chart.symm (a.val,(P.chart z).2)) at hrel
+    rw [P.chart.left_inv hz] at hrel
+    have hleaf : P.chart.symm (a.val,(P.chart z).2)∈L.leaf z :=
+      Relation.ReflTransGen.single hrel
+    have hh := (e.homogeneous_coordinates_zero_iff (relationPolynomial e Q c).property i
+      (hpatch (a.val,(P.chart z).2) ⟨a.property,hzUV.2⟩)).mp (hzero (subset_closure hleaf))
+    rwa [relation_eval] at hh
+  · rintro ⟨c,hc,hzero⟩
+    refine ⟨c,hc,?_⟩
+    apply L.closure_leaf_subset
+      (e.homogeneousZeroLocus_locally_holomorphic (relationPolynomial e Q c).property)
+      (e.homogeneousZeroLocus_isClosed (relationPolynomial e Q c).property)
+    apply (L.germIn_iff P hz).mpr
+    change ∀ᶠa in 𝓝 (P.chart z).1,
+      P.chart.symm (a,(P.chart z).2)∈e.homogeneousZeroLocus (relationPolynomial e Q c).val
+    filter_upwards [hU.mem_nhds hzUV.1] with a ha
+    apply (e.homogeneous_coordinates_zero_iff (relationPolynomial e Q c).property i
+      (hpatch (a,(P.chart z).2) ⟨ha,hzUV.2⟩)).mpr
+    rw [relation_eval]
+    exact hzero ⟨a,ha⟩
+
+ 
+
+theorem relationLocus_locally_holomorphic :
+    LocallyHolomorphicCommonZeros X (L.relationLocus e Q) := by
+  classical
+  intro x
+  let P := L.chart x
+  have hxs : x∈P.chart.source := L.mem_source x
+  have hxt : P.chart x∈P.chart.target := P.chart.map_source hxs
+  obtain ⟨i,hi⟩ := Function.ne_iff.mp (e.map x).rep_nonzero
+  change (e.map x).rep i≠0 at hi
+  let patch := {y : X.Carrier | (e.map y).rep i≠0}
+  have hpatch : P.chart.symm ⁻¹' patch∈𝓝 (P.chart x) := by
+    apply (P.chart.symm.continuousAt hxt).preimage_mem_nhds
+    simpa only [P.chart.left_inv hxs] using (e.open_patch i).mem_nhds hi
+  obtain ⟨U,V,hU,hUc,hV,hxUV,hrect⟩ := UniformPlaqueSlices.connected_rectangle
+    (Filter.inter_mem (P.chart.open_target.mem_nhds hxt) hpatch)
+  have hrectT : U ×ˢ V⊆P.chart.target := fun t ht => (hrect ht).1
+  have hrectP : ∀t∈U ×ˢ V,(e.map (P.chart.symm t)).rep i≠0 := fun t ht => (hrect ht).2
+  let W := P.chart.source ∩ P.chart ⁻¹' (U ×ˢ V)
+  have hW : IsOpen W := P.chart.continuousOn.isOpen_inter_preimage P.chart.open_source (hU.prod hV)
+  let row : U → X.Carrier → Fin n → ℂ := fun a y j =>
+    MvPolynomial.eval (projectiveCoordinates i (e.map (P.chart.symm (a.val,(P.chart y).2)))) (Q j).val
+  let f : (Fin n → U) → X.Carrier → ℂ := fun s y => Matrix.det (fun a b => row (s a) y b)
+  refine ⟨W,hW,⟨hxs,hxUV⟩,Set.range f,?_,?_⟩
+  · rintro _ ⟨s,rfl⟩ y hy
+    apply ContMDiffAt.contMDiffWithinAt
+    apply HolomorphicDeterminant.contMDiffAt_det
+    intro a b
+    have hC : ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,S.FirstModel x × S.SecondModel x) ω
+        (fun z => ((s a).val,(P.chart z).2)) y := by
+      apply (contMDiffAt_prod_module_iff _).mpr
+      exact ⟨contMDiffAt_const,(contMDiffAt_prod_module_iff _).mp (P.holomorphicAt hy.1) |>.2⟩
+    have hI := (P.inverse_holomorphicAt (hrectT (show ((s a).val,(P.chart y).2)∈U ×ˢ V from ⟨(s a).property,hy.2.2⟩))).comp y hC
+    have he := ((e.holomorphic i).contMDiffAt ((e.open_patch i).mem_nhds
+      (hrectP ((s a).val,(P.chart y).2) ⟨(s a).property,hy.2.2⟩))).comp y hI
+    exact _root_.OAI.MvPolynomial.contMDiffAt_eval_comp (ModelWithCorners X) (Q b).val
+      (fun j => contMDiffAt_pi_space.mp he j)
+  · intro y hy
+    have hiff := L.relation_rectangle_iff e Q i hU hUc hrectT hrectP hy.1 hy.2
+    rw [hiff,FiniteSampling.relation_iff_det_zero]
+    constructor
+    · intro hd f' hf'
+      obtain ⟨s,rfl⟩ := hf'
+      exact hd s
+    · intro hd s
+      exact hd (f s) ⟨s,rfl⟩
+
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PolynomialSpecialization.lean

@@ -0,0 +1,100 @@
+import Mathlib
+
+namespace OAI
+
+/-! Polynomial Specialization. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped ContDiff Manifold BigOperators
+namespace PolynomialSpecialization
+open MvPolynomial
+
+lemma eval_analyticAt {σ : Type*} [Fintype σ] (p : MvPolynomial σ ℂ) (x : σ → ℂ) :
+    AnalyticAt ℂ (fun y => eval y p) x := by
+  induction p using MvPolynomial.induction_on with
+  | C c => simpa only [eval_C] using (analyticAt_const (v := c) (x := x))
+  | add p q hp hq =>
+      have he : (fun y => eval y (p+q))=((fun y => eval y p)+(fun y => eval y q)) := by
+        funext y
+        exact eval_add
+      rw [he]
+      exact hp.add hq
+  | mul_X p i hp =>
+      have he : (fun y => eval y (p*X i))=((fun y => eval y p)*(fun y => y i)) := by
+        funext y
+        simp only [eval_mul,eval_X,Pi.mul_apply]
+      rw [he]
+      exact hp.mul ((ContinuousLinearMap.proj i : (σ → ℂ) →L[ℂ] ℂ).analyticAt x)
+
+lemma eq_zero_of_zero_on_open {σ : Type*} [Fintype σ]
+    (p : MvPolynomial σ ℂ) {U : Set (σ → ℂ)} (hU : IsOpen U) (hne : U.Nonempty)
+    (hp : ∀a∈U,eval a p=0) : p=0 := by
+  obtain ⟨a,ha⟩ := hne
+  have hz : (fun y => eval y p) =ᶠ[𝓝 a] 0 := by
+    filter_upwards [hU.mem_nhds ha] with y hy
+    exact hp y hy
+  have he := (show AnalyticOnNhd ℂ (fun y => eval y p) univ from
+    fun y _ => eval_analyticAt p y).eqOn_zero_of_preconnected_of_eventuallyEq_zero
+      isPreconnected_univ (mem_univ a) hz
+  apply MvPolynomial.funext
+  intro y
+  simpa using he (mem_univ y)
+
+lemma exists_simultaneously_nonzero {σ ι : Type*} [Fintype σ] [Fintype ι]
+    (p : ι → MvPolynomial σ ℂ) (hp : ∀i,p i≠0)
+    {U : Set (σ → ℂ)} (hU : IsOpen U) (hne : U.Nonempty) :
+    ∃a∈U,∀i,eval a (p i)≠0 := by
+  classical
+  by_contra! h
+  have he : (∏i,p i)=0 := eq_zero_of_zero_on_open _ hU hne (by
+    intro a ha
+    obtain ⟨i,hi⟩ := h a ha
+    rw [map_prod]
+    exact Finset.prod_eq_zero (Finset.mem_univ i) hi)
+  exact (Finset.prod_ne_zero_iff.mpr (fun i _ => hp i)) he
+
+ 
+
+theorem generic_specialization {σ ι : Type*} [Fintype σ] [Fintype ι]
+    (p : ι → MvPolynomial (Option σ) ℂ) (hp : ∀i,p i≠0)
+    {U : Set (σ → ℂ)} (hU : IsOpen U) (hne : U.Nonempty) :
+    ∃a∈U,∀i,Polynomial.map (eval a) (optionEquivLeft ℂ σ (p i))≠0 := by
+  classical
+  have hc : ∀i,∃n,(optionEquivLeft ℂ σ (p i)).coeff n≠0 := by
+    intro i
+    by_contra! h
+    apply hp i
+    apply (optionEquivLeft ℂ σ).injective
+    rw [map_zero]
+    exact Polynomial.ext (by simpa using h)
+  choose n hn using hc
+  obtain ⟨a,ha,h⟩ := exists_simultaneously_nonzero
+    (fun i => (optionEquivLeft ℂ σ (p i)).coeff (n i)) hn hU hne
+  refine ⟨a,ha,fun i he => h i ?_⟩
+  have hec := congrArg (fun q : Polynomial ℂ => q.coeff (n i)) he
+  simpa only [Polynomial.coeff_map,Polynomial.coeff_zero] using hec
+
+ 
+
+theorem finite_fiber {ι B : Type*} [Fintype ι]
+    (T : Set B) (f : B → ι → ℂ) (hf : Set.InjOn f T)
+    (p : ι → Polynomial ℂ) (hp : ∀i,p i≠0)
+    (hroot : ∀b∈T,∀i,(p i).IsRoot (f b i)) : T.Finite := by
+  let R (i : ι) := {c : ℂ // (p i).IsRoot c}
+  let : ∀i,Finite (R i) := fun i => (Polynomial.finite_setOfPred_isRoot (hp i)).to_subtype
+  let g : T → ∀i,R i := fun b i => ⟨f b.val i,hroot b.val b.property i⟩
+  have hg : Function.Injective g := by
+    intro a b he
+    apply Subtype.ext
+    apply hf a.property b.property
+    funext i
+    exact congrArg Subtype.val (congrFun he i)
+  let : Finite T := Finite.of_injective g hg
+  exact Set.toFinite T
+
+end PolynomialSpecialization
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PositiveCoverLift.lean

@@ -0,0 +1,148 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.HolomorphicTangentMapAt
+import OAI.Geometry.SplitTangent.BracketIntegrability
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCoverLift
+
+namespace OAI
+
+/-! Positive Cover Lift. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+variable {X Y : ComplexManifold.{u}} {p : Y.Carrier → X.Carrier}
+
+ 
+def coverTangentLift
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (y : Y.Carrier) : Tangent X (p y) →L[ℂ] Tangent Y y :=
+  ((hp y).mfderivToContinuousLinearEquiv (by simp)).symm.toContinuousLinearMap
+
+lemma coverTangentLift_leftInverse
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (y : Y.Carrier) (v : Tangent Y y) :
+    coverTangentLift hp y (mfderiv (ModelWithCorners Y) (ModelWithCorners X) p y v)=v :=
+  ((hp y).mfderivToContinuousLinearEquiv (by simp)).symm_apply_apply v
+
+lemma coverTangentLift_eq_localInverse
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (y z : Y.Carrier) (hz : z∈(hp y).localInverse.target) (v : Tangent X (p z)) :
+    coverTangentLift hp z v=
+      mfderiv (ModelWithCorners X) (ModelWithCorners Y) (hp y).localInverse (p z) v := by
+  let h := hp y
+  have hps : p z∈h.localInverse.source := by
+    rw [h.choose_spec.2 hz]
+    exact h.choose.map_source hz
+  have hdi := (h.localInverse_contMDiffOn.contMDiffAt
+    (h.localInverse.open_source.mem_nhds hps)).mdifferentiableAt (by simp)
+  have he : h.localInverse ∘ p =ᶠ[𝓝 z] id :=
+    Filter.eventuallyEq_of_mem (h.localInverse.open_target.mem_nhds hz)
+      h.localInverse_eqOn_left
+  have hd := mfderiv_comp z hdi ((hp z).mdifferentiableAt (by simp))
+  rw [he.mfderiv_eq,mfderiv_id] at hd
+  let C := (hp z).mfderivToContinuousLinearEquiv (by simp)
+  have hh := DFunLike.congr_fun hd (C.symm v)
+  change C.symm v=mfderiv (ModelWithCorners X) (ModelWithCorners Y)
+    h.localInverse (p z) (C (C.symm v)) at hh
+  change C.symm v=mfderiv (ModelWithCorners X) (ModelWithCorners Y)
+    h.localInverse (p z) v
+  simpa only [C.apply_symm_apply] using hh
+
+lemma coverTangentLift_holomorphic
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    {g : ℂ → Y.Carrier} {σ : ∀t,Tangent X (p (g t))}
+    (hg : Continuous g)
+    (hσ : ContMDiff 𝓘(ℂ,ℂ) ((ModelWithCorners X).prod 𝓘(ℂ,Model X)) ω
+      (fun t => (⟨p (g t),σ t⟩ : TangentBundle (ModelWithCorners X) X.Carrier))) :
+    ContMDiff 𝓘(ℂ,ℂ) ((ModelWithCorners Y).prod 𝓘(ℂ,Model Y)) ω
+      (fun t => (⟨g t,coverTangentLift hp (g t) (σ t)⟩ :
+        TangentBundle (ModelWithCorners Y) Y.Carrier)) := by
+  intro t
+  have hh := (holomorphicAt_tangentMap
+    (hp (g t)).localInverse_contMDiffAt (σ t)).comp t (hσ t)
+  apply hh.congr_of_eventuallyEq
+  filter_upwards [hg.continuousAt.preimage_mem_nhds
+    ((hp (g t)).localInverse.open_target.mem_nhds
+      (hp (g t)).localInverse_mem_target)] with w hw
+  exact Bundle.TotalSpace.ext ((hp (g t)).localInverse_left_inv hw).symm
+    (heq_of_eq (coverTangentLift_eq_localInverse hp (g t) (g w) hw (σ w)))
+
+namespace RationalCurve
+variable {g : RationalCurve X} {k : RationalCurve Y}
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (hf : ∀z,p (k.finite z)=g.finite z) (hi : ∀z,p (k.infinity z)=g.infinity z)
+
+def coverSection (σ : CurveTangentSection g) : CurveTangentSection k where
+  finite z := coverTangentLift hp (k.finite z) (σ.finite z)
+  infinity z := coverTangentLift hp (k.infinity z) (σ.infinity z)
+  finite_holomorphic := coverTangentLift_holomorphic hp k.finite_holomorphic.continuous
+    (by
+      have he : (fun t => (⟨p (k.finite t),σ.finite t⟩ :
+          TangentBundle (ModelWithCorners X) X.Carrier))=
+          (fun t => (⟨g.finite t,σ.finite t⟩ :
+          TangentBundle (ModelWithCorners X) X.Carrier)) := by
+        funext t
+        exact Bundle.TotalSpace.ext (hf t) (heq_of_eq rfl)
+      rw [he]
+      exact σ.finite_holomorphic)
+  infinity_holomorphic := coverTangentLift_holomorphic hp k.infinity_holomorphic.continuous
+    (by
+      have he : (fun t => (⟨p (k.infinity t),σ.infinity t⟩ :
+          TangentBundle (ModelWithCorners X) X.Carrier))=
+          (fun t => (⟨g.infinity t,σ.infinity t⟩ :
+          TangentBundle (ModelWithCorners X) X.Carrier)) := by
+        funext t
+        exact Bundle.TotalSpace.ext (hi t) (heq_of_eq rfl)
+      rw [he]
+      exact σ.infinity_holomorphic)
+  overlap z hz := by rw [k.overlap z hz,σ.overlap z hz]
+
+include hp hf hi in
+ 
+theorem pointedGenerated_cover_lift (hg : PointedGenerated g (fun _ => ⊤)) :
+    PointedGenerated k (fun _ => ⊤) := by
+  intro v hv
+  let D := mfderiv (ModelWithCorners Y) (ModelWithCorners X) p (k.finite 1)
+  obtain ⟨σ,_,_,h0,h1⟩ := hg (D v) Submodule.mem_top
+  refine ⟨coverSection hp hf hi σ,fun _ => Submodule.mem_top,
+    fun _ => Submodule.mem_top,?_,?_⟩
+  · change coverTangentLift hp (k.finite 0) (σ.finite 0)=0
+    erw [h0,map_zero]
+  · change coverTangentLift hp (k.finite 1) (σ.finite 1)=v
+    rw [h1]
+    exact coverTangentLift_leftInverse hp (k.finite 1) v
+
+ 
+
+theorem exists_positive_cover_lift
+    (g : RationalCurve X) (hg : PointedGenerated g (fun _ => ⊤))
+    (hcover : IsCoveringMap p)
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (y : Y.Carrier) (hy : p y=g.finite 0) :
+    ∃k : RationalCurve Y,k.finite 0=y ∧ PointedGenerated k (fun _ => ⊤) ∧
+      (∀z,p (k.finite z)=g.finite z) ∧ (∀z,p (k.infinity z)=g.infinity z) := by
+  obtain ⟨k,hk,hf,hi⟩ := g.exists_cover_lift hcover hp y hy
+  exact ⟨k,hk,pointedGenerated_cover_lift hp hf hi hg,hf,hi⟩
+
+ 
+
+theorem exists_positive_cover_lift_at
+    (g : RationalCurve X) (hg : PointedGenerated g (fun _ => ⊤))
+    (hcover : IsCoveringMap p)
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (a : ℂ) (y : Y.Carrier) (hy : p y=g.finite a) :
+    ∃k : RationalCurve Y,k.finite a=y ∧ PointedGenerated k (fun _ => ⊤) ∧
+      (∀z,p (k.finite z)=g.finite z) ∧ (∀z,p (k.infinity z)=g.infinity z) := by
+  obtain ⟨k,hk,hf,hi⟩ := g.exists_cover_lift_at hcover hp a y hy
+  exact ⟨k,hk,pointedGenerated_cover_lift hp hf hi hg,hf,hi⟩
+
+end RationalCurve
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PositiveJetFiltration.lean

@@ -0,0 +1,103 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.FormalBoxes
+import OAI.Geometry.SplitTangent.SymmetricConormalBound
+import OAI.Geometry.SplitTangent.TensorSectionSpace
+
+namespace OAI
+
+/-! Positive Jet Filtration. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.PositiveJetFiltration
+variable {X : ComplexManifold.{u}} {g : RationalCurve X} {S : TangentSplitting X}
+  {V : Type*} [AddCommGroup V] [Module ℂ V] {d : ℕ}
+  (F : ℕ → Submodule ℂ V) (hF : Antitone F)
+  (L : ∀m,F m →ₗ[ℂ] symmetricSupportedTensors g S (d : ℤ) m)
+  (hker : ∀m s,L m s=0 ↔ s.val∈F (m+1))
+
+include hF hker L
+
+ 
+
+def kernelEquiv (m : ℕ) : LinearMap.ker (L m) ≃ₗ[ℂ] F (m+1) where
+  toFun s := ⟨s.val.val,(hker m s.val).mp s.property⟩
+  invFun s := ⟨⟨s.val,hF (Nat.le_succ m) s.property⟩,
+    (hker m _).mpr s.property⟩
+  left_inv _ := rfl
+  right_inv _ := rfl
+  map_add' _ _ := rfl
+  map_smul' _ _ := rfl
+
+theorem high_eq_zero (hg : PointedGenerated g S.first)
+    (hsep : ∀v,(∀m,v∈F m) → v=0) {k : ℕ} (hk : d < k) (s : F k) : s=0 := by
+  have hs (n : ℕ) : s.val∈F n := by
+    induction n with
+    | zero => exact hF (Nat.zero_le k) s.property
+    | succ n ih =>
+      by_cases hn : n+1≤k
+      · exact hF hn s.property
+      · exact (hker n ⟨s.val,ih⟩).mp
+          (symmetricSupportedTensors.eq_zero_of_degree_lt_order hg (by omega) _)
+  exact Subtype.ext (hsep s.val hs)
+
+ 
+
+theorem finite_and_bound (hg : PointedGenerated g S.first)
+    (hsep : ∀v,(∀m,v∈F m) → v=0) (N k : ℕ) (hk : d < k+N) :
+    Module.Finite ℂ (F k) ∧ Module.finrank ℂ (F k) ≤
+      ∑j∈Finset.range N,
+        (Module.finrank ℂ (S.first (g.finite 1))+(k+j)-1).choose (k+j)*(d+1) := by
+  induction N generalizing k with
+  | zero =>
+    have : Subsingleton (F k) := ⟨fun s t =>
+      (high_eq_zero F hF L hker hg hsep (by simpa using hk) s).trans
+        (high_eq_zero F hF L hker hg hsep (by simpa using hk) t).symm⟩
+    exact ⟨inferInstance,by simp [Module.finrank_zero_of_subsingleton]⟩
+  | succ N ih =>
+    obtain ⟨hf,hb⟩ := ih (k+1) (by omega)
+    let : Module.Finite ℂ (F (k+1)) := hf
+    let : AddCommGroup (symmetricSupportedTensors g S (d : ℤ) k) :=
+      Module.addCommMonoidToAddCommGroup ℂ
+    obtain ⟨ht,htb⟩ := symmetricSupportedTensors.finite_and_finrank_le hg d k
+    let : Module.Finite ℂ (symmetricSupportedTensors g S (d : ℤ) k) := ht
+    let : Module.Finite ℂ (LinearMap.ker (L k)) :=
+      Module.Finite.equiv (kernelEquiv F hF L hker k).symm
+    let : Module.Finite ℂ (F k) := DiagonalRationality.finite_of_kernel (L k)
+    refine ⟨inferInstance,?_⟩
+    have hrank := LinearMap.finrank_range_add_finrank_ker (K := ℂ) (L k)
+    have hrange := (LinearMap.range (L k)).finrank_le
+    have hkernel := (kernelEquiv F hF L hker k).finrank_eq
+    rw [Finset.sum_range_succ']
+    have hshift : (∑j∈Finset.range N,
+        (Module.finrank ℂ (S.first (g.finite 1))+(k+(j+1))-1).choose (k+(j+1))*(d+1)) =
+        ∑j∈Finset.range N,
+        (Module.finrank ℂ (S.first (g.finite 1))+(k+1+j)-1).choose (k+1+j)*(d+1) := by
+      apply Finset.sum_congr rfl
+      intro j hj
+      simp only [Nat.add_assoc, Nat.add_comm, Nat.add_left_comm]
+    rw [hshift]
+    simp only [Nat.add_zero]
+    omega
+
+ 
+
+theorem polynomial_bound (hg : PointedGenerated g S.first)
+    (hsep : ∀v,(∀m,v∈F m) → v=0) :
+    Module.Finite ℂ (F 0) ∧ Module.finrank ℂ (F 0) ≤
+      (d+Module.finrank ℂ (S.first (g.finite 1))).choose
+        (Module.finrank ℂ (S.first (g.finite 1)))*(d+1) := by
+  obtain ⟨hf,hb⟩ := finite_and_bound F hF L hker hg hsep (d+1) 0 (by omega)
+  refine ⟨hf,?_⟩
+  simpa only [Nat.zero_add,←Nat.multichoose_eq,←Finset.sum_mul,Nat.sum_range_multichoose]
+    using hb
+
+end SplitTangent.PositiveJetFiltration
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/PositiveTangentCurves.lean

@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.BoxTransportBase
+import OAI.Geometry.SplitTangent.BracketIntegrability
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.BoxFirstTransport
+import OAI.Geometry.SplitTangent.TangentRationalChains
+import OAI.Geometry.SplitTangent.RationalVariation
+
+namespace OAI
+
+/-! Positive Tangent Curves. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped ContDiff Manifold
+universe u
+namespace SplitTangent
+
+ 
+
+def PointedGenerated {X : ComplexManifold.{u}} (g : RationalCurve X)
+    (D : ∀x : X.Carrier, Submodule ℂ (Tangent X x)) : Prop :=
+  ∀ v : Tangent X (g.finite 1), v∈D (g.finite 1) →
+    ∃σ : CurveTangentSection g,
+      (∀z, σ.finite z∈D (g.finite z)) ∧
+      (∀z, σ.infinity z∈D (g.infinity z)) ∧
+      σ.finite 0=0 ∧ σ.finite 1=v
+
+namespace TangentBox
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X} {g : RationalCurve X}
+  (B : TangentBox S g)
+
+lemma firstFactor_tangentTo (b : ℂ) : (B.firstFactor b).TangentTo S.first := by
+  exact B.horizontal_tangent false b
+
+ 
+
+theorem firstFactor_pointedGenerated
+    (hg : PointedGenerated g S.first) : PointedGenerated (B.firstFactor 1) S.first := by
+  intro v hv
+  have hv' : v∈S.first (g.finite 1) := by
+    change v∈S.first (B.chart false false (1,1)) at hv
+    erw [B.finite_diagonal 1] at hv
+    exact hv
+  obtain ⟨σ,σf,σi,σ0,σ1⟩ := hg v hv'
+  let τ := ((B.firstMap 1).mapSection σ).project S
+  refine ⟨τ,fun z => CurveTangentSection.project_mem_first_finite S _ z,
+    fun z => CurveTangentSection.project_mem_first_infinity S _ z,?_,?_⟩
+  · change S.projector _ ((B.firstMap 1).finite 0 (σ.finite 0))=0
+    rw [σ0,map_zero,map_zero]
+  · change S.projector _ ((B.firstMap 1).finite 1 (σ.finite 1))=v
+    rw [σ1,B.firstMap_normalized]
+    have hfix := (S.mem_first_iff (g.finite 1) v).mp hv'
+    erw [B.firstFactor_diagonal,hfix,hfix]
+
+end TangentBox
+
+namespace RationalFamily
+variable {X T : ComplexManifold.{u}} (G : RationalFamily X T)
+
+theorem pointedGenerated_of_submersive (S : TangentSplitting X) (τ : T.Carrier)
+    (hτ : Function.Surjective (mfderiv (ModelWithCorners T)
+      ((ModelWithCorners X).prod (ModelWithCorners X)) (G.twoPointEvaluation 0 1) τ)) :
+    PointedGenerated (G.curve τ) S.first :=
+  fun v hv => G.exists_first_section_zero_value S hτ v hv
+
+end RationalFamily
+
+namespace TangentSplitting
+
+ 
+
+theorem exists_positive_tangent_curve {X : ComplexManifold.{u}}
+    [CompactSpace X.Carrier] (S : TangentSplitting X) (e : ProjectiveEmbedding X)
+    (hRC : RationallyConnected e) (hdim : 0<X.dim) :
+    ∃h : RationalCurve X, h.TangentTo S.first ∧ PointedGenerated h S.first := by
+  obtain ⟨T,hT,G,hG⟩ := hRC.exists_submersive_family e hdim
+  let := hT
+  let τ : T.Carrier := Classical.arbitrary _
+  obtain ⟨B⟩ := S.exists_projective_tangent_box e (G.curve τ)
+  exact ⟨B.firstFactor 1,B.firstFactor_tangentTo 1,
+    B.firstFactor_pointedGenerated (G.pointedGenerated_of_submersive S τ (hG τ))⟩
+
+ 
+
+theorem exists_positive_tangent_curves {X : ComplexManifold.{u}}
+    [CompactSpace X.Carrier] (S : TangentSplitting X) (e : ProjectiveEmbedding X)
+    (hRC : RationallyConnected e) (hdim : 0<X.dim) :
+    (∃h : RationalCurve X, h.TangentTo S.first ∧ PointedGenerated h S.first) ∧
+    (∃h : RationalCurve X, h.TangentTo S.second ∧ PointedGenerated h S.second) := by
+  refine ⟨S.exists_positive_tangent_curve e hRC hdim,?_⟩
+  simpa only [S.swap_first] using S.swap.exists_positive_tangent_curve e hRC hdim
+
+end TangentSplitting
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProductCriteria.lean

@@ -0,0 +1,128 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.EmbeddedHolomorphicAtlas
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.HolomorphicLocalDiffeomorph
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Product Criteria. -/
+
+noncomputable section
+open Set Filter Topology Bundle
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+ 
+theorem injective_mfderiv_of_leftInverse {X Y : ComplexManifold.{u}}
+    {i : Y.Carrier → X.Carrier} {p : X.Carrier → Y.Carrier}
+    (hi : ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i)
+    (hp : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω p)
+    (hpi : Function.LeftInverse p i) (y : Y.Carrier) :
+    Function.Injective (mfderiv (ModelWithCorners Y) (ModelWithCorners X) i y) := by
+  have he : p ∘ i = id := funext hpi
+  have hd := mfderiv_comp y ((hp (i y)).mdifferentiableAt (by simp))
+    ((hi y).mdifferentiableAt (by simp))
+  rw [he, mfderiv_id] at hd
+  intro v w hvw
+  have h := congrArg (mfderiv (ModelWithCorners X) (ModelWithCorners Y) p (i y)) hvw
+  have hdv := congrArg (fun L : Model Y →L[ℂ] Model Y => L v) hd
+  have hdw := congrArg (fun L : Model Y →L[ℂ] Model Y => L w) hd
+  exact hdv.trans (h.trans hdw.symm)
+
+ 
+
+theorem isProjective_factors {X Y Z : ComplexManifold.{u}}
+    [Nonempty X.Carrier] [CompactSpace X.Carrier]
+    (e : ProjectiveEmbedding X)
+    (f : Diffeomorph (ModelWithCorners X)
+      ((ModelWithCorners Y).prod (ModelWithCorners Z)) X.Carrier
+      (Y.Carrier × Z.Carrier) ω) : IsProjective Y ∧ IsProjective Z := by
+  let yz := f (Classical.arbitrary X.Carrier)
+  let p : X.Carrier → Y.Carrier := fun x => (f x).1
+  let q : X.Carrier → Z.Carrier := fun x => (f x).2
+  let i : Y.Carrier → X.Carrier := fun y => f.symm (y, yz.2)
+  let j : Z.Carrier → X.Carrier := fun z => f.symm (yz.1, z)
+  have hp : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω p :=
+    contMDiff_fst.comp f.contMDiff
+  have hq : ContMDiff (ModelWithCorners X) (ModelWithCorners Z) ω q :=
+    contMDiff_snd.comp f.contMDiff
+  have hi : ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i :=
+    f.symm.contMDiff.comp (contMDiff_id.prodMk contMDiff_const)
+  have hj : ContMDiff (ModelWithCorners Z) (ModelWithCorners X) ω j :=
+    f.symm.contMDiff.comp (contMDiff_const.prodMk contMDiff_id)
+  have hpi : Function.LeftInverse p i := by intro y; simp [p, i]
+  have hqj : Function.LeftInverse q j := by intro z; simp [q, j]
+  have hpc : CompactSpace Y.Carrier :=
+    hpi.surjective.compactSpace hp.continuous
+  have hqc : CompactSpace Z.Carrier :=
+    hqj.surjective.compactSpace hq.continuous
+  exact ⟨⟨hpc, ⟨e.pullback i hi hpi.injective
+    (injective_mfderiv_of_leftInverse hi hp hpi)⟩⟩,
+    ⟨hqc, ⟨e.pullback j hj hqj.injective
+    (injective_mfderiv_of_leftInverse hj hq hqj)⟩⟩⟩
+
+namespace TangentSplitting
+variable {X : ComplexManifold.{u}} (S : TangentSplitting X)
+
+ 
+
+theorem compatible_product_of_bijective_quotients [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+    (e : ProjectiveEmbedding X) (Y Z : ComplexManifold.{u})
+    (q₁ : X.Carrier → Y.Carrier) (q₂ : X.Carrier → Z.Carrier)
+    (hq₁ : ContMDiff (ModelWithCorners X) (ModelWithCorners Y) ω q₁)
+    (hq₂ : ContMDiff (ModelWithCorners X) (ModelWithCorners Z) ω q₂)
+    (hs₁ : ∀x, Function.Surjective (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x))
+    (hs₂ : ∀x, Function.Surjective (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x))
+    (hk₁ : ∀x, LinearMap.ker (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x).toLinearMap=
+      S.second x)
+    (hk₂ : ∀x, LinearMap.ker (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x).toLinearMap=
+      S.first x)
+    (hpair : Function.Bijective (fun x => (q₁ x,q₂ x))) : HasCompatibleProjectiveProduct X S := by
+  let : ChartedSpace (Model Y × Model Z) (Y.Carrier × Z.Carrier) :=
+    prodChartedSpace (Model Y) Y.Carrier (Model Z) Z.Carrier
+  let : IsManifold 𝓘(ℂ,Model Y × Model Z) ω (Y.Carrier × Z.Carrier) := by
+    rw [modelWithCornersSelf_prod]
+    exact IsManifold.prod Y.Carrier Z.Carrier
+  let q : X.Carrier → Y.Carrier × Z.Carrier := fun x => (q₁ x,q₂ x)
+  let I := (ModelWithCorners Y).prod (ModelWithCorners Z)
+  have hq : ContMDiff (ModelWithCorners X) I ω q := hq₁.prodMk hq₂
+  have hd (x : X.Carrier) : mfderiv (ModelWithCorners X) I q x=
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Y) q₁ x).prod
+      (mfderiv (ModelWithCorners X) (ModelWithCorners Z) q₂ x) :=
+    mfderiv_prodMk ((hq₁ x).mdifferentiableAt (by simp)) ((hq₂ x).mdifferentiableAt (by simp))
+  have hb (x : X.Carrier) : Function.Bijective (mfderiv (ModelWithCorners X) I q x) := by
+    rw [hd]
+    exact HolomorphicFrobenius.complementary_quotients_bijective
+      (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+      (S.idempotent x) _ _ (hs₁ x) (hs₂ x) (hk₁ x) (hk₂ x)
+  let : LocallyPathConnectedSpace Y.Carrier := ChartedSpace.locallyPathConnectedSpace (Model Y) Y.Carrier
+  let : LocallyPathConnectedSpace Z.Carrier := ChartedSpace.locallyPathConnectedSpace (Model Z) Z.Carrier
+  have hl : IsLocalDiffeomorph (ModelWithCorners X) I ω q := by
+    intro x
+    have hI : I=𝓘(ℂ,Model Y × Model Z) := modelWithCornersSelf_prod.symm
+    rw [hI] at hq hb ⊢
+    exact HolomorphicLocalDiffeomorph.manifold_ift (hq x) (hb x)
+  let f : Diffeomorph (ModelWithCorners X) I X.Carrier (Y.Carrier × Z.Carrier) ω :=
+    hl.diffeomorphOfBijective hpair
+  have hf : (f : X.Carrier → Y.Carrier × Z.Carrier)=q := rfl
+  obtain ⟨hY,hZ⟩ := isProjective_factors e f
+  refine ⟨Y,Z,hY,hZ,f,?_⟩
+  intro x
+  change Submodule.map (mfderiv (ModelWithCorners X) I q x).toLinearMap (S.first x)=_ ∧
+    Submodule.map (mfderiv (ModelWithCorners X) I q x).toLinearMap (S.second x)=_
+  rw [hd]
+  exact ⟨HolomorphicFrobenius.image_range_projector_of_quotients
+    (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+    (S.idempotent x) _ _ (hs₁ x) (hk₁ x) (hk₂ x),
+    HolomorphicFrobenius.image_kernel_projector_of_quotients
+    (E := Model X) (F := Model Y) (G := Model Z) (S.projector x)
+    (S.idempotent x) _ _ (hs₂ x) (hk₁ x) (hk₂ x)⟩
+
+end TangentSplitting
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProjectiveHypersurfaces.lean

@@ -0,0 +1,96 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.HolomorphicHypersurfaces
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.ProjectiveLineFrame
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+
+namespace OAI
+
+/-! Projective Hypersurfaces. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent
+
+lemma LocallyHolomorphicZeroSet.isClosed {X : ComplexManifold.{u}} {Z : Set X.Carrier}
+    (h : LocallyHolomorphicZeroSet X Z) : IsClosed Z := by
+  rw [← isOpen_compl_iff]
+  apply isOpen_iff_mem_nhds.mpr
+  intro x hx
+  obtain ⟨U,hU,hxU,f,hf,he⟩ := h x
+  have hfc := (hf.contMDiffAt (hU.mem_nhds hxU)).continuousAt
+  have hn : f x≠0 := fun hz => hx ((he x hxU).mpr hz)
+  have hne := hfc.eventually_ne hn
+  filter_upwards [hU.mem_nhds hxU,hne] with y hy hyn
+  exact fun hz => hyn ((he y hy).mp hz)
+
+namespace ProjectiveEmbedding
+variable {X : ComplexManifold.{u}} (e : ProjectiveEmbedding X)
+
+def homogeneousZeroLocus (p : MvPolynomial (Fin (e.N+1)) ℂ) : Set X.Carrier :=
+  {x | MvPolynomial.eval (e.map x).rep p=0}
+
+lemma homogeneous_coordinates_eval {p : MvPolynomial (Fin (e.N+1)) ℂ} {k : ℕ}
+    (hp : p.IsHomogeneous k) (i : Fin (e.N+1)) (x : X.Carrier) :
+    MvPolynomial.eval (projectiveCoordinates i (e.map x)) p=
+      ((e.map x).rep i)⁻¹^k*MvPolynomial.eval (e.map x).rep p := by
+  exact _root_.OAI.MvPolynomial.IsHomogeneous.eval_scale hp ((e.map x).rep i)⁻¹ (e.map x).rep
+
+lemma homogeneous_coordinates_zero_iff {p : MvPolynomial (Fin (e.N+1)) ℂ} {k : ℕ}
+    (hp : p.IsHomogeneous k) (i : Fin (e.N+1)) {x : X.Carrier} (hi : (e.map x).rep i≠0) :
+    x∈e.homogeneousZeroLocus p ↔ MvPolynomial.eval (projectiveCoordinates i (e.map x)) p=0 := by
+  rw [e.homogeneous_coordinates_eval hp]
+  exact (mul_eq_zero_iff_left (pow_ne_zero _ (inv_ne_zero hi))).symm
+
+lemma homogeneousZeroLocus_locally_holomorphic
+    {p : MvPolynomial (Fin (e.N+1)) ℂ} {k : ℕ} (hp : p.IsHomogeneous k) :
+    LocallyHolomorphicZeroSet X (e.homogeneousZeroLocus p) := by
+  intro x
+  obtain ⟨i,hi⟩ := Function.ne_iff.mp (e.map x).rep_nonzero
+  change (e.map x).rep i≠0 at hi
+  refine ⟨{y | (e.map y).rep i≠0},e.open_patch i,hi,
+    fun y => MvPolynomial.eval (projectiveCoordinates i (e.map y)) p,?_,?_⟩
+  · intro y hy
+    apply ContMDiffAt.contMDiffWithinAt
+    apply _root_.OAI.MvPolynomial.contMDiffAt_eval_comp (ModelWithCorners X) p
+    intro j
+    exact contMDiffAt_pi_space.mp
+      ((e.holomorphic i).contMDiffAt ((e.open_patch i).mem_nhds hy)) j
+  · intro y hy
+    exact e.homogeneous_coordinates_zero_iff hp i hy
+
+lemma homogeneousZeroLocus_isClosed
+    {p : MvPolynomial (Fin (e.N+1)) ℂ} {k : ℕ} (hp : p.IsHomogeneous k) :
+    IsClosed (e.homogeneousZeroLocus p) :=
+  (e.homogeneousZeroLocus_locally_holomorphic hp).isClosed
+
+lemma linearFrame_zero_iff
+    {p : MvPolynomial (Fin (e.N+1)) ℂ} {k : ℕ} (hp : p.IsHomogeneous k)
+    (a : Fin (e.N+1) → ℂ) {x : X.Carrier} (ha : (∑i,a i*(e.map x).rep i)≠0) :
+    MvPolynomial.eval (e.linearFrame a x) p=0 ↔ x∈e.homogeneousZeroLocus p := by
+  rw [linearFrame,_root_.OAI.MvPolynomial.IsHomogeneous.eval_scale hp]
+  exact mul_eq_zero_iff_left (pow_ne_zero _ (inv_ne_zero ha))
+
+lemma linearFrame_denominator_eventually
+    (a : Fin (e.N+1) → ℂ) {x : X.Carrier} (ha : (∑i,a i*(e.map x).rep i)≠0) :
+    ∀ᶠ y in 𝓝 x,(∑i,a i*(e.map y).rep i)≠0 := by
+  have hframe : e.linearFrame a x≠0 :=
+    smul_ne_zero (inv_ne_zero ha) (e.map x).rep_nonzero
+  obtain ⟨j,hj⟩ := Function.ne_iff.mp hframe
+  have hc := (e.linearFrame_holomorphicAt (ModelWithCorners X)
+    (f := id) (a := fun _ => a) contMDiffAt_id contMDiffAt_const ha).continuousAt
+  have hn := ((continuous_apply j).continuousAt.comp hc).eventually_ne hj
+  filter_upwards [hn] with y hy
+  intro hh
+  apply hy
+  change e.linearFrame a y j=0
+  simp only [linearFrame,hh,inv_zero,zero_smul,Pi.zero_apply]
+
+end ProjectiveEmbedding
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProjectiveLineFrame.lean

@@ -0,0 +1,132 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.FormalBoxes
+
+namespace OAI
+
+/-! Projective Line Frame. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent.ProjectiveEmbedding
+variable {X : ComplexManifold.{u}} (e : ProjectiveEmbedding X)
+
+ 
+def linearFrame (a : Fin (e.N+1) → ℂ) (x : X.Carrier) : Fin (e.N+1) → ℂ :=
+  (∑i,a i*(e.map x).rep i)⁻¹ • (e.map x).rep
+
+lemma linearFrame_eq_coordinates {a : Fin (e.N+1) → ℂ} {x : X.Carrier}
+    {k : Fin (e.N+1)} (hk : (e.map x).rep k ≠ 0) :
+    e.linearFrame a x = (∑i,a i*projectiveCoordinates k (e.map x) i)⁻¹ •
+      projectiveCoordinates k (e.map x) := by
+  have he : (∑i,a i*projectiveCoordinates k (e.map x) i)=
+      ((e.map x).rep k)⁻¹ * ∑i,a i*(e.map x).rep i := by
+    rw [Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i hi
+    simp only [projectiveCoordinates]
+    ring
+  ext i
+  simp only [linearFrame,Pi.smul_apply,smul_eq_mul]
+  rw [he]
+  simp only [projectiveCoordinates,mul_inv_rev,inv_inv]
+  symm
+  calc
+    _ = (∑ j, a j*(e.map x).rep j)⁻¹ *
+      (((e.map x).rep k * ((e.map x).rep k)⁻¹) * (e.map x).rep i) := by ring
+    _ = _ := by rw [mul_inv_cancel₀ hk,one_mul]
+
+lemma linearFrame_denominator_ne {a v : Fin (e.N+1) → ℂ} {x : X.Carrier}
+    (hv : e.Incidence x v) (ha : ∑i,a i*v i=1) :
+    (∑i,a i*(e.map x).rep i) ≠ 0 := by
+  obtain ⟨k,hk⟩ := Function.ne_iff.mp (e.map x).rep_nonzero
+  change (e.map x).rep k ≠ 0 at hk
+  have hvk : v k ≠ 0 := by
+    intro hz
+    have hvz : v=0 := by
+      ext i
+      rw [(e.incidence_iff_coordinates hk).mp hv i,hz,zero_mul]
+      rfl
+    simp [hvz] at ha
+  have hcross : (∑i,a i*(e.map x).rep i)*v k=(e.map x).rep k := by
+    calc
+      _ = ∑i,a i*((e.map x).rep i*v k) := by rw [Finset.sum_mul]; congr 1; funext i; ring
+      _ = ∑i,a i*((e.map x).rep k*v i) := by
+        apply Finset.sum_congr rfl
+        intro i hi
+        rw [← hv k i]
+      _ = (e.map x).rep k*(∑i,a i*v i) := by rw [Finset.mul_sum]; congr 1; funext i; ring
+      _ = _ := by rw [ha,mul_one]
+  intro h
+  exact hk (by simpa only [h,zero_mul] using hcross.symm)
+
+lemma linearFrame_eq_of_incidence {a v : Fin (e.N+1) → ℂ} {x : X.Carrier}
+    (hv : e.Incidence x v) (ha : ∑i,a i*v i=1) : e.linearFrame a x=v := by
+  have hden := e.linearFrame_denominator_ne hv ha
+  ext j
+  change (∑i,a i*(e.map x).rep i)⁻¹ * (e.map x).rep j=v j
+  apply (inv_mul_eq_iff_eq_mul₀ hden).mpr
+  calc
+    _ = ∑i,a i*((e.map x).rep j*v i) := by
+      rw [show (∑i,a i*((e.map x).rep j*v i))=
+        (e.map x).rep j*(∑i,a i*v i) by rw [Finset.mul_sum]; congr 1; funext i; ring,ha,mul_one]
+    _ = ∑i,a i*((e.map x).rep i*v j) := by
+      apply Finset.sum_congr rfl
+      intro i hi
+      rw [hv j i]
+    _ = _ := by rw [Finset.sum_mul]; congr 1; funext i; ring
+
+ 
+lemma linearFrame_change (a b : Fin (e.N+1) → ℂ) (x : X.Carrier)
+    (hb : (∑i,b i*(e.map x).rep i)≠0) :
+    e.linearFrame a x = (∑i,b i*e.linearFrame a x i) • e.linearFrame b x := by
+  have he : (∑i,b i*e.linearFrame a x i)=
+      (∑i,a i*(e.map x).rep i)⁻¹ * (∑i,b i*(e.map x).rep i) := by
+    simp only [linearFrame,Pi.smul_apply,smul_eq_mul,Finset.mul_sum]
+    apply Finset.sum_congr rfl
+    intro i hi
+    ring
+  rw [he]
+  ext i
+  simp only [linearFrame,Pi.smul_apply,smul_eq_mul]
+  field_simp
+
+lemma linearFrame_holomorphicAt
+    {E H M : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
+    [TopologicalSpace H] (I : _root_.ModelWithCorners ℂ E H)
+    [TopologicalSpace M] [ChartedSpace H M]
+    {f : M → X.Carrier} {a : M → Fin (e.N+1) → ℂ} {y : M}
+    (hf : ContMDiffAt I (ModelWithCorners X) ω f y)
+    (ha : ContMDiffAt I 𝓘(ℂ,Fin (e.N+1) → ℂ) ω a y)
+    (hn : (∑i,a y i*(e.map (f y)).rep i)≠0) :
+    ContMDiffAt I 𝓘(ℂ,Fin (e.N+1) → ℂ) ω
+      (fun z => e.linearFrame (a z) (f z)) y := by
+  obtain ⟨k,hk⟩ := Function.ne_iff.mp (e.map (f y)).rep_nonzero
+  change (e.map (f y)).rep k ≠ 0 at hk
+  have hc := ((e.holomorphic k).contMDiffAt ((e.open_patch k).mem_nhds hk)).comp y hf
+  have hd : ContMDiffAt I 𝓘(ℂ,ℂ) ω
+      (fun z => ∑i,a z i*projectiveCoordinates k (e.map (f z)) i) y := by
+    apply contMDiffAt_finsetSum
+    intro i hi
+    exact (contMDiffAt_pi_space.mp ha i).mul (contMDiffAt_pi_space.mp hc i)
+  have hd0 : (∑i,a y i*projectiveCoordinates k (e.map (f y)) i)≠0 := by
+    have he : (∑i,a y i*projectiveCoordinates k (e.map (f y)) i)=
+        ((e.map (f y)).rep k)⁻¹ * (∑i,a y i*(e.map (f y)).rep i) := by
+      rw [Finset.mul_sum]
+      apply Finset.sum_congr rfl
+      intro i hi
+      simp only [projectiveCoordinates]
+      ring
+    rw [he]
+    exact mul_ne_zero (inv_ne_zero hk) hn
+  apply ((hd.inv₀ hd0).smul hc).congr_of_eventuallyEq
+  filter_upwards [hf.continuousAt.preimage_mem_nhds ((e.open_patch k).mem_nhds hk)] with z hz
+  exact e.linearFrame_eq_coordinates hz
+
+end SplitTangent.ProjectiveEmbedding
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProjectiveLinearCoordinates.lean

@@ -0,0 +1,105 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.TensorVanishing
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Projective Linear Coordinates. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace ProjectiveLinearCoordinates
+open _root_.MvPolynomial _root_.OAI.MvPolynomial
+variable {σ : Type*} [Fintype σ]
+
+ 
+def form (l : (σ → ℂ) →ₗ[ℂ] ℂ) : homogeneousSubmodule σ ℂ 1 := by
+  classical
+  exact ∑i,l (Pi.single i 1) • ⟨X i,isHomogeneous_X ℂ i⟩
+
+lemma eval_form (l : (σ → ℂ) →ₗ[ℂ] ℂ) (x : σ → ℂ) : eval x (form l).val=l x := by
+  classical
+  have he : (∑i,x i • Pi.single i (1 : ℂ))=x := by
+    ext j
+    simp [Pi.single_apply]
+  calc
+    _ = ∑i,x i*l (Pi.single i 1) := by
+      simp only [form,Submodule.coe_sum,Submodule.coe_smul,map_sum,MvPolynomial.smul_eval,eval_X]
+      apply Finset.sum_congr rfl
+      intro i hi
+      exact mul_comm _ _
+    _ = l (∑i,x i • Pi.single i 1) := by simp only [map_sum,map_smul,smul_eq_mul]
+    _ = l x := congrArg l he
+
+lemma eval_form_ratio (l : (σ → ℂ) →ₗ[ℂ] ℂ) (x : σ → ℂ) (i : σ) :
+    eval x (form l).val / x i=l ((x i)⁻¹ • x) := by
+  rw [eval_form,map_smul]
+  simp only [smul_eq_mul,div_eq_mul_inv,mul_comm]
+
+end ProjectiveLinearCoordinates
+namespace SplitTangent.ProjectiveEmbedding
+variable {X : ComplexManifold.{u}} (e : ProjectiveEmbedding X)
+  {S : TangentSplitting X} {A B : Type*}
+  [NormedAddCommGroup A] [NormedSpace ℂ A] [FiniteDimensional ℂ A]
+  [NormedAddCommGroup B] [NormedSpace ℂ B] [FiniteDimensional ℂ B]
+
+omit [FiniteDimensional ℂ A] [FiniteDimensional ℂ B] in
+lemma plaque_coordinates_analytic (P : AlignedProductChart S A B)
+    {z : A × B} (hz : z∈P.chart.target) (i : Fin (e.N+1))
+    (hi : (e.map (P.chart.symm z)).rep i≠0) :
+    AnalyticAt ℂ (fun t => projectiveCoordinates i (e.map (P.chart.symm t))) z :=
+  (((e.holomorphic i).contMDiffAt ((e.open_patch i).mem_nhds hi)).comp z
+    (P.inverse_holomorphicAt hz)).contDiffAt.analyticAt
+
+omit [FiniteDimensional ℂ A] [FiniteDimensional ℂ B] in
+lemma plaque_coordinates_first_injective (P : AlignedProductChart S A B)
+    {z : A × B} (hz : z∈P.chart.target) (i : Fin (e.N+1))
+    (hi : (e.map (P.chart.symm z)).rep i≠0) :
+    Function.Injective ((fderiv ℂ (fun t => projectiveCoordinates i (e.map (P.chart.symm t))) z).comp
+      (ContinuousLinearMap.inl ℂ A B)) := by
+  have hd := mfderiv_comp z
+    (((e.holomorphic i).contMDiffAt ((e.open_patch i).mem_nhds hi)).mdifferentiableAt (by simp))
+    ((P.inverse_holomorphicAt hz).mdifferentiableAt (by simp))
+  rw [mfderiv_eq_fderiv] at hd
+  change Function.Injective ((fderiv ℂ ((fun x => projectiveCoordinates i (e.map x)) ∘ P.chart.symm) z).comp
+    (ContinuousLinearMap.inl ℂ A B))
+  rw [hd]
+  exact (e.immersion _ i hi).comp ((P.mdifferentiable.symm.mfderiv_injective hz).comp
+    (fun _ _ h => congrArg Prod.fst h))
+
+lemma coordinates_injOn (i : Fin (e.N+1)) :
+    Set.InjOn (fun x => projectiveCoordinates i (e.map x)) {x | (e.map x).rep i≠0} := by
+  intro x hx y hy h
+  apply e.injective
+  rw [←Projectivization.mk_rep (e.map x),←Projectivization.mk_rep (e.map y),
+    Projectivization.mk_eq_mk_iff']
+  refine ⟨(e.map x).rep i*((e.map y).rep i)⁻¹,?_⟩
+  ext j
+  have hh := congrFun h j
+  change ((e.map x).rep i)⁻¹*(e.map x).rep j=
+    ((e.map y).rep i)⁻¹*(e.map y).rep j at hh
+  change ((e.map x).rep i*((e.map y).rep i)⁻¹)*(e.map y).rep j=(e.map x).rep j
+  calc
+    _ = (e.map x).rep i*(((e.map y).rep i)⁻¹*(e.map y).rep j) := by ring
+    _ = (e.map x).rep i*(((e.map x).rep i)⁻¹*(e.map x).rep j) := by rw [hh]
+    _ = _ := by rw [←mul_assoc,mul_inv_cancel₀ hx,one_mul]
+
+ 
+
+theorem exists_linear_plaque_coordinates (P : AlignedProductChart S A B)
+    {z : A × B} (hz : z∈P.chart.target) (i : Fin (e.N+1))
+    (hi : (e.map (P.chart.symm z)).rep i≠0) :
+    ∃(p : (Fin (e.N+1) → ℂ) →L[ℂ] A)
+      (Q : OpenPartialHomeomorph (A × B) (A × B)), z∈Q.source ∧
+      (∀t,Q t=(p (projectiveCoordinates i (e.map (P.chart.symm t))),t.2)) ∧
+      AnalyticAt ℂ Q z ∧ AnalyticAt ℂ Q.symm (Q z) :=
+  RectangularInverse.exists_chart (e.plaque_coordinates_analytic P hz i hi)
+    (e.plaque_coordinates_first_injective P hz i hi)
+
+end SplitTangent.ProjectiveEmbedding
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProjectivePositiveLeaf.lean

@@ -0,0 +1,124 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.RationalCurveFrames
+import OAI.Geometry.SplitTangent.EmbeddedLeafCharts
+import OAI.Geometry.SplitTangent.CompactPositiveLeaf
+import OAI.Geometry.SplitTangent.PlaqueTangentImage
+import OAI.Geometry.SplitTangent.TangentCurveLeaf
+
+namespace OAI
+
+/-! Projective Positive Leaf. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  (L : LeafJetAtlas S) (x₀ : X.Carrier) [PreconnectedSpace X.Carrier]
+  (h : ∀y∈L.leaf x₀,L.plaques.LocallySinglePlaque (L.leaf x₀) y)
+
+lemma embedded_inclusion_tangent : let A := L.embeddedAtlas x₀ h;
+    letI := A.chartedSpace;
+    ∀y : L.leaf x₀,LinearMap.range
+      (mfderiv 𝓘(ℂ,Fin (Module.finrank ℂ (S.first x₀)) → ℂ) (ModelWithCorners X)
+        (Subtype.val : L.leaf x₀ → X.Carrier) y).toLinearMap=S.first y.val := by
+  dsimp only
+  let A := L.embeddedAtlas x₀ h
+  let := A.chartedSpace
+  intro y
+  let Y := A.manifold
+  let i : Y.Carrier → X.Carrier := Subtype.val
+  have hi : ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i := A.inclusion_holomorphic
+  let D : Model Y →L[ℂ] Tangent X y.val := mfderiv (ModelWithCorners Y) (ModelWithCorners X) i y
+  have hsub : LinearMap.range D.toLinearMap ≤ S.first y.val := by
+    obtain ⟨j,U,V,hU,_,hV,hrect,hys,hyUV,huniq⟩ := h y.val y.property
+    let P := L.chart j
+    have hc : ContinuousAt (fun z : Y.Carrier => P.chart z.val) y :=
+      (P.chart.continuousAt hys).comp continuousAt_subtype_val
+    have hs : ∀ᶠ z : Y.Carrier in 𝓝 y,z.val∈P.chart.source :=
+      continuousAt_subtype_val.preimage_mem_nhds (P.chart.open_source.mem_nhds hys)
+    have hUV : ∀ᶠ z : Y.Carrier in 𝓝 y,P.chart z.val∈U ×ˢ V :=
+      hc.preimage_mem_nhds ((hU.prod hV).mem_nhds hyUV)
+    have hplaque : ∀ᶠ z : Y.Carrier in 𝓝 y,(P.chart (i z)).2=(P.chart (i y)).2 := by
+      filter_upwards [hs,hUV] with z hzs hzUV
+      exact huniq z.val z.property hzs hzUV
+    rintro v ⟨w,rfl⟩
+    exact P.mfderiv_into_first (hi y) hys hplaque w
+  let : FiniteDimensional ℂ (Tangent X y.val) := by
+    change FiniteDimensional ℂ (Model X)
+    infer_instance
+  apply Submodule.eq_of_le_of_finrank_eq hsub
+  change Module.finrank ℂ (LinearMap.range
+    (mfderiv 𝓘(ℂ,Fin (Module.finrank ℂ (S.first x₀)) → ℂ) (ModelWithCorners X)
+      (Subtype.val : L.leaf x₀ → X.Carrier) y).toLinearMap)=Module.finrank ℂ (S.first y.val)
+  rw [LinearMap.finrank_range_of_inj (A.inclusion_mfderiv_injective y)]
+  change Module.finrank ℂ (Fin (Module.finrank ℂ (S.first x₀)) → ℂ)=Module.finrank ℂ (S.first y.val)
+  rw [Module.finrank_fintype_fun_eq_card,Fintype.card_fin]
+  exact L.first_rank_eq x₀ y.val
+
+include h in
+ 
+
+theorem exists_projective_leaf (e : ProjectiveEmbedding X) (hc : IsCompact (L.leaf x₀)) :
+    ∃Y : ComplexManifold.{u}, IsProjective Y ∧ ConnectedSpace Y.Carrier ∧
+      Y.dim=Module.finrank ℂ (S.first x₀) ∧
+      ∃i : Y.Carrier → X.Carrier,
+        ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i ∧
+        Function.Injective i ∧ Set.range i=L.leaf x₀ ∧
+        ∀y,LinearMap.range (mfderiv (ModelWithCorners Y) (ModelWithCorners X) i y).toLinearMap=
+          S.first (i y) := by
+  let A := L.embeddedAtlas x₀ h
+  let := A.chartedSpace
+  refine ⟨A.manifold,⟨isCompact_iff_compactSpace.mp hc,⟨A.projectiveEmbedding e⟩⟩,
+    isConnected_iff_connectedSpace.mp (L.plaques.leaf_isConnected x₀),rfl,
+    Subtype.val,A.inclusion_holomorphic,Subtype.val_injective,?_,?_⟩
+  · exact Subtype.range_coe
+  · exact L.embedded_inclusion_tangent x₀ h
+
+end SplitTangent.LeafJetAtlas
+namespace SplitTangent.RationalCurveFrames
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  {e : ProjectiveEmbedding X} {g : RationalCurve X} (F : RationalCurveFrames e g)
+  (L : LeafJetAtlas S) [PreconnectedSpace X.Carrier] [CompactSpace X.Carrier]
+
+include F in
+omit [CompactSpace X.Carrier] in
+lemma leaf_locallySinglePlaque (ht : g.TangentTo S.first) (hg : PointedGenerated g S.first) :
+    ∀y∈L.leaf (g.finite 1),L.plaques.LocallySinglePlaque (L.leaf (g.finite 1)) y := by
+  intro y hy
+  have hh := F.closure_locallySinglePlaque L ht hg (subset_closure hy)
+  rwa [(F.leaf_isClosed L ht hg).closure_eq] at hh
+
+include F in
+theorem exists_projective_leaf (ht : g.TangentTo S.first) (hg : PointedGenerated g S.first) :
+    ∃Y : ComplexManifold.{u}, IsProjective Y ∧ ConnectedSpace Y.Carrier ∧
+      Y.dim=Module.finrank ℂ (S.first (g.finite 1)) ∧
+      ∃i : Y.Carrier → X.Carrier,
+        ContMDiff (ModelWithCorners Y) (ModelWithCorners X) ω i ∧
+        Function.Injective i ∧ Set.range i=L.leaf (g.finite 1) ∧
+        (∀y,LinearMap.range (mfderiv (ModelWithCorners Y) (ModelWithCorners X) i y).toLinearMap=
+          S.first (i y)) ∧
+        ∃k : RationalCurve Y,(∀z,i (k.finite z)=g.finite z) ∧ (∀z,i (k.infinity z)=g.infinity z) := by
+  let h := F.leaf_locallySinglePlaque L ht hg
+  let A := L.embeddedAtlas (g.finite 1) h
+  let := A.chartedSpace
+  let k : RationalCurve A.manifold := {
+    finite := fun z => ⟨g.finite z,L.tangent_rational_curve_finite ht z⟩
+    infinity := fun z => ⟨g.infinity z,L.tangent_rational_curve_infinity ht z⟩
+    finite_holomorphic := A.holomorphic_lift g.finite_holomorphic (L.tangent_rational_curve_finite ht)
+    infinity_holomorphic := A.holomorphic_lift g.infinity_holomorphic (L.tangent_rational_curve_infinity ht)
+    overlap := fun z hz => Subtype.ext (g.overlap z hz) }
+  refine ⟨A.manifold,⟨isCompact_iff_compactSpace.mp (F.leaf_isCompact L ht hg),
+    ⟨A.projectiveEmbedding e⟩⟩,isConnected_iff_connectedSpace.mp (L.plaques.leaf_isConnected _),rfl,
+    Subtype.val,A.inclusion_holomorphic,Subtype.val_injective,Subtype.range_coe,
+    L.embedded_inclusion_tangent _ h,k,fun _ => rfl,fun _ => rfl⟩
+
+end SplitTangent.RationalCurveFrames
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/ProjectiveTangentBox.lean

@@ -0,0 +1,84 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.FormalBoxes
+
+namespace OAI
+
+/-! Projective Tangent Box. -/
+
+noncomputable section
+open scoped Manifold ContDiff LinearAlgebra.Projectivization
+open Set Bundle
+
+universe u
+namespace SplitTangent
+
+attribute [instance] ComplexManifold.topology ComplexManifold.charts
+  ComplexManifold.holomorphicAtlas ComplexManifold.hausdorff
+  ComplexManifold.secondCountable
+
+namespace FormalCauchy
+
+variable {V : Type*} [AddCommGroup V] [Module ℂ V]
+
+instance projectiveTangentBoxAnalyticFunctionCoeFun (U : Set ℂ) :
+    CoeFun (AnalyticFunction U) (fun _ => ℂ → ℂ) := ⟨Subtype.val⟩
+
+open scoped MvPowerSeries.WithPiTopology
+
+end FormalCauchy
+end SplitTangent
+
+open Set Filter Topology
+
+namespace SplitTangent.TangentSplitting
+open HolomorphicJets
+variable {X : ComplexManifold.{u}} (S : TangentSplitting X)
+
+theorem coordinateCurve_analyticAlternative {g : ℂ → X.Carrier}
+    (hg : ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g) (x : X.Carrier) :
+    AnalyticOnNhd ℂ (coordinateCurve g x) (coordinateDomain g x) := by
+  intro z hz
+  have hc := contMDiffAt_of_mem_maximalAtlas
+    (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) (n := ω) x) hz
+  exact (hc.comp z (hg z)).contDiffAt.analyticAt
+
+ 
+
+def localJetAlternative {g : ℂ → X.Carrier}
+    (hg : ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners X) ω g) (x : X.Carrier) :
+    ℕ → ℂ → Model X := Classical.choose
+  (exists_cauchyOn (coordinateDomain_open hg x) (coordinateCurve g x)
+    (fun i z hz => analyticAt_pi_iff.mp (coordinateCurve_analyticAlternative hg x z hz) i)
+    (S.coordinateMatrix x) (fun i j _ hz => S.coordinateMatrix_analytic x i j _
+      ((chartAt (Model X) x).map_source hz)))
+
+end SplitTangent.TangentSplitting
+
+open Filter Topology
+
+section FiniteBaseImport
+open Polynomial
+namespace SplitTangent.RationalSurface
+
+local instance projectiveTangentBoxDecidableEq : DecidableEq K := Classical.decEq K
+
+variable {ι : Type*} [Fintype ι]
+
+end SplitTangent.RationalSurface
+
+end FiniteBaseImport
+
+open Filter Topology
+
+open Filter Topology Metric Set
+
+ 
+
+open MvPowerSeries
+
+open Filter Topology Set Metric
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/QuotientSubmersions.lean

@@ -0,0 +1,99 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.ActualQuotientCharts
+import OAI.Geometry.SplitTangent.BasicSubmersionTransport
+import OAI.Geometry.SplitTangent.LeafJetAtlas
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.SwappedProductChart
+import OAI.Geometry.SplitTangent.ChartSubmersion
+import OAI.Geometry.SplitTangent.BasicDerivativeKernel
+
+namespace OAI
+
+/-! Quotient Submersions. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent.LeafJetAtlas
+variable {X : ComplexManifold.{u}} {S : TangentSplitting X}
+  [CompactSpace X.Carrier] [ConnectedSpace X.Carrier]
+  {L : LeafJetAtlas S} (M : LeafJetAtlas S.swap) {e : ProjectiveEmbedding X}
+  {hRC : RationallyConnected e} {hdim : 0<X.dim}
+namespace QuotientChartData
+variable {i : X.Carrier} (D : L.QuotientChartData e hRC hdim i)
+
+lemma chart_comp_quotient_eventuallyEq_rectangle {a : S.FirstModel i} {b : S.SecondModel i}
+    (ha : a∈D.U) (hb : b∈D.V) :
+    D.chart ∘ L.leafQuotient e hRC hdim =ᶠ[𝓝 ((L.chart i).chart.symm (a,b))]
+      (fun y => ((L.chart i).chart y).2) := by
+  let P := L.chart i
+  have ht : (a,b)∈P.chart.target := D.rectangle ⟨ha,hb⟩
+  have hs := P.chart.map_target ht
+  have hx : P.chart (P.chart.symm (a,b))=(a,b) := P.chart.right_inv ht
+  have hn := Filter.Eventually.and (P.chart.open_source.mem_nhds hs)
+    ((P.chart.continuousAt hs).preimage_mem_nhds (by
+      rw [hx]
+      exact (D.open_U.prod D.open_V).mem_nhds ⟨ha,hb⟩))
+  filter_upwards [hn] with y hy
+  change D.chart (L.leafQuotient e hRC hdim y)=(P.chart y).2
+  conv_lhs => rw [←P.chart.left_inv hy.1]
+  exact D.chart_quotient_rectangle hy.2.1 hy.2.2
+
+lemma chart_comp_quotient_submersion_rectangle {a : S.FirstModel i} {b : S.SecondModel i}
+    (ha : a∈D.U) (hb : b∈D.V) :
+    BasicSubmersionAt (D.chart ∘ L.leafQuotient e hRC hdim) ((L.chart i).chart.symm (a,b)) := by
+  refine ⟨D.chart_comp_quotient_contMDiffAt_rectangle ha hb,?_⟩
+  let P := L.chart i
+  have hs := P.chart.map_target (D.rectangle (show (a,b)∈D.U ×ˢ D.V from ⟨ha,hb⟩))
+  rw [(D.chart_comp_quotient_eventuallyEq_rectangle ha hb).mfderiv_eq]
+  exact P.snd_mfderiv_surjective hs
+
+lemma chart_comp_quotient_submersion {x : X.Carrier}
+    (hx : L.leafQuotient e hRC hdim x∈D.chart.source) :
+    BasicSubmersionAt (D.chart ∘ L.leafQuotient e hRC hdim) x := by
+  obtain ⟨b,hb,he⟩ := hx
+  exact (L.basic_submersion_leaf D.chart_comp_quotient_basic
+    ((L.leafQuotient_eq_iff e hRC hdim _ _).mp he)).mp
+      (D.chart_comp_quotient_submersion_rectangle D.mem_U hb)
+
+include M in
+lemma chart_comp_quotient_kernel {x : X.Carrier}
+    (hx : L.leafQuotient e hRC hdim x∈D.chart.source) :
+    LinearMap.ker (mfderiv (ModelWithCorners X) 𝓘(ℂ,S.SecondModel i)
+      (D.chart ∘ L.leafQuotient e hRC hdim) x).toLinearMap=S.first x := by
+  let : FiniteDimensional ℂ (Tangent X x) := by
+    change FiniteDimensional ℂ (Model X)
+    infer_instance
+  let d := (mfderiv (ModelWithCorners X) 𝓘(ℂ,S.SecondModel i)
+    (D.chart ∘ L.leafQuotient e hRC hdim) x).toLinearMap
+  have hs := D.chart_comp_quotient_submersion hx
+  have hsub : S.first x≤d.ker := by
+    intro v hv
+    exact L.basic_derivative_annihilates_first D.chart_comp_quotient_basic
+      (hs.1.mdifferentiableAt (by simp)) hv
+  apply Eq.symm
+  apply Submodule.eq_of_le_of_finrank_le hsub
+  have hd := d.finrank_range_add_finrank_ker
+  have hsur : d.range=⊤ := LinearMap.range_eq_top.mpr hs.2
+  rw [hsur,finrank_top] at hd
+  have hr := (L.chart i).swap.first_finrank (by
+    rw [AlignedProductChart.swap_source]
+    exact L.mem_source i)
+  have hc := M.first_rank_eq i x
+  rw [S.swap_first] at hr hc
+  have hp := (S.projector x).toLinearMap.finrank_range_add_finrank_ker
+  change Module.finrank ℂ (S.first x)+Module.finrank ℂ (S.second x)=_ at hp
+  change Module.finrank ℂ (S.SecondModel i)+Module.finrank ℂ d.ker=
+    Module.finrank ℂ (Tangent X x) at hd
+  rw [←hr,hc,Nat.add_comm] at hd
+  have hk : Module.finrank ℂ d.ker=Module.finrank ℂ (S.first x) :=
+    Nat.add_right_cancel (hd.trans hp.symm)
+  exact hk.le
+
+end QuotientChartData
+end SplitTangent.LeafJetAtlas
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/RCCovariantVanishing.lean

@@ -0,0 +1,176 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.BracketIntegrability
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.PositiveTangentCurves
+import OAI.Geometry.SplitTangent.TwistedCurveTensor
+import OAI.Geometry.SplitTangent.PositiveCoverLift
+import OAI.Geometry.SplitTangent.OpenPositiveLeaves
+
+namespace OAI
+
+/-! R C Covariant Vanishing. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+
+ 
+
+structure HolomorphicTangentTensor (X : ComplexManifold.{u}) (m : ℕ) where
+  value : X.Carrier → TangentTensor X m
+  holomorphic : ∀x,ContMDiffOn (ModelWithCorners X) 𝓘(ℂ,TangentTensor X m) ω
+    (fun y => (value y).compContinuousLinearMap (fun _ =>
+      (trivializationAt (Model X) (Tangent X) x).symmL ℂ y))
+    (trivializationAt (Model X) (Tangent X) x).baseSet
+
+namespace HolomorphicTangentTensor
+variable {X : ComplexManifold.{u}} {m : ℕ} (A : HolomorphicTangentTensor X m)
+
+def coordinates (x y : X.Carrier) : TangentTensor X m :=
+  (A.value y).compContinuousLinearMap (fun _ =>
+    (trivializationAt (Model X) (Tangent X) x).symmL ℂ y)
+
+lemma coordinates_zero_iff {x y : X.Carrier}
+    (hy : y∈(trivializationAt (Model X) (Tangent X) x).baseSet) :
+    A.coordinates x y=0 ↔ A.value y=0 := by
+  let t := trivializationAt (Model X) (Tangent X) x
+  constructor
+  · intro h
+    apply ContinuousMultilinearMap.ext
+    intro v
+    have h' := congrArg (fun B : TangentTensor X m =>
+      B (fun i => t.continuousLinearMapAt ℂ y (v i))) h
+    change A.value y (fun i => t.symmL ℂ y (t.continuousLinearMapAt ℂ y (v i)))=0 at h'
+    have he : (fun i => t.symmL ℂ y (t.continuousLinearMapAt ℂ y (v i))) = v := by
+      funext i
+      exact t.symmL_continuousLinearMapAt hy (v i)
+    rw [he] at h'
+    exact h'
+  · intro h
+    apply ContinuousMultilinearMap.ext
+    intro v
+    simp [coordinates,h]
+    rfl
+
+def along (g : RationalCurve X) : TwistedCurveTensor g 0 m where
+  finite := A.value ∘ g.finite
+  infinity := A.value ∘ g.infinity
+  finite_holomorphic z := by
+    exact (((A.holomorphic (g.finite z)).contMDiffAt
+      ((trivializationAt (Model X) (Tangent X) (g.finite z)).open_baseSet.mem_nhds
+        (FiberBundle.mem_baseSet_trivializationAt' _))).comp z
+      (g.finite_holomorphic z)).contDiffAt.analyticAt
+  infinity_holomorphic z := by
+    exact (((A.holomorphic (g.infinity z)).contMDiffAt
+      ((trivializationAt (Model X) (Tangent X) (g.infinity z)).open_baseSet.mem_nhds
+        (FiberBundle.mem_baseSet_trivializationAt' _))).comp z
+      (g.infinity_holomorphic z)).contDiffAt.analyticAt
+  overlap z hz := by simp [g.overlap z hz]
+
+lemma zero_on_positive_curve (hm : 0 < m) (g : RationalCurve X)
+    (hg : PointedGenerated g (fun _ => ⊤)) : A.value (g.finite 1)=0 := by
+  apply ContinuousMultilinearMap.ext
+  intro v
+  exact (A.along g).vanish_on_generated_fiber hg hm v (fun _ => Submodule.mem_top)
+
+lemma local_analytic_zero_locus (x : X.Carrier) :
+    ∃e : OpenPartialHomeomorph X.Carrier (Model X),x∈e.source ∧
+      ∃f : Model X → TangentTensor X m,AnalyticOnNhd ℂ f e.target ∧
+        ∀y∈e.source,A.value y=0 ↔ f (e y)=0 := by
+  let t := trivializationAt (Model X) (Tangent X) x
+  let c := chartAt (Model X) x
+  let e := c.restr t.baseSet
+  have hsrc : e.source=c.source ∩ t.baseSet := c.restr_source' _ t.open_baseSet
+  have htarg : e.target=c.target ∩ c.symm ⁻¹' t.baseSet := by
+    rw [OpenPartialHomeomorph.restr_target,t.open_baseSet.interior_eq]
+  refine ⟨e,?_,fun z => A.coordinates x (c.symm z),?_,?_⟩
+  · rw [hsrc]
+    exact ⟨mem_chart_source (Model X) x,FiberBundle.mem_baseSet_trivializationAt' _⟩
+  · intro z hz
+    rw [htarg] at hz
+    have hc : ContMDiffAt 𝓘(ℂ,Model X) (ModelWithCorners X) ω c.symm z :=
+      contMDiffAt_symm_of_mem_maximalAtlas
+        (IsManifold.chart_mem_maximalAtlas (I := ModelWithCorners X) x) hz.1
+    exact (((A.holomorphic x).contMDiffAt (t.open_baseSet.mem_nhds hz.2)).comp z hc).contDiffAt.analyticAt
+  · intro y hy
+    rw [hsrc] at hy
+    change A.value y=0 ↔ A.coordinates x (c.symm (c y))=0
+    rw [c.left_inv hy.1]
+    exact (A.coordinates_zero_iff hy.2).symm
+
+lemma eq_zero_of_nonempty_open [PreconnectedSpace X.Carrier]
+    {U : Set X.Carrier} (hU : IsOpen U) (hne : U.Nonempty)
+    (hzero : ∀x∈U,A.value x=0) : ∀x,A.value x=0 := by
+  have hZ : {x | A.value x=0}=univ :=
+    AnalyticContinuation.eq_univ_of_local_analytic_zero_locus
+      A.local_analytic_zero_locus (by
+        obtain ⟨x,hx⟩ := hne
+        exact ⟨x,mem_interior_iff_mem_nhds.mpr
+          (Filter.mem_of_superset (hU.mem_nhds hx) hzero)⟩)
+  intro x
+  have := Set.mem_univ x
+  rwa [←hZ] at this
+
+end HolomorphicTangentTensor
+
+namespace RationallyConnected
+variable {X : ComplexManifold.{u}} [CompactSpace X.Carrier]
+    (e : ProjectiveEmbedding X) (hRC : RationallyConnected e)
+include e hRC
+
+ 
+
+theorem exists_open_positive_tangent_curves (hdim : 0<X.dim) :
+    ∃U : Set X.Carrier,IsOpen U ∧ U.Nonempty ∧
+      ∀x∈U,∃g : RationalCurve X,g.finite 1=x ∧ PointedGenerated g (fun _ => ⊤) := by
+  obtain ⟨T,hT,G,hs⟩ := hRC.exists_submersive_family e hdim
+  let := hT
+  refine ⟨Set.range (G.evaluation 1),(G.evaluation_open hs).isOpen_range,
+    Set.range_nonempty _,?_⟩
+  rintro x ⟨τ,rfl⟩
+  refine ⟨G.curve τ,rfl,?_⟩
+  intro v hv
+  obtain ⟨σ,h0,h1⟩ := G.exists_section_endpoints (hs τ) 0 v
+  exact ⟨σ,fun _ => Submodule.mem_top,fun _ => Submodule.mem_top,h0,h1⟩
+
+ 
+
+theorem holomorphic_tensor_zero [PreconnectedSpace X.Carrier] (hdim : 0<X.dim)
+    {m : ℕ} (hm : 0 < m) (A : HolomorphicTangentTensor X m) :
+    ∀x,A.value x=0 := by
+  obtain ⟨U,hU,hUn,hpos⟩ := hRC.exists_open_positive_tangent_curves e hdim
+  apply A.eq_zero_of_nonempty_open hU hUn
+  intro x hx
+  obtain ⟨g,hg0,hg⟩ := hpos x hx
+  rw [←hg0]
+  exact A.zero_on_positive_curve hm g hg
+
+ 
+
+theorem holomorphic_cover_tensor_zero [ConnectedSpace X.Carrier]
+    {Y : ComplexManifold.{u}} [CompactSpace Y.Carrier] [ConnectedSpace Y.Carrier]
+    {p : Y.Carrier → X.Carrier} (hcover : IsCoveringMap p)
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (hdim : 0<X.dim) {m : ℕ} (hm : 0 < m) (A : HolomorphicTangentTensor Y m) :
+    ∀y,A.value y=0 := by
+  have hs : Function.Surjective p := by
+    have hc : IsClopen (Set.range p) :=
+      ⟨isCompact_range hcover.continuous |>.isClosed,hcover.isOpenMap.isOpen_range⟩
+    exact Set.range_eq_univ.mp (hc.eq_univ (Set.range_nonempty _))
+  obtain ⟨U,hU,hUn,hpos⟩ := hRC.exists_open_positive_tangent_curves e hdim
+  apply A.eq_zero_of_nonempty_open (hU.preimage hcover.continuous)
+    (hUn.preimage hs)
+  intro y hy
+  obtain ⟨g,hg1,hg⟩ := hpos (p y) hy
+  obtain ⟨k,hk1,hk,_,_⟩ := g.exists_positive_cover_lift_at hg hcover hp 1 y hg1.symm
+  rw [←hk1]
+  exact A.zero_on_positive_curve hm k hk
+
+end RationallyConnected
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/RationalAccepted.lean

@@ -0,0 +1,97 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.RationalFamilies
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Rational Accepted. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped ContDiff Manifold
+
+universe u
+namespace SplitTangent.RationalParameters
+open AnalyticZeroCover
+
+variable {X : ComplexManifold.{u}} (e : ProjectiveEmbedding X) [CompactSpace X.Carrier]
+
+ 
+
+lemma analyticSetOn_incidenceAlternative {m : ℕ} {U : Set (Space m)} (hU : IsOpen U)
+    {Q : Space m → Fin (e.N+1) → ℂ} (hQ : AnalyticOnNhd ℂ Q U)
+    (hnz : ∀ z∈U, Q z≠0) :
+    AnalyticSetOn U {z | z∈U ∧ ∃ x, e.Incidence x (Q z)} where
+  subset := fun _ h => h.1
+  closed := by
+    intro z hz
+    refine ⟨hz.2,?_⟩
+    change Q z ∈ {v | ∃ x, e.Incidence x v}
+    rw [← e.isClosed_cone.closure_eq]
+    exact (closure_mono (show Q '' {z | z∈U ∧ ∃ x, e.Incidence x (Q z)} ⊆
+        {v | ∃ x, e.Incidence x v} from by rintro _ ⟨y,hy,rfl⟩; exact hy.2)
+        (mem_closure_image (hQ z hz.2).continuousAt hz.1))
+  local_equations := by
+    intro z hz
+    obtain ⟨D,hD,hDeq⟩ := e.cone_local_equations_any (hnz z hz.1)
+    have hcomp : AnalyticAt ℂ (D ∘ Q) z := hD.comp (hQ z hz.1)
+    have heq := (hQ z hz.1).continuousAt.eventually hDeq
+    obtain ⟨V,hV,hVo,hVz⟩ := eventually_nhds_iff.mp
+      (Filter.Eventually.and (hU.mem_nhds hz.1) (hcomp.eventually_analyticAt.and heq))
+    let f : Fin (e.N+1) → Space m → ℂ := fun i y => D (Q y) i
+    refine ⟨V,hVo,hVz,fun y hy => (hV y hy).1,Set.range f,?_,?_⟩
+    · rintro g ⟨i,rfl⟩ y hy
+      exact ((ContinuousLinearMap.proj i).analyticAt _).comp (hV y hy).2.1
+    · intro y hy
+      simp only [mem_ofPred_eq,forall_mem_range]
+      have hyU : y∈U := (hV y hy).1
+      simp only [hyU,true_and]
+      rw [(hV y hy).2.2]
+      exact ⟨fun h i => congrFun h i,fun h => funext h⟩
+
+lemma accepted_test {d : ℕ} (P : Patch (Coeff e.N d))
+    (hPM : P.image ⊆ regular e.N d) (hPA : ¬P.image ⊆ accepted e d) :
+    ∃ B : Set (Space P.dim), AnalyticSetOn P.domain B ∧
+      (∃ x∈P.domain, x∉B) ∧ {x | x∈P.domain ∧ P.map x∈accepted e d} ⊆ B := by
+  classical
+  obtain ⟨τ,hτ,hτA⟩ := Set.not_subset.mp hPA
+  obtain ⟨x,hx,rfl⟩ := hτ
+  have hn : ∃ b : Bool, ∃ z : ℂ, ¬∃ y, e.Incidence y (ev b (P.map x) z) := by
+    simpa only [accepted,mem_ofPred_eq,not_forall] using hτA
+  obtain ⟨b,z,hbad⟩ := hn
+  let Q : Space P.dim → (Fin (e.N+1) → ℂ) := fun y => ev b (P.map y) z
+  have hQ : AnalyticOnNhd ℂ Q P.domain := fun y hy =>
+    AnalyticAt.comp (f := fun y => (z,P.map y)) (x := y) (ev_analytic b (z,P.map y))
+      (analyticAt_const.prod (P.analytic y hy))
+  refine ⟨{y | y∈P.domain ∧ ∃ q, e.Incidence q (Q y)},
+    analyticSetOn_incidenceAlternative e P.isOpen_domain hQ
+      (fun y hy => regular_nonzero (hPM ⟨y,hy,rfl⟩) b z),?_,?_⟩
+  · exact ⟨x,hx,fun h => hbad h.2⟩
+  · intro y hy
+    exact ⟨hy.1,hy.2 b z⟩
+
+ 
+
+theorem countable_accepted {d : ℕ} :
+    ∃ C : Set (Patch (Coeff e.N d)), C.Countable ∧
+      (∀ P∈C, P.image ⊆ regular e.N d ∩ accepted e d) ∧
+      regular e.N d ∩ accepted e d ⊆ ⋃ P∈C,P.image := by
+  classical
+  obtain ⟨D,hD,hDdim,hcover⟩ := countable_open_patches (isOpen_regular e.N d)
+  have H (i : D) := i.val.countable_accepted_cover (accepted_test e) (hDdim i.val i.property).2
+  choose C hC hCp hCc using H
+  let : Countable D := hD.to_subtype
+  refine ⟨⋃ i,C i,Set.countable_iUnion hC,?_,?_⟩
+  · intro P hP
+    obtain ⟨i,hi⟩ := mem_iUnion.mp hP
+    exact (hCp i P hi).2
+  · intro τ hτ
+    obtain ⟨P,hP,hτP⟩ := mem_iUnion₂.mp (hcover hτ.1)
+    obtain ⟨Q,hQ,hτQ⟩ := mem_iUnion₂.mp (hCc ⟨P,hP⟩ ⟨hτP,hτ.2⟩)
+    exact mem_iUnion₂.mpr ⟨Q,mem_iUnion.mpr ⟨⟨P,hP⟩,hQ⟩,hτQ⟩
+
+end SplitTangent.RationalParameters
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/RationalCoverLift.lean

@@ -0,0 +1,89 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+
+namespace OAI
+
+/-! Rational Cover Lift. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff
+universe u
+namespace SplitTangent
+variable {X Y : ComplexManifold.{u}} {p : Y.Carrier → X.Carrier}
+
+lemma holomorphic_of_continuous_cover_lift
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    {f : ℂ → X.Carrier} {g : ℂ → Y.Carrier}
+    (hf : ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners X) ω f)
+    (hg : Continuous g) (he : ∀z,p (g z)=f z) :
+    ContMDiff 𝓘(ℂ,ℂ) (ModelWithCorners Y) ω g := by
+  intro z
+  let h := hp (g z)
+  have hinv := h.localInverse_contMDiffAt
+  rw [he z] at hinv
+  have hh := hinv.comp z (hf z)
+  apply hh.congr_of_eventuallyEq
+  have hn := hg.continuousAt.preimage_mem_nhds
+    (h.localInverse.open_target.mem_nhds h.localInverse_mem_target)
+  filter_upwards [hn] with w hw
+  change g w=h.localInverse (f w)
+  rw [←he w,h.localInverse_left_inv hw]
+
+ 
+
+theorem RationalCurve.exists_cover_lift_at (g : RationalCurve X)
+    (hcover : IsCoveringMap p)
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (a₀ : ℂ) (y : Y.Carrier) (hy : p y=g.finite a₀) :
+    ∃k : RationalCurve Y,k.finite a₀=y ∧
+      (∀z,p (k.finite z)=g.finite z) ∧ (∀z,p (k.infinity z)=g.infinity z) := by
+  let f : C(ℂ,X.Carrier) := ⟨g.finite,g.finite_holomorphic.continuous⟩
+  obtain ⟨F,hF,_⟩ := hcover.existsUnique_continuousMap_lifts f a₀ y hy
+  have hF' z : p (F z)=g.finite z := congrFun hF.2 z
+  have h1 : p (F 1)=g.infinity 1 := by
+    rw [hF' 1,g.overlap 1 one_ne_zero,inv_one]
+  let q : C(ℂ,X.Carrier) := ⟨g.infinity,g.infinity_holomorphic.continuous⟩
+  obtain ⟨G,hG,_⟩ := hcover.existsUnique_continuousMap_lifts q (1 : ℂ) (F 1) h1
+  have hG' z : p (G z)=g.infinity z := congrFun hG.2 z
+  have hconn : IsPreconnected {z : ℂ | z≠0} := by
+    have hh := (isConnected_compl_singleton_of_one_lt_rank
+      (E := ℂ) (by norm_num [Complex.rank_real_complex]) (0 : ℂ)).isPreconnected
+    exact hh
+  let : PreconnectedSpace {z : ℂ // z≠0} := isPreconnected_iff_preconnectedSpace.mp hconn
+  let a : {z : ℂ // z≠0} → Y.Carrier := fun z => F z.val
+  let b : {z : ℂ // z≠0} → Y.Carrier := fun z => G z.val⁻¹
+  have ha : Continuous a := F.continuous.comp continuous_subtype_val
+  have hb : Continuous b := G.continuous.comp
+    (continuous_subtype_val.inv₀ (fun z => z.property))
+  have hab : p ∘ a=p ∘ b := by
+    funext z
+    exact (hF' z.val).trans ((g.overlap z.val z.property).trans (hG' z.val⁻¹).symm)
+  have hab1 : a ⟨1,one_ne_zero⟩=b ⟨1,one_ne_zero⟩ := by
+    change F 1=G 1⁻¹
+    rw [inv_one,hG.1]
+  have heq : a=b := hcover.eq_of_comp_eq ha hb hab ⟨1,one_ne_zero⟩ hab1
+  let k : RationalCurve Y := {
+    finite := F
+    infinity := G
+    finite_holomorphic := holomorphic_of_continuous_cover_lift hp
+      g.finite_holomorphic F.continuous hF'
+    infinity_holomorphic := holomorphic_of_continuous_cover_lift hp
+      g.infinity_holomorphic G.continuous hG'
+    overlap z hz := congrFun heq ⟨z,hz⟩ }
+  exact ⟨k,hF.1,hF',hG'⟩
+
+ 
+theorem RationalCurve.exists_cover_lift (g : RationalCurve X)
+    (hcover : IsCoveringMap p)
+    (hp : IsLocalDiffeomorph (ModelWithCorners Y) (ModelWithCorners X) ω p)
+    (y : Y.Carrier) (hy : p y=g.finite 0) :
+    ∃k : RationalCurve Y,k.finite 0=y ∧
+      (∀z,p (k.finite z)=g.finite z) ∧ (∀z,p (k.infinity z)=g.infinity z) :=
+  g.exists_cover_lift_at hcover hp 0 y hy
+
+end SplitTangent
+
+end
+
+end OAI

lean/OAI/Geometry/SplitTangent/RationalCurveFrames.lean

@@ -0,0 +1,134 @@
+import Mathlib
+import OAI.Geometry.SplitTangent.Basic
+import OAI.Geometry.SplitTangent.FormalBoxes
+import OAI.Geometry.SplitTangent.ProjectiveLineFrame
+
+namespace OAI
+
+/-! Rational Curve Frames. -/
+
+noncomputable section
+open Set Filter Topology
+open scoped Manifold ContDiff BigOperators
+universe u
+namespace SplitTangent
+
+ 
+
+structure RationalCurveFrames {X : ComplexManifold.{u}}
+    (e : ProjectiveEmbedding X) (g : RationalCurve X) where
+  degree : ℕ
+  P : Fin (e.N+1) → Polynomial ℂ
+  Q : Fin (e.N+1) → Polynomial ℂ
+  a : Fin (e.N+1) → Polynomial ℂ
+  b : Fin (e.N+1) → Polynomial ℂ
+  finite_bezout : ∑i,a i*P i=1
+  infinity_bezout : ∑i,b i*Q i=1
+  finite_incidence : ∀z,e.Incidence (g.finite z) (fun i => (P i).eval z)
+  infinity_incidence : ∀z,e.Incidence (g.infinity z) (fun i => (Q i).eval z)
+  transition : ∀z,z≠0 → ∀i,(P i).eval z=z^degree*(Q i).eval z⁻¹
+
+theorem RationalCurve.exists_frames {X : ComplexManifold.{u}}
+    (e : ProjectiveEmbedding X) (g : RationalCurve X) : Nonempty (RationalCurveFrames e g) := by
+  classical
+  obtain ⟨d,P,Q,hP,hQ,hdeg,hf,hi,ht⟩ := rationalCurve_two_chart_polynomials e g
+  obtain ⟨a,ha⟩ := PolynomialTuple.bezout P hP
+  obtain ⟨b,hb⟩ := PolynomialTuple.bezout Q hQ
+  refine ⟨⟨d,P,Q,a,b,ha,hb,?_,?_,ht⟩⟩
+  · intro z
+    obtain ⟨k,hk⟩ := Function.ne_iff.mp (e.map (g.finite z)).rep_nonzero
+    refine (e.incidence_iff_coordinates hk).mpr (fun j => ?_)
+    exact (hf z k j hk).trans (mul_comm _ _)
+  · intro z
+    obtain ⟨k,hk⟩ := Function.ne_iff.mp (e.map (g.infinity z)).rep_nonzero
+    refine (e.incidence_iff_coordinates hk).mpr (fun j => ?_)
+    exact (hi z k j hk).trans (mul_comm _ _)
+
+namespace RationalCurveFrames
+variable {X : ComplexManifold.{u}} {e : ProjectiveEmbedding X} {g : RationalCurve X}
+    (F : RationalCurveFrames e g)
+
+def finite (z : ℂ) (x : X.Carrier) := e.linearFrame (fun i => (F.a i).eval z) x
+def infinity (z : ℂ) (x : X.Carrier) := e.linearFrame (fun i => (F.b i).eval z) x
+
+lemma finite_unit (z : ℂ) : ∑i,(F.a i).eval z*(F.P i).eval z=1 := by
+  simpa only [Polynomial.eval_finsetSum,Polynomial.eval_mul,Polynomial.eval_one]
+    using congrArg (Polynomial.eval z) F.finite_bezout
+lemma infinity_unit (z : ℂ) : ∑i,(F.b i).eval z*(F.Q i).eval z=1 := by
+  simpa only [Polynomial.eval_finsetSum,Polynomial.eval_mul,Polynomial.eval_one]
+    using congrArg (Polynomial.eval z) F.infinity_bezout
+
+lemma finite_denominator_ne (z : ℂ) :
+    (∑i,(F.a i).eval z*(e.map (g.finite z)).rep i)≠0 :=
+  e.linearFrame_denominator_ne (F.finite_incidence z) (F.finite_unit z)
+lemma infinity_denominator_ne (z : ℂ) :
+    (∑i,(F.b i).eval z*(e.map (g.infinity z)).rep i)≠0 :=
+  e.linearFrame_denominator_ne (F.infinity_incidence z) (F.infinity_unit z)
+
+lemma finite_on_curve (z : ℂ) : F.finite z (g.finite z)=fun i => (F.P i).eval z :=
+  e.linearFrame_eq_of_incidence (F.finite_incidence z) (F.finite_unit z)
+lemma infinity_on_curve (z : ℂ) : F.infinity z (g.infinity z)=fun i => (F.Q i).eval z :=
+  e.linearFrame_eq_of_incidence (F.infinity_incidence z) (F.infinity_unit z)
+
+ 
+def multiplier (z : ℂ) (x : X.Carrier) : ℂ :=
+  ∑i,(F.b i).eval z⁻¹ * F.finite z x i
+
+lemma multiplier_on_curve {z : ℂ} (hz : z≠0) :
+    F.multiplier z (g.finite z)=z^F.degree := by
+  simp only [multiplier,F.finite_on_curve,F.transition z hz]
+  calc
+    _ = z^F.degree * (∑i,(F.b i).eval z⁻¹ * (F.Q i).eval z⁻¹) := by
+      rw [Finset.mul_sum]
+      apply Finset.sum_congr rfl
+      intro i hi
+      ring
+    _ = _ := by rw [F.infinity_unit,mul_one]
+
+lemma frame_transition (z : ℂ) (x : X.Carrier)
+    (hb : (∑i,(F.b i).eval z⁻¹*(e.map x).rep i)≠0) :
+    F.finite z x=F.multiplier z x • F.infinity z⁻¹ x :=
+  e.linearFrame_change _ _ x hb
+
+lemma finite_holomorphicAt (z : ℂ) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,Fin (e.N+1) → ℂ) ω
+      (F.finite z) (g.finite z) :=
+  e.linearFrame_holomorphicAt (ModelWithCorners X) contMDiffAt_id
+    contMDiffAt_const (F.finite_denominator_ne z)
+
+lemma infinity_holomorphicAt (z : ℂ) :
+    ContMDiffAt (ModelWithCorners X) 𝓘(ℂ,Fin (e.N+1) → ℂ) ω
+      (F.infinity z) (g.infinity z) :=
+  e.linearFrame_holomorphicAt (ModelWithCorners X) contMDiffAt_id
+    contMDiffAt_const (F.infinity_denominator_ne z)
+
+ 
+
+lemma finite_joint_holomorphicAt (z : ℂ) :
+    ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,Fin (e.N+1) → ℂ) ω
+      (fun q : ℂ × X.Carrier => F.finite q.1 q.2) (z,g.finite z) := by
+  apply e.linearFrame_holomorphicAt _ contMDiffAt_snd _ (F.finite_denominator_ne z)
+  apply contMDiffAt_pi_space.mpr
+  intro i
+  have hp : ContMDiffAt 𝓘(ℂ,ℂ) 𝓘(ℂ,ℂ) ω (fun t => (F.a i).eval t) z := by
+    simpa [Polynomial.aeval_def] using
+      ((F.a i).contDiff_aeval (𝕜 := ℂ) ω).contDiffAt.contMDiffAt
+  exact hp.comp (z,g.finite z) (contMDiffAt_fst (I := 𝓘(ℂ,ℂ)) (J := ModelWithCorners X))
+
+lemma infinity_joint_holomorphicAt (z : ℂ) :
+    ContMDiffAt (𝓘(ℂ,ℂ).prod (ModelWithCorners X)) 𝓘(ℂ,Fin (e.N+1) → ℂ) ω
+      (fun q : ℂ × X.Carrier => F.infinity q.1 q.2) (z,g.infinity z) := by
+  apply e.linearFrame_holomorphicAt _ contMDiffAt_snd _ (F.infinity_denominator_ne z)
+  apply contMDiffAt_pi_space.mpr
+  intro i
+  have hp : ContMDiffAt 𝓘(ℂ,ℂ) 𝓘(ℂ,ℂ) ω (fun t => (F.b i).eval t) z := by
+    simpa [Polynomial.aeval_def] using
+      ((F.b i).contDiff_aeval (𝕜 := ℂ) ω).contDiffAt.contMDiffAt
+  exact hp.comp (z,g.infinity z) (contMDiffAt_fst (I := 𝓘(ℂ,ℂ)) (J := ModelWithCorners X))
+
+end RationalCurveFrames
+end SplitTangent
+
+end
+
+end OAI