import OAI.Geometry.ComplexBundle.GrassmannManifold
import OAI.Geometry.ComplexBundle.Kernel

namespace OAI

noncomputable section

/-! Linear incidence equations and their graph-coordinate kernel bundles. -/

section
open Module
namespace Kaplansky.Incidence
variable {E F V : Type*} [AddCommGroup E] [Module ℂ E]
  [AddCommGroup F] [Module ℂ F] [AddCommGroup V] [Module ℂ V]

def restrictQuotient (S : Submodule ℂ E) (U : Submodule ℂ F) :
    (E →ₗ[ℂ] F) →ₗ[ℂ] (S →ₗ[ℂ] F ⧸ U) where
  toFun T := U.mkQ.comp (T.comp S.subtype)
  map_add' _ _ := by ext; rfl
  map_smul' _ _ := by ext; rfl

theorem restrictQuotient_surjective (S : Submodule ℂ E) (U : Submodule ℂ F) :
    Function.Surjective (restrictQuotient S U) := by
  obtain ⟨C,hC⟩ := S.exists_isCompl
  obtain ⟨lift,hlift⟩ := U.mkQ.exists_rightInverse_of_surjective
    (LinearMap.range_eq_top.mpr U.mkQ_surjective)
  intro T
  refine ⟨lift.comp (T.comp (S.projectionOnto C hC)),?_⟩
  ext x
  change U.mkQ (lift (T (S.projectionOnto C hC x.val)))=T x
  rw [Submodule.projectionOnto_apply_left]
  exact congrArg (fun L : (F ⧸ U) →ₗ[ℂ] (F ⧸ U) => L (T x)) hlift

/-- The q-fold evaluation/restriction/quotient map used by the incidence locus. -/
def tupleRestriction {q : ℕ} (S : Submodule ℂ E) (U : Submodule ℂ F)
    (ev : V →ₗ[ℂ] (Fin q → E →ₗ[ℂ] F)) :
    V →ₗ[ℂ] (Fin q → S →ₗ[ℂ] F ⧸ U) where
  toFun v i := restrictQuotient S U (ev v i)
  map_add' _ _ := by ext; simp
  map_smul' _ _ := by ext; simp

theorem tupleRestriction_surjective {q : ℕ} (S : Submodule ℂ E) (U : Submodule ℂ F)
    (ev : V →ₗ[ℂ] (Fin q → E →ₗ[ℂ] F)) (hev : Function.Surjective ev) :
    Function.Surjective (tupleRestriction S U ev) := by
  intro T
  choose L hL using (fun i => restrictQuotient_surjective S U (T i))
  obtain ⟨v,hv⟩ := hev L
  refine ⟨v,?_⟩
  funext i
  change restrictQuotient S U (ev v i)=T i
  rw [hv,hL]

theorem mem_tupleRestriction_ker {q : ℕ} (S : Submodule ℂ E) (U : Submodule ℂ F)
    (ev : V →ₗ[ℂ] (Fin q → E →ₗ[ℂ] F)) (v : V) :
    v ∈ LinearMap.ker (tupleRestriction S U ev) ↔
      ∀ i, ∀ x ∈ S, ev v i x ∈ U := by
  change (fun i => U.mkQ.comp ((ev v i).comp S.subtype))=0 ↔ _
  constructor
  · intro h i x hx
    have he := congrArg (fun T : Fin q → S →ₗ[ℂ] F ⧸ U => T i ⟨x,hx⟩) h
    exact (Submodule.Quotient.mk_eq_zero U).mp he
  · intro h
    funext i
    apply LinearMap.ext
    intro x
    exact (Submodule.Quotient.mk_eq_zero U).mpr (h i x.val x.property)

variable [FiniteDimensional ℂ E] [FiniteDimensional ℂ F]

theorem incidence_target_finrank (q : ℕ) (S : Submodule ℂ E) (U : Submodule ℂ F) :
    finrank ℂ (Fin q → S →ₗ[ℂ] F ⧸ U)=
      q * finrank ℂ S * (finrank ℂ F-finrank ℂ U) := by
  have hU := U.finrank_quotient_add_finrank
  have hQ : finrank ℂ (F ⧸ U)=finrank ℂ F-finrank ℂ U := by omega
  simp [Module.finrank_pi_fintype,Module.finrank_linearMap,hQ, Nat.mul_assoc]

