import OAI.AlgebraicGeometry.CharacterVarieties.Foundation.VertexFrames

namespace OAI

noncomputable section
open scoped Classical Matrix

namespace IntegralCharacterVarieties.MatrixIso
open scoped Classical Matrix
variable {R : Type*} [CommRing R]
variable {α β γ : Type*} [Fintype α] [Fintype β] [Fintype γ]

@[simp] lemma linearEquiv_congr_apply (e : α ≃ β) (x : α → R) (j : β) :
    (congr (R:=R) e).linearEquiv x j = x (e.symm j) := by
  change ∑ i, ((1 : Matrix β β R) j (e i)) * x i = _
  have he (i : α) : (j=e i) ↔ (i=e.symm j) := by
    constructor
    · intro h; rw [h,e.symm_apply_apply]
    · intro h; rw [h,e.apply_symm_apply]
  simp [Matrix.one_apply,he]

@[simp] lemma linearEquiv_congr_symm_apply (e : α ≃ β) (x : β → R) (j : α) :
    (congr (R:=R) e).linearEquiv.symm x j = x (e j) := by
  change ∑ i, ((1 : Matrix β β R) (e j) i) * x i = _
  simp [Matrix.one_apply]

@[simp] lemma linearEquiv_trans_apply (f : MatrixIso R α β) (g : MatrixIso R β γ)
    (x : α → R) : (f.trans g).linearEquiv x=g.linearEquiv (f.linearEquiv x) := by
  change (g.val*f.val)*ᵥ x=g.val*ᵥ (f.val*ᵥ x)
  exact (Matrix.mulVec_mulVec _ _ _).symm

@[simp] lemma linearEquiv_diagonal_apply (u : α → Rˣ) (x : α → R) (j : α) :
    (diagonal u).linearEquiv x j=(u j : R)*x j := by
  change (Matrix.diagonal (fun i => (u i:R))*ᵥ x) j=_
  simp [Matrix.mulVec,Matrix.diagonal,dotProduct]

@[simp] lemma linearEquiv_trans_symm_apply (f : MatrixIso R α β) (g : MatrixIso R β γ)
    (x : γ → R) :
    (f.trans g).linearEquiv.symm x=f.linearEquiv.symm (g.linearEquiv.symm x) := by
  change (f.inv*g.inv)*ᵥ x=f.inv*ᵥ (g.inv*ᵥ x)
  exact (Matrix.mulVec_mulVec _ _ _).symm

@[simp] lemma linearEquiv_diagonal_symm_apply (u : α → Rˣ) (x : α → R) (j : α) :
    (diagonal u).linearEquiv.symm x j=(((u j)⁻¹ : Rˣ):R)*x j := by
  change (Matrix.diagonal (fun i => (((u i)⁻¹:Rˣ):R))*ᵥ x) j=_
  simp [Matrix.mulVec,Matrix.diagonal,dotProduct]

end IntegralCharacterVarieties.MatrixIso

namespace IntegralCharacterVarieties.MatrixIso
open scoped Classical Matrix
variable {R : Type*} [CommRing R]
variable {α β α' β' : Type*} [Fintype α] [Fintype β] [Fintype α'] [Fintype β']

@[simp] theorem linearEquiv_reindex (f : MatrixIso R α β) (a : α' ≃ α) (b : β' ≃ β)
    (x : α' → R) (j : β') :
    (f.reindex a b).linearEquiv x j=f.linearEquiv (fun i => x (a.symm i)) (b j) := by
  change (∑ i, f.val (b j) (a i)*x i)=∑ i,f.val (b j) i*x (a.symm i)
  rw [←a.sum_comp]
  simp only [Equiv.symm_apply_apply]