/-- Exact rank-nullity for the actual incidence fiber in the parameter space V. -/
theorem incidence_kernel_finrank [FiniteDimensional ℂ V] {q : ℕ}
    (S : Submodule ℂ E) (U : Submodule ℂ F)
    (ev : V →ₗ[ℂ] (Fin q → E →ₗ[ℂ] F)) (hev : Function.Surjective ev) :
    finrank ℂ (LinearMap.ker (tupleRestriction S U ev))=
      finrank ℂ V-q * finrank ℂ S * (finrank ℂ F-finrank ℂ U) := by
  have h := (tupleRestriction S U ev).finrank_range_add_finrank_ker
  rw [LinearMap.range_eq_top.mpr (tupleRestriction_surjective S U ev hev),
    finrank_top, incidence_target_finrank] at h
  omega

theorem incidence_kernel_real_finrank [FiniteDimensional ℂ V] {q : ℕ}
    (S : Submodule ℂ E) (U : Submodule ℂ F)
    (ev : V →ₗ[ℂ] (Fin q → E →ₗ[ℂ] F)) (hev : Function.Surjective ev) :
    finrank ℝ (LinearMap.ker (tupleRestriction S U ev))=
      2*(finrank ℂ V-q * finrank ℂ S * (finrank ℂ F-finrank ℂ U)) := by
  rw [finrank_real_of_complex,incidence_kernel_finrank S U ev hev]

end Kaplansky.Incidence

end

section
open scoped ContDiff
namespace Kaplansky.Incidence
variable {s k t l : ℕ}
open ComplexGrassmann

/-- The quotient coordinate of a graph t-plane, (u,v) ↦ v-bu. -/
def graphQuotient (b : GraphSlope t l) : GraphAmbient t l →L[ℂ] GraphVertical l :=
  ContinuousLinearMap.snd ℂ _ _ - b.comp (ContinuousLinearMap.fst ℂ _ _)

@[simp] theorem graphQuotient_apply (b : GraphSlope t l) (v : GraphAmbient t l) :
    graphQuotient b v=v.2-b v.1 := rfl

theorem graphQuotient_zero_iff (b : GraphSlope t l) (v : GraphAmbient t l) :
    graphQuotient b v=0 ↔ v ∈ b.toLinearMap.graph := sub_eq_zero

theorem graphQuotient_surjective (b : GraphSlope t l) : Function.Surjective (graphQuotient b) := by
  intro w
  exact ⟨(0,w),by simp⟩

def graphRestriction (a : GraphSlope s k) (b : GraphSlope t l) :
    (GraphAmbient s k →L[ℂ] GraphAmbient t l) →L[ℂ]
      (GraphHorizontal s →L[ℂ] GraphVertical l) :=
  ((ContinuousLinearMap.compL ℂ (GraphHorizontal s) (GraphAmbient t l) (GraphVertical l))
    (graphQuotient b)).comp
      ((ContinuousLinearMap.compL ℂ (GraphHorizontal s) (GraphAmbient s k) (GraphAmbient t l)).flip
        (graphInclusion a))

@[simp] theorem graphRestriction_apply (a : GraphSlope s k) (b : GraphSlope t l)
    (T : GraphAmbient s k →L[ℂ] GraphAmbient t l) (v : GraphHorizontal s) :
    graphRestriction a b T v=graphQuotient b (T (v,a v)) := by
  simp [graphRestriction]

/-- The zero equation for these smooth coordinates is exactly preservation of
S into U, with S and U the actual graph subspaces. -/
theorem graphRestriction_zero_iff (a : GraphSlope s k) (b : GraphSlope t l)
    (T : GraphAmbient s k →L[ℂ] GraphAmbient t l) :
    graphRestriction a b T=0 ↔ ∀ v ∈ a.toLinearMap.graph, T v ∈ b.toLinearMap.graph := by
  constructor
  · intro h v hv
    have he := congrArg (fun Q : GraphHorizontal s →L[ℂ] GraphVertical l => Q v.1) h
    have hv' : v.2=a v.1 := hv
    have hvv : (v.1,a v.1)=v := Prod.ext rfl hv'.symm
    rw [graphRestriction_apply,hvv] at he
    exact (graphQuotient_zero_iff b (T v)).mp he
  · intro h
    apply ContinuousLinearMap.ext
    intro v
    simpa only [graphRestriction_apply,zero_apply] using
      (graphQuotient_zero_iff b (T (v,a v))).mpr (h _ rfl)

/-- A concrete right inverse: place the requested quotient map in the lower
left block and set all other blocks to zero. -/
theorem graphRestriction_surjective (a : GraphSlope s k) (b : GraphSlope t l) :
    Function.Surjective (graphRestriction a b) := by
  intro C
  refine ⟨(ContinuousLinearMap.inr ℂ _ _).comp
    (C.comp (ContinuousLinearMap.fst ℂ _ _)),?_⟩
  ext v
  simp [graphRestriction_apply]

theorem graphQuotient_smooth : ContDiff ℂ ∞ (graphQuotient (t := t) (l := l)) :=
  contDiff_const.sub (contDiff_id.clm_comp contDiff_const)

theorem graphInclusion_smooth : ContDiff ℂ ∞ (graphInclusion (s := s) (k := k)) :=
  contDiff_const.add (contDiff_const.clm_comp contDiff_id)

theorem graphRestriction_smooth : ContDiff ℂ ∞
    (fun p : GraphSlope s k × GraphSlope t l => graphRestriction p.1 p.2) := by
  have hq : ContDiff ℂ ∞ (fun p : GraphSlope s k × GraphSlope t l => graphQuotient p.2) :=
    graphQuotient_smooth.comp contDiff_snd
  have hi : ContDiff ℂ ∞ (fun p : GraphSlope s k × GraphSlope t l => graphInclusion p.1) :=
    graphInclusion_smooth.comp contDiff_fst
  exact (((ContinuousLinearMap.compL ℂ (GraphHorizontal s) (GraphAmbient t l)
    (GraphVertical l)).contDiff.comp hq)).clm_comp
    (((ContinuousLinearMap.compL ℂ (GraphHorizontal s) (GraphAmbient s k)
      (GraphAmbient t l)).flip.contDiff).comp hi)

theorem graphRestriction_smooth_real : ContDiff ℝ ∞
    (fun p : GraphSlope s k × GraphSlope t l => graphRestriction p.1 p.2) :=
  (graphRestriction_smooth (s := s) (k := k) (t := t) (l := l)).restrict_scalars ℝ

end Kaplansky.Incidence

end

open scoped ContDiff Manifold
namespace Kaplansky.Incidence
open ComplexGrassmann SmoothKernel
variable {s k t l q : ℕ}

abbrev TupleAmbient (q s k t l : ℕ) :=
  Fin q → GraphAmbient s k →L[ℂ] GraphAmbient t l
abbrev TupleTarget (q s l : ℕ) := Fin q → GraphHorizontal s →L[ℂ] GraphVertical l

def tupleGraphRestriction (a : GraphSlope s k) (b : GraphSlope t l) :
    TupleAmbient q s k t l →L[ℂ] TupleTarget q s l :=
  ContinuousLinearMap.pi (fun i => (graphRestriction a b).comp (ContinuousLinearMap.proj i))

theorem tupleGraphRestriction_surjective (a : GraphSlope s k) (b : GraphSlope t l) :
    Function.Surjective (tupleGraphRestriction (q := q) a b) := by
  intro C
  choose T hT using fun i => graphRestriction_surjective a b (C i)
  exact ⟨T,funext hT⟩

theorem tupleGraphRestriction_smooth : ContDiff ℂ ∞
    (fun p : GraphSlope s k × GraphSlope t l => tupleGraphRestriction (q := q) p.1 p.2) := by
  apply contDiff_clm_apply_iff.mpr
  intro T
  apply contDiff_pi.mpr
  intro i
  exact graphRestriction_smooth.clm_apply contDiff_const

theorem tupleTarget_finrank : Module.finrank ℂ (TupleTarget q s l)=q*s*l := by
  have h : Module.finrank ℂ (GraphHorizontal s →L[ℂ] GraphVertical l)=s*l :=
    graph_slope_complex_finrank
  simp [TupleTarget,Module.finrank_pi_fintype,h,Nat.mul_assoc]