@[simp] theorem linearEquiv_sum_inl (f : MatrixIso R α β) (g : MatrixIso R α' β')
    (x : α ⊕ α' → R) (j : β) :
    (f.sum g).linearEquiv x (.inl j)=f.linearEquiv (fun i => x (.inl i)) j := by
  change ∑ i, (Matrix.fromBlocks f.val 0 0 g.val) (.inl j) i*x i=_
  rw [Fintype.sum_sum_type]
  simp [Matrix.fromBlocks,MatrixIso.linearEquiv,Matrix.toLin'_apply,Matrix.mulVec,dotProduct]

@[simp] theorem linearEquiv_sum_inr (f : MatrixIso R α β) (g : MatrixIso R α' β')
    (x : α ⊕ α' → R) (j : β') :
    (f.sum g).linearEquiv x (.inr j)=g.linearEquiv (fun i => x (.inr i)) j := by
  change ∑ i, (Matrix.fromBlocks f.val 0 0 g.val) (.inr j) i*x i=_
  rw [Fintype.sum_sum_type]
  simp [Matrix.fromBlocks,MatrixIso.linearEquiv,Matrix.toLin'_apply,Matrix.mulVec,dotProduct]
end IntegralCharacterVarieties.MatrixIso

namespace IntegralCharacterVarieties
variable {R V α : Type*} [CommRing R] [AddCommGroup V] [Module R V]
lemma mem_framedPrefix (grade : α → ℕ) (E : (α → R) ≃ₗ[R] V) (k : ℕ) (v : V) :
    v∈framedPrefix grade E k ↔ E.symm v∈coordinatePrefix R grade k := by
  exact Submodule.mem_map_equiv (coordinatePrefix R grade k) (e:=E) (x:=v)
end IntegralCharacterVarieties

namespace IntegralCharacterVarieties.OccurrenceIncidence.VertexTable.LocalRanks
open scoped Classical Matrix
variable {R : Type*} [CommRing R] {a b c : ℕ}
  (d : LocalRanks (.splitting a b c false))
local instance : Fintype (d.Columns .before) := d.fintypeColumns .before
local instance : Fintype (d.Columns .after) := d.fintypeColumns .after
local instance : Fintype (d.Columns .branch) := d.fintypeColumns .branch

def coarseW (v : d.Columns .before → R) (j : d.Parent .branch) : R :=
  v ⟨.inr (.inl ()),d.splitBranchParent.symm j⟩

def fineW (v : d.Columns .after → R) (j : d.Columns .branch) : R :=
  v ⟨.inr (.inl (d.splitBranchChildren.symm j).1),(d.splitBranchChildren.symm j).2⟩

variable (w : MatrixIso R (d.Columns .branch) (d.Parent .branch))

theorem refinement_coarseW (v : d.Columns .after → R) :
    d.coarseW ((d.splitRefinement w).linearEquiv v)=w.linearEquiv (d.fineW v) := by
  funext j
  simp only [coarseW,splitRefinement,MatrixIso.linearEquiv_reindex,
    splitBefore,Equiv.coe_fn_mk,MatrixIso.linearEquiv_sum_inr,
    MatrixIso.linearEquiv_sum_inl,Equiv.apply_symm_apply]
  rfl

theorem refinement_prefix (v : d.Columns .after → R) (j : d.SplitA false) :
    (d.splitRefinement w).linearEquiv v ⟨.inl j.1,j.2⟩=
      v ⟨.inl (d.splitPrefix.symm j).1,(d.splitPrefix.symm j).2⟩ := by
  simp only [splitRefinement,MatrixIso.linearEquiv_reindex,splitBefore,
    Equiv.coe_fn_mk,MatrixIso.linearEquiv_sum_inl,MatrixIso.linearEquiv_congr_apply]
  rfl

theorem refinement_suffix (v : d.Columns .after → R) (j : d.SplitC false) :
    (d.splitRefinement w).linearEquiv v ⟨.inr (.inr j.1),j.2⟩=
      v ⟨.inr (.inr (d.splitSuffix.symm j).1),(d.splitSuffix.symm j).2⟩ := by
  simp only [splitRefinement,MatrixIso.linearEquiv_reindex,splitBefore,
    Equiv.coe_fn_mk,MatrixIso.linearEquiv_sum_inr,MatrixIso.linearEquiv_congr_apply]
  rfl

/-- Source-order grades, not an arbitrary enumeration. -/
def beforeGrade (z : d.Columns .before) : ℕ :=
  ((Kind.splitting a b c false).childEnumeration .before z.1).val
def afterGrade (z : d.Columns .after) : ℕ :=
  ((Kind.splitting a b c false).childEnumeration .after z.1).val
def branchGrade (z : d.Columns .branch) : ℕ := z.1.val

@[simp] theorem beforeGrade_prefix (z : d.SplitA false) :
    d.beforeGrade ⟨.inl z.1,z.2⟩=z.1.val := rfl
@[simp] theorem beforeGrade_middle (z : d.SplitW) :
    d.beforeGrade ⟨.inr (.inl ()),z⟩=a := by
  change a+((_:Fin 1).val) = a
  omega
@[simp] theorem beforeGrade_suffix (z : d.SplitC false) :
    d.beforeGrade ⟨.inr (.inr z.1),z.2⟩=a+1+z.1.val := by
  change a+(1+z.1.val)=_
  omega
@[simp] theorem afterGrade_prefix (z : d.SplitA true) :
    d.afterGrade ⟨.inl z.1,z.2⟩=z.1.val := rfl
@[simp] theorem afterGrade_middle (z : d.SplitB) :
    d.afterGrade ⟨.inr (.inl z.1),z.2⟩=a+z.1.val := rfl
@[simp] theorem afterGrade_suffix (z : d.SplitC true) :
    d.afterGrade ⟨.inr (.inr z.1),z.2⟩=a+b+z.1.val := by
  change a+(b+z.1.val)=_
  omega


theorem current_iff (v : d.Columns .before → R) :
    v∈coordinatePrefix R d.beforeGrade (a+1) ↔
      ∀ z : d.SplitC false, v ⟨.inr (.inr z.1),z.2⟩=0 := by
  constructor
  · intro hv z
    apply hv
    rw [d.beforeGrade_suffix]
    omega
  · intro hv ⟨z,k⟩ hz
    rcases z with i|u|i
    · have hi := i.isLt
      change a+1 ≤ i.val at hz
      omega
    · cases u
      rw [d.beforeGrade_middle] at hz
      omega
    · exact hv ⟨i,k⟩

theorem afterPrefix_iff (v : d.Columns .after → R) (j : ℕ) (hj : j≤b) :
    v∈coordinatePrefix R d.afterGrade (a+j) ↔
      (∀ z : d.SplitC true, v ⟨.inr (.inr z.1),z.2⟩=0) ∧
      d.fineW v∈coordinatePrefix R d.branchGrade j := by
  constructor
  · intro hv
    constructor
    · intro z
      apply hv
      rw [d.afterGrade_suffix]
      omega
    · intro z hz
      apply hv
      rw [d.afterGrade_middle]
      change j≤z.1.val at hz
      change a+j≤a+z.1.val
      omega
  · rintro ⟨hC,hW⟩ ⟨z,k⟩ hz
    rcases z with i|i|i
    · have hi := i.isLt
      change a+j ≤ i.val at hz
      omega
    · have hh := hW (d.splitBranchChildren ⟨i,k⟩)
      change a+j ≤ a+i.val at hz
      apply hh
      change j ≤ i.val
      omega
    · exact hC ⟨i,k⟩

theorem refinement_current_iff (v : d.Columns .after → R) :
    (d.splitRefinement w).linearEquiv v∈coordinatePrefix R d.beforeGrade (a+1) ↔
      ∀ z : d.SplitC true, v ⟨.inr (.inr z.1),z.2⟩=0 := by
  rw [d.current_iff]
  simp only [d.refinement_suffix]
  constructor
  · intro h z
    specialize h (d.splitSuffix z)
    exact (congrArg (fun z : d.SplitC true => v ⟨.inr (.inr z.1),z.2⟩)
      (d.splitSuffix.symm_apply_apply z)).symm.trans h
  · intro h z
    exact h _

/-- At the split matrix, the refined interval flag is the inverse image of the additional seam flag
INSIDE the old coarse W interval. -/
theorem refinement_flag_iff (v : d.Columns .after → R) (j : ℕ) (hj : j≤b) :
    v∈coordinatePrefix R d.afterGrade (a+j) ↔
      (d.splitRefinement w).linearEquiv v∈coordinatePrefix R d.beforeGrade (a+1) ∧
      d.coarseW ((d.splitRefinement w).linearEquiv v)∈
        framedPrefix d.branchGrade w.linearEquiv j := by
  rw [d.afterPrefix_iff v j hj,d.refinement_current_iff]
  rw [d.refinement_coarseW]
  change _ ↔ _ ∧ w.linearEquiv (d.fineW v)∈
    (coordinatePrefix R d.branchGrade j).map w.linearEquiv.toLinearMap
  rw [Submodule.mem_map_equiv,LinearEquiv.symm_apply_apply]

variable (f : ∀ p,MatrixIso R (d.Columns p) (d.Parent p))

def beforeParentFrame : MatrixIso R (d.Columns .before) (d.Parent .after) :=
  (f .before).reindex (Equiv.refl _) d.splitParent

theorem rightFrame_eq :
    (d.splitComparison f).right=
      (d.splitRefinement (f .branch)).trans (d.beforeParentFrame f) := by
  apply MatrixIso.ext <;> rfl

theorem rightFrame_formula (v : d.Columns .after → R) :
    (d.splitComparison f).right.linearEquiv v=
      (d.beforeParentFrame f).linearEquiv ((d.splitRefinement (f .branch)).linearEquiv v) := by
  rw [d.rightFrame_eq f]
  exact MatrixIso.linearEquiv_trans_apply _ _ _

variable (h : (d.splitComparison f).Holds)

include h in
/-- The equality below is derived from the source comparison itself. -/
theorem old_refined_flag (v : d.Parent .after → R) (j : ℕ) (hj : j≤b) :
    v∈framedPrefix d.afterGrade (f .after).linearEquiv (a+j) ↔
      v∈framedPrefix d.beforeGrade (d.beforeParentFrame f).linearEquiv (a+1) ∧
      d.coarseW ((d.beforeParentFrame f).linearEquiv.symm v)∈
        framedPrefix d.branchGrade (f .branch).linearEquiv j := by
  have he := h.1 (a+j)
  change framedPrefix d.afterGrade (f .after).linearEquiv (a+j)=
    framedPrefix d.afterGrade (d.splitComparison f).right.linearEquiv (a+j) at he
  let x : d.Columns .after → R := (d.splitComparison f).right.linearEquiv.symm v
  have hx : (d.beforeParentFrame f).linearEquiv.symm v=
      (d.splitRefinement (f .branch)).linearEquiv x := by
    apply (d.beforeParentFrame f).linearEquiv.injective
    exact ((d.beforeParentFrame f).linearEquiv.apply_symm_apply v).trans
      (((d.splitComparison f).right.linearEquiv.apply_symm_apply v).symm.trans
        (d.rightFrame_formula f x))
  have hp := mem_framedPrefix d.afterGrade (d.splitComparison f).right.linearEquiv (a+j) v
  have hq := mem_framedPrefix d.beforeGrade (d.beforeParentFrame f).linearEquiv (a+1) v
  constructor
  · intro hv
    have hh := (d.refinement_flag_iff (f .branch) x j hj).mp (hp.mp (he ▸ hv))
    exact ⟨hq.mpr (hx.symm ▸ hh.1),hx.symm ▸ hh.2⟩
  · rintro ⟨hv,hw⟩
    have hh := (d.refinement_flag_iff (f .branch) x j hj).mpr
      ⟨hx ▸ hq.mp hv,hx ▸ hw⟩
    exact he.symm ▸ hp.mpr hh


def branchProjection : (d.Parent .after → R) →ₗ[R] (d.Parent .branch → R) where
  toFun v := d.coarseW ((d.beforeParentFrame f).linearEquiv.symm v)
  map_add' v z := by ext i; simp [coarseW]
  map_smul' t v := by ext i; simp [coarseW]


theorem right_branch_coordinates (v : d.Parent .after → R) :
    d.fineW ((d.splitComparison f).right.linearEquiv.symm v)=
      (f .branch).linearEquiv.symm (d.branchProjection f v) := by
  apply (f .branch).linearEquiv.injective
  rw [LinearEquiv.apply_symm_apply]
  let x : d.Columns .after → R := (d.splitComparison f).right.linearEquiv.symm v
  have hx : (d.beforeParentFrame f).linearEquiv.symm v=
      (d.splitRefinement (f .branch)).linearEquiv x := by
    apply (d.beforeParentFrame f).linearEquiv.injective
    exact ((d.beforeParentFrame f).linearEquiv.apply_symm_apply v).trans
      (((d.splitComparison f).right.linearEquiv.apply_symm_apply v).symm.trans
        (d.rightFrame_formula f x))
  exact (d.refinement_coarseW (f .branch) x).symm.trans
    (congrArg d.coarseW hx.symm)

include h in
/-- Every named fine quotient coordinate agrees with the old branch frame. This uses the GRADED
clause of the old vertex equation. -/
theorem old_branch_grade (z : d.Columns .branch) (v : d.Parent .after → R)
    (hv : v∈framedPrefix d.afterGrade (f .after).linearEquiv (a+z.1.val+1)) :
    d.fineW ((f .after).linearEquiv.symm v) z=
      (f .branch).linearEquiv.symm (d.branchProjection f v) z := by
  have hz : d.afterGrade
      ⟨.inr (.inl (d.splitBranchChildren.symm z).1),(d.splitBranchChildren.symm z).2⟩=
      a+z.1.val := rfl
  have hg := congrFun (h.2 (a+z.1.val) v hv)
    ⟨⟨.inr (.inl (d.splitBranchChildren.symm z).1),(d.splitBranchChildren.symm z).2⟩,hz⟩
  exact hg.trans (congrFun (d.right_branch_coordinates f v) z)

def branchSubsystem (U : Submodule R (d.Parent .after → R)) :
    Submodule R (d.Parent .branch → R) :=
  (U ⊓ framedPrefix d.beforeGrade (d.beforeParentFrame f).linearEquiv (a+1)).map
    (d.branchProjection f)

include h in
/-- The branch subsystem's entire fine flag is obtained from the old U intersection flag, in the
named additional-seam module. -/
theorem old_branch_intersections (U : Submodule R (d.Parent .after → R))
    (j : ℕ) (hj : j≤b) :
    (U ⊓ framedPrefix d.afterGrade (f .after).linearEquiv (a+j)).map
        (d.branchProjection f)=
      d.branchSubsystem f U ⊓ framedPrefix d.branchGrade (f .branch).linearEquiv j := by
  ext z
  constructor
  · rintro ⟨v,⟨hU,hv⟩,rfl⟩
    have hh := (d.old_refined_flag f h v j hj).mp hv
    exact ⟨⟨v,⟨hU,hh.1⟩,rfl⟩,hh.2⟩
  · rintro ⟨⟨v,⟨hU,hv⟩,rfl⟩,hz⟩
    exact ⟨v,⟨hU,(d.old_refined_flag f h v j hj).mpr ⟨hv,hz⟩⟩,rfl⟩

/-- The output records the exact source prefix criterion together with all U intersection images,
rather than only relative-position dimensions. -/
def HasOldSplit : Prop :=
  (∀ (v : d.Parent .after → R) (j : ℕ), j≤b →
    (v∈framedPrefix d.afterGrade (f .after).linearEquiv (a+j) ↔
      v∈framedPrefix d.beforeGrade (d.beforeParentFrame f).linearEquiv (a+1) ∧
      d.branchProjection f v∈framedPrefix d.branchGrade (f .branch).linearEquiv j)) ∧
  (∀ (U : Submodule R (d.Parent .after → R)) (j : ℕ), j≤b →
    (U ⊓ framedPrefix d.afterGrade (f .after).linearEquiv (a+j)).map
        (d.branchProjection f)=
      d.branchSubsystem f U ⊓ framedPrefix d.branchGrade (f .branch).linearEquiv j) ∧
  ∀ (z : d.Columns .branch) (v : d.Parent .after → R),
    v∈framedPrefix d.afterGrade (f .after).linearEquiv (a+z.1.val+1) →
    d.fineW ((f .after).linearEquiv.symm v) z=
      (f .branch).linearEquiv.symm (d.branchProjection f v) z

include h in
theorem old_split_flags : d.HasOldSplit f :=
  ⟨d.old_refined_flag f h,d.old_branch_intersections f h,d.old_branch_grade f h⟩

def OldSplitExtracted (R : Type*) [CommRing R] : (k : Kind) → (d : LocalRanks k) →
    (∀ p, MatrixIso R (d.Columns p) (d.Parent p)) → Prop
  | .passage _ _,_,_ => True
  | .splitting _ _ _ false,d,f => d.HasOldSplit f
  | .splitting _ _ _ true,d,f => d.forwardRanks.HasOldSplit f

theorem comparison_oldSplit {k : Kind} (d : LocalRanks k)
    (f : ∀ p,MatrixIso R (d.Columns p) (d.Parent p))
    (h : (comparison k d f).Holds) : OldSplitExtracted R k d f := by
  cases k with
  | passage _ _ => trivial
  | splitting a b c r =>
    cases r with
    | false => exact d.old_split_flags f h
    | true => exact d.forwardRanks.old_split_flags f h

end IntegralCharacterVarieties.OccurrenceIncidence.VertexTable.LocalRanks

namespace IntegralCharacterVarieties.SurfacePresentation.Diagram
open OccurrenceIncidence VertexTable
variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A] [Algebra R A]
  (D : Diagram F S V arity) (P : D.Punctures R) (g : D.Solution P A)

/-- The split/merge extraction follows from the entire old solution. -/
theorem oldSplit_extraction (v : V) :
    LocalRanks.OldSplitExtracted A (D.ports.kind v) (D.vertexRanks v)
      (fun p => D.portFrame g.val.val ⟨v,p⟩) :=
  LocalRanks.comparison_oldSplit (D.vertexRanks v)
    (fun p => D.portFrame g.val.val ⟨v,p⟩) (g.property v)
end IntegralCharacterVarieties.SurfacePresentation.Diagram

end

end OAI