variable {Y V : Type*} [NormedAddCommGroup Y] [NormedSpace ℝ Y]
  [NormedAddCommGroup V] [NormedSpace ℂ V]
variable (ev : Y → V →L[ℂ] TupleAmbient q s k t l)

/-- The actual linear family whose zero set is the local incidence locus. -/
def graphEvaluation (p : Y × (GraphSlope s k × GraphSlope t l)) : V →L[ℂ] TupleTarget q s l :=
  (tupleGraphRestriction p.2.1 p.2.2).comp (ev p.1)

theorem graphEvaluation_smooth (he : ContDiff ℝ ∞ ev) : ContDiff ℝ ∞ (graphEvaluation ev) := by
  have hc : ContDiff ℂ ∞ (fun p :
      (TupleAmbient q s k t l →L[ℂ] TupleTarget q s l) × (V →L[ℂ] TupleAmbient q s k t l) =>
      p.1.comp p.2) := contDiff_fst.clm_comp contDiff_snd
  exact (hc.restrict_scalars ℝ).comp
    (((tupleGraphRestriction_smooth (q := q) (s := s) (k := k) (t := t) (l := l)).restrict_scalars ℝ).comp
      contDiff_snd |>.prodMk (he.comp contDiff_fst))

def graphFamily (he : ContDiff ℝ ∞ ev) (hs : ∀ y, Function.Surjective (ev y)) :
    SurjectiveFamily (Y × (GraphSlope s k × GraphSlope t l)) V (TupleTarget q s l) where
  map := graphEvaluation ev
  continuous := (graphEvaluation_smooth ev he).continuous
  surjective p := (tupleGraphRestriction_surjective p.2.1 p.2.2).comp (hs p.1)

omit [NormedAddCommGroup Y] [NormedSpace ℝ Y] in
theorem graphEvaluation_zero_iff (p : Y × (GraphSlope s k × GraphSlope t l)) (v : V) :
    graphEvaluation ev p v=0 ↔ ∀ i, ∀ x ∈ p.2.1.toLinearMap.graph,
      ev p.1 v i x ∈ p.2.2.toLinearMap.graph := by
  constructor
  · intro h i
    have hi := congrArg (fun T : TupleTarget q s l => T i) h
    exact (graphRestriction_zero_iff p.2.1 p.2.2 (ev p.1 v i)).mp hi
  · intro h
    funext i
    exact (graphRestriction_zero_iff p.2.1 p.2.2 (ev p.1 v i)).mpr (h i)

variable [FiniteDimensional ℂ V]

theorem graph_kernel_finrank (he : ContDiff ℝ ∞ ev) (hs : ∀ y, Function.Surjective (ev y))
    (p : Y × (GraphSlope s k × GraphSlope t l)) :
    Module.finrank ℂ (LinearMap.ker (graphEvaluation ev p).toLinearMap)=
      Module.finrank ℂ V-q*s*l := by
  have h := (graphFamily ev he hs).kernel_finrank p
  change Module.finrank ℂ (LinearMap.ker (graphEvaluation ev p).toLinearMap) =
    Module.finrank ℂ V - Module.finrank ℂ (TupleTarget q s l) at h
  rw [tupleTarget_finrank] at h
  exact h

theorem graph_kernel_bundle_smooth (he : ContDiff ℝ ∞ ev) (hs : ∀ y, Function.Surjective (ev y)) :
    (graphFamily ev he hs).realCore.IsContMDiff
      𝓘(ℝ,Y × (GraphSlope s k × GraphSlope t l)) ∞ :=
  (graphFamily ev he hs).realCore_isContMDiff (graphEvaluation_smooth ev he)

omit [FiniteDimensional ℂ V] in
theorem incidence_model_finrank [FiniteDimensional ℝ Y] : Module.finrank ℝ
    ((Y × (GraphSlope s k × GraphSlope t l)) × KernelModel V (TupleTarget q s l))=
      Module.finrank ℝ Y+2*s*k+2*t*l+2*(Module.finrank ℂ V-q*s*l) := by
  simp only [Module.finrank_prod,graph_slope_real_finrank,
    SurjectiveFamily.kernel_model_real_finrank,tupleTarget_finrank]
  omega

end Kaplansky.Incidence

end

end OAI