Sync from openai/math@faee2cf485a8 (part 23)

lean/OAI/RepresentationTheory/RestrictedTilting/FormalAssociatedAction.lean

@@ -1,77 +1,77 @@
-import OAI.RepresentationTheory.RestrictedTilting.FormalSectionAction
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedPlaneJet
-import OAI.RepresentationTheory.RestrictedTilting.NumeratorAction
-import OAI.RepresentationTheory.RestrictedTilting.CompletionCoefficients
-import OAI.RepresentationTheory.RestrictedTilting.CompletedCoordinates
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory
-open scoped TensorProduct BigOperators Pointwise
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-variable (P : Matrix ι ι (Polynomial k))
-variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
-local notation "N" => associatedSectionsSubmodule k ι ρ
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
-local notation "σ" => associatedSectionsRepresentation k ι ρ
-local notation "hσ" => associatedSections_planeCompatible k ι ρ
-local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
-variable [Module.Finite k ((associatedSectionsSubmodule k ι ρ) ⧸
-  planeJetRelation (M := associatedSectionsSubmodule k ι ρ) k 1)]
-local notation "T" => planeJetFD k σ hσ 1
-
-noncomputable def formalAssociatedCoordinates
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) (v : T) :
-    ι → planeCompletion k := completedCoordinates I W (formalPlaneSection k σ hσ s hs v)
-
-omit [Infinite k] in
-lemma linePolynomial_cleared (p : Polynomial k) (t : k) (d : ℕ) :
-    linePolynomial k (clearedPolynomial p (MvPolynomial.C t) ((MvPolynomial.X 0 : A)^2) d) =
-      clearedLineAction k p t d := by
-  rw [map_clearedPolynomial]
-  simp [linePolynomial, clearedLineAction]
-
-omit [Infinite k] in
-lemma formalLineMap_cleared (p : Polynomial k) (t : k) (d : ℕ) :
-    formalLineMap k (algebraMap A (planeCompletion k)
-      (clearedPolynomial p (MvPolynomial.C t) ((MvPolynomial.X 0 : A)^2) d)) =
-      clearedPolynomial p (algebraMap k (PowerSeries k) t) ((PowerSeries.X : PowerSeries k)^2) d := by
-  change formalLineMap k ((IsScalarTower.toAlgHom k A (planeCompletion k)) _) = _
-  rw [map_clearedPolynomial, map_clearedPolynomial]
-  simp only [IsScalarTower.toAlgHom_apply, map_pow, formalLineMap_X]
-  congr 1
-  rw [MvPolynomial.C_eq_algebraMap, ← IsScalarTower.algebraMap_apply,
-    AlgHom.commutes]
-
-lemma formalAssociatedCoordinates_unipotent
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (t : k) (v : T) (i : ι) :
-    (PowerSeries.X : PowerSeries k)^(2*d) * formalLineMap k
-      (formalAssociatedCoordinates k ι ρ P hP d hd s hs ((planeJetFD k σ hσ 1).ρ (unipotent k t) v) i) =
-      ∑ j, clearedPolynomial (P i j) (algebraMap k (PowerSeries k) t)
-        ((PowerSeries.X : PowerSeries k)^2) d * formalLineMap k
-          (formalAssociatedCoordinates k ι ρ P hP d hd s hs v j) := by
-  let F : N →ₗ[A] A := (MvPolynomial.X 0 : A)^(2*d) • (LinearMap.proj i).comp W
-  let G : N →ₗ[A] A := ∑ j, clearedPolynomial (P i j) (MvPolynomial.C t)
-    ((MvPolynomial.X 0 : A)^2) d • (LinearMap.proj j).comp W
-  have he : ∀ f : N, linePolynomial k (F (σ (unipotent k t) f)) = linePolynomial k (G f) := by
-    intro f
-    simpa only [F,G,LinearMap.smul_apply,LinearMap.sum_apply,LinearMap.comp_apply,
-      LinearMap.proj_apply,smul_eq_mul,map_mul,map_pow,map_sum,
-      show linePolynomial k (MvPolynomial.X 0) = Polynomial.X from by simp [linePolynomial],
-      linePolynomial_cleared] using associatedNumerator_line_unipotent k ι ρ P hP d hd t f i
-  have h := formalPlaneSection_line_action k σ hσ s hs (unipotent k t) F G he v
-  simp only [F,G,completion_map_smul, LinearMap.sum_apply, completion_self_smul, map_mul, map_sum,
-    map_pow, formalLineMap_X, formalLineMap_cleared] at h
-  simpa only [formalAssociatedCoordinates, completedCoordinates_apply] using h
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.FormalSectionAction
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedPlaneJet
+import OAI.RepresentationTheory.RestrictedTilting.NumeratorAction
+import OAI.RepresentationTheory.RestrictedTilting.CompletionCoefficients
+import OAI.RepresentationTheory.RestrictedTilting.CompletedCoordinates
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory
+open scoped TensorProduct BigOperators Pointwise
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+variable (P : Matrix ι ι (Polynomial k))
+variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
+local notation "N" => associatedSectionsSubmodule k ι ρ
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
+local notation "σ" => associatedSectionsRepresentation k ι ρ
+local notation "hσ" => associatedSections_planeCompatible k ι ρ
+local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
+variable [Module.Finite k ((associatedSectionsSubmodule k ι ρ) ⧸
+  planeJetRelation (M := associatedSectionsSubmodule k ι ρ) k 1)]
+local notation "T" => planeJetFD k σ hσ 1
+
+noncomputable def formalAssociatedCoordinates
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) (v : T) :
+    ι → planeCompletion k := completedCoordinates I W (formalPlaneSection k σ hσ s hs v)
+
+omit [Infinite k] in
+lemma linePolynomial_cleared (p : Polynomial k) (t : k) (d : ℕ) :
+    linePolynomial k (clearedPolynomial p (MvPolynomial.C t) ((MvPolynomial.X 0 : A)^2) d) =
+      clearedLineAction k p t d := by
+  rw [map_clearedPolynomial]
+  simp [linePolynomial, clearedLineAction]
+
+omit [Infinite k] in
+lemma formalLineMap_cleared (p : Polynomial k) (t : k) (d : ℕ) :
+    formalLineMap k (algebraMap A (planeCompletion k)
+      (clearedPolynomial p (MvPolynomial.C t) ((MvPolynomial.X 0 : A)^2) d)) =
+      clearedPolynomial p (algebraMap k (PowerSeries k) t) ((PowerSeries.X : PowerSeries k)^2) d := by
+  change formalLineMap k ((IsScalarTower.toAlgHom k A (planeCompletion k)) _) = _
+  rw [map_clearedPolynomial, map_clearedPolynomial]
+  simp only [IsScalarTower.toAlgHom_apply, map_pow, formalLineMap_X]
+  congr 1
+  rw [MvPolynomial.C_eq_algebraMap, ← IsScalarTower.algebraMap_apply,
+    AlgHom.commutes]
+
+lemma formalAssociatedCoordinates_unipotent
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (t : k) (v : T) (i : ι) :
+    (PowerSeries.X : PowerSeries k)^(2*d) * formalLineMap k
+      (formalAssociatedCoordinates k ι ρ P hP d hd s hs ((planeJetFD k σ hσ 1).ρ (unipotent k t) v) i) =
+      ∑ j, clearedPolynomial (P i j) (algebraMap k (PowerSeries k) t)
+        ((PowerSeries.X : PowerSeries k)^2) d * formalLineMap k
+          (formalAssociatedCoordinates k ι ρ P hP d hd s hs v j) := by
+  let F : N →ₗ[A] A := (MvPolynomial.X 0 : A)^(2*d) • (LinearMap.proj i).comp W
+  let G : N →ₗ[A] A := ∑ j, clearedPolynomial (P i j) (MvPolynomial.C t)
+    ((MvPolynomial.X 0 : A)^2) d • (LinearMap.proj j).comp W
+  have he : ∀ f : N, linePolynomial k (F (σ (unipotent k t) f)) = linePolynomial k (G f) := by
+    intro f
+    simpa only [F,G,LinearMap.smul_apply,LinearMap.sum_apply,LinearMap.comp_apply,
+      LinearMap.proj_apply,smul_eq_mul,map_mul,map_pow,map_sum,
+      show linePolynomial k (MvPolynomial.X 0) = Polynomial.X from by simp [linePolynomial],
+      linePolynomial_cleared] using associatedNumerator_line_unipotent k ι ρ P hP d hd t f i
+  have h := formalPlaneSection_line_action k σ hσ s hs (unipotent k t) F G he v
+  simp only [F,G,completion_map_smul, LinearMap.sum_apply, completion_self_smul, map_mul, map_sum,
+    map_pow, formalLineMap_X, formalLineMap_cleared] at h
+  simpa only [formalAssociatedCoordinates, completedCoordinates_apply] using h
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FormalAssociatedIso.lean

@@ -1,100 +1,100 @@
-import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedAction
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory Matrix
-open scoped TensorProduct BigOperators Pointwise
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-attribute [local instance 1100] HahnSeries.instAlgebra
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-variable (P : Matrix ι ι (Polynomial k))
-variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
-local notation "N" => associatedSectionsSubmodule k ι ρ
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
-local notation "H" => planeCompletion k
-local notation "K" => LaurentSeries k
-local notation "σ" => associatedSectionsRepresentation k ι ρ
-local notation "hσ" => associatedSections_planeCompatible k ι ρ
-local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
-local notation "Z" => associatedDenominatorLinear k ι ρ P hP d hd
-local notation "hx" => And.left (associatedSections_regular k ι ρ P hP)
-local notation "hy" => And.right (associatedSections_regular k ι ρ P hP)
-variable [Module.Finite k ((associatedSectionsSubmodule k ι ρ) ⧸
-  planeJetRelation (M := associatedSectionsSubmodule k ι ρ) k 1)]
-local notation "T" => planeJetFD k σ hσ 1
-
-omit [Infinite k] in
-lemma ofPowerSeriesAlg_apply_eq (f : PowerSeries k) :
-    (HahnSeries.ofPowerSeriesAlg ℤ k) f = HahnSeries.ofPowerSeries ℤ k f := rfl
-
-noncomputable def formalLineParameter : K :=
-  HahnSeries.ofPowerSeries ℤ k PowerSeries.X
-
-omit [Infinite k] in
-lemma formalLineParameter_ne_zero : formalLineParameter k ≠ 0 := by
-  intro hz
-  apply PowerSeries.X_ne_zero (R := k)
-  exact HahnSeries.ofPowerSeries_injective (hz.trans (map_zero _).symm)
-
-noncomputable def associatedFieldTrivialization
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) : (K ⊗[k] T) ≃ₗ[K] (ι → K) := by
-  letI : Algebra H K := (formalLineFieldMap k).toRingHom.toAlgebra
-  exact fieldCoordinateTrivialization (formalPlaneTrivialization k σ hσ s hs0 hs hx hy)
-    (completedCoordinates I W) (completedDenominator I Z)
-    (algebraMap A H ((MvPolynomial.X 0)^ (d+d)))
-    (completedCoordinates_denominator I W Z _ (associatedNumerator_denominator k ι ρ P hP d hd))
-    (completedDenominator_coordinates I W Z _ (associatedDenominator_numerator k ι ρ P hP d hd))
-    (by
-      change formalLineFieldMap k (algebraMap A H ((MvPolynomial.X 0)^(d+d))) ≠ 0
-      rw [map_pow, map_pow]
-      exact pow_ne_zero _ (formalLineFieldMap_X_ne_zero k))
-
-lemma associatedFieldTrivialization_one
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (v : T) (i : ι) :
-    associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs (1 ⊗ₜ[k] v) i =
-      HahnSeries.ofPowerSeries ℤ k
-        (formalLineMap k (formalAssociatedCoordinates k ι ρ P hP d hd s hs v i)) := by
-  let : Algebra H K := (formalLineFieldMap k).toRingHom.toAlgebra
-  dsimp only [associatedFieldTrivialization]
-  rw [fieldCoordinateTrivialization_one, formalPlaneTrivialization_one_tmul]
-  rfl
-
-lemma associatedFieldTrivialization_unipotent_one
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (t : k) (v : T) :
-    associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs
-      (1 ⊗ₜ[k] ((planeJetFD k σ hσ 1).ρ (unipotent k t) v)) =
-      polynomialMatrixEval P (algebraMap k K t / (formalLineParameter k)^2) *ᵥ
-        associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs (1 ⊗ₜ[k] v) := by
-  apply funext
-  intro i
-  have he := congrArg (HahnSeries.ofPowerSeriesAlg ℤ k)
-    (formalAssociatedCoordinates_unipotent k ι ρ P hP d hd s hs t v i)
-  simp only [map_mul, map_pow, map_sum] at he
-  have hc (j : ι) : (HahnSeries.ofPowerSeriesAlg ℤ k)
-      (clearedPolynomial (P i j) (algebraMap k (PowerSeries k) t)
-        ((PowerSeries.X : PowerSeries k)^2) d) =
-      (formalLineParameter k)^(2*d) *
-        Polynomial.aeval (algebraMap k K t / (formalLineParameter k)^2) (P i j) := by
-    have hc := clearedPolynomial_eval (HahnSeries.ofPowerSeriesAlg ℤ k) (P i j)
-      (algebraMap k (PowerSeries k) t) ((PowerSeries.X : PowerSeries k)^2) d (hd i j)
-      (by
-        rw [map_pow]
-        exact pow_ne_zero 2 (formalLineParameter_ne_zero k))
-    simpa only [map_pow, AlgHom.commutes, ofPowerSeriesAlg_apply_eq, formalLineParameter, ← pow_mul, div_eq_mul_inv] using hc
-  simp only [hc, mul_assoc, ← Finset.mul_sum] at he
-  apply mul_left_cancel₀ (pow_ne_zero (2*d) (formalLineParameter_ne_zero k))
-  simpa only [associatedFieldTrivialization_one, Matrix.mulVec, dotProduct, polynomialMatrixEval,
-    formalLineParameter, ofPowerSeriesAlg_apply_eq] using he
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedAction
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory Matrix
+open scoped TensorProduct BigOperators Pointwise
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+attribute [local instance 1100] HahnSeries.instAlgebra
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+variable (P : Matrix ι ι (Polynomial k))
+variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
+local notation "N" => associatedSectionsSubmodule k ι ρ
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
+local notation "H" => planeCompletion k
+local notation "K" => LaurentSeries k
+local notation "σ" => associatedSectionsRepresentation k ι ρ
+local notation "hσ" => associatedSections_planeCompatible k ι ρ
+local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
+local notation "Z" => associatedDenominatorLinear k ι ρ P hP d hd
+local notation "hx" => And.left (associatedSections_regular k ι ρ P hP)
+local notation "hy" => And.right (associatedSections_regular k ι ρ P hP)
+variable [Module.Finite k ((associatedSectionsSubmodule k ι ρ) ⧸
+  planeJetRelation (M := associatedSectionsSubmodule k ι ρ) k 1)]
+local notation "T" => planeJetFD k σ hσ 1
+
+omit [Infinite k] in
+lemma ofPowerSeriesAlg_apply_eq (f : PowerSeries k) :
+    (HahnSeries.ofPowerSeriesAlg ℤ k) f = HahnSeries.ofPowerSeries ℤ k f := rfl
+
+noncomputable def formalLineParameter : K :=
+  HahnSeries.ofPowerSeries ℤ k PowerSeries.X
+
+omit [Infinite k] in
+lemma formalLineParameter_ne_zero : formalLineParameter k ≠ 0 := by
+  intro hz
+  apply PowerSeries.X_ne_zero (R := k)
+  exact HahnSeries.ofPowerSeries_injective (hz.trans (map_zero _).symm)
+
+noncomputable def associatedFieldTrivialization
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) : (K ⊗[k] T) ≃ₗ[K] (ι → K) := by
+  letI : Algebra H K := (formalLineFieldMap k).toRingHom.toAlgebra
+  exact fieldCoordinateTrivialization (formalPlaneTrivialization k σ hσ s hs0 hs hx hy)
+    (completedCoordinates I W) (completedDenominator I Z)
+    (algebraMap A H ((MvPolynomial.X 0)^ (d+d)))
+    (completedCoordinates_denominator I W Z _ (associatedNumerator_denominator k ι ρ P hP d hd))
+    (completedDenominator_coordinates I W Z _ (associatedDenominator_numerator k ι ρ P hP d hd))
+    (by
+      change formalLineFieldMap k (algebraMap A H ((MvPolynomial.X 0)^(d+d))) ≠ 0
+      rw [map_pow, map_pow]
+      exact pow_ne_zero _ (formalLineFieldMap_X_ne_zero k))
+
+lemma associatedFieldTrivialization_one
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (v : T) (i : ι) :
+    associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs (1 ⊗ₜ[k] v) i =
+      HahnSeries.ofPowerSeries ℤ k
+        (formalLineMap k (formalAssociatedCoordinates k ι ρ P hP d hd s hs v i)) := by
+  let : Algebra H K := (formalLineFieldMap k).toRingHom.toAlgebra
+  dsimp only [associatedFieldTrivialization]
+  rw [fieldCoordinateTrivialization_one, formalPlaneTrivialization_one_tmul]
+  rfl
+
+lemma associatedFieldTrivialization_unipotent_one
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (t : k) (v : T) :
+    associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs
+      (1 ⊗ₜ[k] ((planeJetFD k σ hσ 1).ρ (unipotent k t) v)) =
+      polynomialMatrixEval P (algebraMap k K t / (formalLineParameter k)^2) *ᵥ
+        associatedFieldTrivialization k ι ρ P hP d hd s hs0 hs (1 ⊗ₜ[k] v) := by
+  apply funext
+  intro i
+  have he := congrArg (HahnSeries.ofPowerSeriesAlg ℤ k)
+    (formalAssociatedCoordinates_unipotent k ι ρ P hP d hd s hs t v i)
+  simp only [map_mul, map_pow, map_sum] at he
+  have hc (j : ι) : (HahnSeries.ofPowerSeriesAlg ℤ k)
+      (clearedPolynomial (P i j) (algebraMap k (PowerSeries k) t)
+        ((PowerSeries.X : PowerSeries k)^2) d) =
+      (formalLineParameter k)^(2*d) *
+        Polynomial.aeval (algebraMap k K t / (formalLineParameter k)^2) (P i j) := by
+    have hc := clearedPolynomial_eval (HahnSeries.ofPowerSeriesAlg ℤ k) (P i j)
+      (algebraMap k (PowerSeries k) t) ((PowerSeries.X : PowerSeries k)^2) d (hd i j)
+      (by
+        rw [map_pow]
+        exact pow_ne_zero 2 (formalLineParameter_ne_zero k))
+    simpa only [map_pow, AlgHom.commutes, ofPowerSeriesAlg_apply_eq, formalLineParameter, ← pow_mul, div_eq_mul_inv] using hc
+  simp only [hc, mul_assoc, ← Finset.mul_sum] at he
+  apply mul_left_cancel₀ (pow_ne_zero (2*d) (formalLineParameter_ne_zero k))
+  simpa only [associatedFieldTrivialization_one, Matrix.mulVec, dotProduct, polynomialMatrixEval,
+    formalLineParameter, ofPowerSeriesAlg_apply_eq] using he
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FormalLine.lean

@@ -1,92 +1,92 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped TensorProduct
-universe u
-variable (k : Type u) [Field k]
-attribute [local instance 1100] HahnSeries.instAlgebra
-
-abbrev planeCompletion := AdicCompletion (MvPolynomial.idealOfVars (Fin 2) k)
-  (MvPolynomial (Fin 2) k)
-
- 
-def formalLineEmbedding : Unit ↪ Fin 2 := ⟨fun _ => 0, fun a b _ => Subsingleton.elim a b⟩
-
-noncomputable def formalLineMap : planeCompletion k →ₐ[k] PowerSeries k :=
-  (MvPowerSeries.killCompl (formalLineEmbedding)).comp
-    ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm.restrictScalars k).toAlgHom
-
- 
-
-noncomputable def formalLineFieldMap : planeCompletion k →ₐ[k] LaurentSeries k :=
-  (HahnSeries.ofPowerSeriesAlg ℤ k).comp (formalLineMap k)
-
-lemma formalLineMap_poly :
-    (formalLineMap k).comp (IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeCompletion k)) =
-    MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then (PowerSeries.X : PowerSeries k) else 0) := by
-  ext i : 1
-  change MvPowerSeries.killCompl (formalLineEmbedding)
-    ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm
-      (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X i))) = _
-  rw [AlgEquiv.commutes]
-  rw [MvPowerSeries.algebraMap_apply', MvPolynomial.coe_X, MvPowerSeries.map_X]
-  fin_cases i
-  · simp only [MvPolynomial.aeval_X]
-    change MvPowerSeries.killCompl (R := k) formalLineEmbedding (MvPowerSeries.X 0) = PowerSeries.X
-    exact MvPowerSeries.killCompl_X (R := k) (e := formalLineEmbedding) ()
-  · rw [MvPowerSeries.killCompl_X_eq_zero]
-    · simp
-    · rintro ⟨u,hu⟩
-      exact Fin.zero_ne_one (show (0 : Fin 2) = 1 from hu)
-
-@[simp] lemma formalLineMap_of (P : MvPolynomial (Fin 2) k) :
-    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) P) =
-      MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then (PowerSeries.X : PowerSeries k) else 0) P :=
-  congrArg (fun f : MvPolynomial (Fin 2) k →ₐ[k] PowerSeries k => f P) (formalLineMap_poly k)
-
-@[simp] lemma formalLineMap_X :
-    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X 0)) =
-      PowerSeries.X := by simp
-
-@[simp] lemma formalLineMap_Y :
-    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X 1)) = 0 := by
-  simp
-
-lemma formalLineFieldMap_X_ne_zero :
-    formalLineFieldMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k)
-      (MvPolynomial.X 0)) ≠ 0 := by
-  change HahnSeries.ofPowerSeries ℤ k (formalLineMap k _) ≠ 0
-  rw [formalLineMap_X]
-  intro hz
-  apply PowerSeries.X_ne_zero (R := k)
-  exact (HahnSeries.ofPowerSeries_injective (Γ := ℤ) (R := k))
-    (hz.trans (map_zero _).symm)
-
- 
-
-lemma formalLineMap_coeff_eq (n : ℕ) (x y : planeCompletion k)
-    (h : x.val (n+1) = y.val (n+1)) :
-    PowerSeries.coeff n (formalLineMap k x) = PowerSeries.coeff n (formalLineMap k y) := by
-  change MvPowerSeries.coeff (Finsupp.single () n)
-      (MvPowerSeries.killCompl (formalLineEmbedding) ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm x)) =
-    MvPowerSeries.coeff (Finsupp.single () n)
-      (MvPowerSeries.killCompl (formalLineEmbedding) ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm y))
-  simp only [MvPowerSeries.coeff_killCompl, Finsupp.embDomain_single]
-  change MvPowerSeries.coeff (Finsupp.single (0 : Fin 2) n)
-      ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm x) =
-    MvPowerSeries.coeff (Finsupp.single (0 : Fin 2) n)
-      ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm y)
-  simp only [MvPowerSeries.toAdicCompletionAlgEquiv_symm_apply,
-    MvPowerSeries.coeff_toAdicCompletionInv]
-  apply congrArg (fun polynomial : MvPolynomial (Fin 2) k =>
-    polynomial.coeff (Finsupp.single (0 : Fin 2) n))
-  have h' : x.val ((Finsupp.single (0 : Fin 2) n).degree + 1) =
-      y.val ((Finsupp.single (0 : Fin 2) n).degree + 1) := by
-    rw [Finsupp.degree_single]
-    exact h
-  exact congrArg Quotient.out h'
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped TensorProduct
+universe u
+variable (k : Type u) [Field k]
+attribute [local instance 1100] HahnSeries.instAlgebra
+
+abbrev planeCompletion := AdicCompletion (MvPolynomial.idealOfVars (Fin 2) k)
+  (MvPolynomial (Fin 2) k)
+
+ 
+def formalLineEmbedding : Unit ↪ Fin 2 := ⟨fun _ => 0, fun a b _ => Subsingleton.elim a b⟩
+
+noncomputable def formalLineMap : planeCompletion k →ₐ[k] PowerSeries k :=
+  (MvPowerSeries.killCompl (formalLineEmbedding)).comp
+    ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm.restrictScalars k).toAlgHom
+
+ 
+
+noncomputable def formalLineFieldMap : planeCompletion k →ₐ[k] LaurentSeries k :=
+  (HahnSeries.ofPowerSeriesAlg ℤ k).comp (formalLineMap k)
+
+lemma formalLineMap_poly :
+    (formalLineMap k).comp (IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeCompletion k)) =
+    MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then (PowerSeries.X : PowerSeries k) else 0) := by
+  ext i : 1
+  change MvPowerSeries.killCompl (formalLineEmbedding)
+    ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm
+      (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X i))) = _
+  rw [AlgEquiv.commutes]
+  rw [MvPowerSeries.algebraMap_apply', MvPolynomial.coe_X, MvPowerSeries.map_X]
+  fin_cases i
+  · simp only [MvPolynomial.aeval_X]
+    change MvPowerSeries.killCompl (R := k) formalLineEmbedding (MvPowerSeries.X 0) = PowerSeries.X
+    exact MvPowerSeries.killCompl_X (R := k) (e := formalLineEmbedding) ()
+  · rw [MvPowerSeries.killCompl_X_eq_zero]
+    · simp
+    · rintro ⟨u,hu⟩
+      exact Fin.zero_ne_one (show (0 : Fin 2) = 1 from hu)
+
+@[simp] lemma formalLineMap_of (P : MvPolynomial (Fin 2) k) :
+    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) P) =
+      MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then (PowerSeries.X : PowerSeries k) else 0) P :=
+  congrArg (fun f : MvPolynomial (Fin 2) k →ₐ[k] PowerSeries k => f P) (formalLineMap_poly k)
+
+@[simp] lemma formalLineMap_X :
+    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X 0)) =
+      PowerSeries.X := by simp
+
+@[simp] lemma formalLineMap_Y :
+    formalLineMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k) (MvPolynomial.X 1)) = 0 := by
+  simp
+
+lemma formalLineFieldMap_X_ne_zero :
+    formalLineFieldMap k (algebraMap (MvPolynomial (Fin 2) k) (planeCompletion k)
+      (MvPolynomial.X 0)) ≠ 0 := by
+  change HahnSeries.ofPowerSeries ℤ k (formalLineMap k _) ≠ 0
+  rw [formalLineMap_X]
+  intro hz
+  apply PowerSeries.X_ne_zero (R := k)
+  exact (HahnSeries.ofPowerSeries_injective (Γ := ℤ) (R := k))
+    (hz.trans (map_zero _).symm)
+
+ 
+
+lemma formalLineMap_coeff_eq (n : ℕ) (x y : planeCompletion k)
+    (h : x.val (n+1) = y.val (n+1)) :
+    PowerSeries.coeff n (formalLineMap k x) = PowerSeries.coeff n (formalLineMap k y) := by
+  change MvPowerSeries.coeff (Finsupp.single () n)
+      (MvPowerSeries.killCompl (formalLineEmbedding) ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm x)) =
+    MvPowerSeries.coeff (Finsupp.single () n)
+      (MvPowerSeries.killCompl (formalLineEmbedding) ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm y))
+  simp only [MvPowerSeries.coeff_killCompl, Finsupp.embDomain_single]
+  change MvPowerSeries.coeff (Finsupp.single (0 : Fin 2) n)
+      ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm x) =
+    MvPowerSeries.coeff (Finsupp.single (0 : Fin 2) n)
+      ((MvPowerSeries.toAdicCompletionAlgEquiv (Fin 2) k).symm y)
+  simp only [MvPowerSeries.toAdicCompletionAlgEquiv_symm_apply,
+    MvPowerSeries.coeff_toAdicCompletionInv]
+  apply congrArg (fun polynomial : MvPolynomial (Fin 2) k =>
+    polynomial.coeff (Finsupp.single (0 : Fin 2) n))
+  have h' : x.val ((Finsupp.single (0 : Fin 2) n).degree + 1) =
+      y.val ((Finsupp.single (0 : Fin 2) n).degree + 1) := by
+    rw [Finsupp.degree_single]
+    exact h
+  exact congrArg Quotient.out h'
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FormalLineContinuity.lean

@@ -1,50 +1,50 @@
-import OAI.RepresentationTheory.RestrictedTilting.FormalLine
-import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
-
-namespace OAI
-
-namespace FiberFunctorProof
-universe u
-variable (k : Type u) [Field k]
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
-
-lemma formalLineMap_of_linePolynomial (P : A) :
-    formalLineMap k (AdicCompletion.of I A P) =
-      Polynomial.aeval (PowerSeries.X : PowerSeries k) (linePolynomial k P) := by
-  change formalLineMap k (algebraMap A (planeCompletion k) P) = _
-  rw [formalLineMap_of]
-  have he : (Polynomial.aeval (PowerSeries.X : PowerSeries k)).comp (linePolynomial k) =
-      MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then PowerSeries.X else 0) := by
-    ext i
-    simp only [AlgHom.comp_apply, linePolynomial, MvPolynomial.aeval_X]
-    split_ifs <;> simp
-  exact congrArg (fun f : A →ₐ[k] PowerSeries k => f P) he.symm
-
-variable {M : Type u} [AddCommGroup M] [Module (MvPolynomial (Fin 2) k) M]
-
- 
-
-lemma formalLine_map_eq_of_representatives
-    (F G : M →ₗ[A] A) (x y : AdicCompletion I M)
-    (h : ∀ n : ℕ, ∃ v w : M,
-      x.val (n+1) = (AdicCompletion.of I M v).val (n+1) ∧
-      y.val (n+1) = (AdicCompletion.of I M w).val (n+1) ∧
-      linePolynomial k (F v) = linePolynomial k (G w)) :
-    formalLineMap k (AdicCompletion.map I F x) =
-      formalLineMap k (AdicCompletion.map I G y) := by
-  ext n
-  obtain ⟨v,w,hv,hw,he⟩ := h n
-  have hF : (AdicCompletion.map I F x).val (n+1) =
-      (AdicCompletion.of I A (F v)).val (n+1) := by
-    rw [← AdicCompletion.map_of]
-    simp only [AdicCompletion.map_val_apply, hv]
-  have hG : (AdicCompletion.map I G y).val (n+1) =
-      (AdicCompletion.of I A (G w)).val (n+1) := by
-    rw [← AdicCompletion.map_of]
-    simp only [AdicCompletion.map_val_apply, hw]
-  rw [formalLineMap_coeff_eq k n _ _ hF, formalLineMap_coeff_eq k n _ _ hG,
-    formalLineMap_of_linePolynomial, formalLineMap_of_linePolynomial, he]
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.FormalLine
+import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
+
+namespace OAI
+
+namespace FiberFunctorProof
+universe u
+variable (k : Type u) [Field k]
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
+
+lemma formalLineMap_of_linePolynomial (P : A) :
+    formalLineMap k (AdicCompletion.of I A P) =
+      Polynomial.aeval (PowerSeries.X : PowerSeries k) (linePolynomial k P) := by
+  change formalLineMap k (algebraMap A (planeCompletion k) P) = _
+  rw [formalLineMap_of]
+  have he : (Polynomial.aeval (PowerSeries.X : PowerSeries k)).comp (linePolynomial k) =
+      MvPolynomial.aeval (fun i : Fin 2 => if i = 0 then PowerSeries.X else 0) := by
+    ext i
+    simp only [AlgHom.comp_apply, linePolynomial, MvPolynomial.aeval_X]
+    split_ifs <;> simp
+  exact congrArg (fun f : A →ₐ[k] PowerSeries k => f P) he.symm
+
+variable {M : Type u} [AddCommGroup M] [Module (MvPolynomial (Fin 2) k) M]
+
+ 
+
+lemma formalLine_map_eq_of_representatives
+    (F G : M →ₗ[A] A) (x y : AdicCompletion I M)
+    (h : ∀ n : ℕ, ∃ v w : M,
+      x.val (n+1) = (AdicCompletion.of I M v).val (n+1) ∧
+      y.val (n+1) = (AdicCompletion.of I M w).val (n+1) ∧
+      linePolynomial k (F v) = linePolynomial k (G w)) :
+    formalLineMap k (AdicCompletion.map I F x) =
+      formalLineMap k (AdicCompletion.map I G y) := by
+  ext n
+  obtain ⟨v,w,hv,hw,he⟩ := h n
+  have hF : (AdicCompletion.map I F x).val (n+1) =
+      (AdicCompletion.of I A (F v)).val (n+1) := by
+    rw [← AdicCompletion.map_of]
+    simp only [AdicCompletion.map_val_apply, hv]
+  have hG : (AdicCompletion.map I G y).val (n+1) =
+      (AdicCompletion.of I A (G w)).val (n+1) := by
+    rw [← AdicCompletion.map_of]
+    simp only [AdicCompletion.map_val_apply, hw]
+  rw [formalLineMap_coeff_eq k n _ _ hF, formalLineMap_coeff_eq k n _ _ hG,
+    formalLineMap_of_linePolynomial, formalLineMap_of_linePolynomial, he]
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FormalSectionAction.lean

@@ -1,37 +1,37 @@
-import OAI.RepresentationTheory.RestrictedTilting.FormalSections
-import OAI.RepresentationTheory.RestrictedTilting.FormalLineContinuity
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory
-open scoped TensorProduct
-universe u
-variable (k : Type u) [Field k]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
-  [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)]
-variable (σ : Representation k (SL2 k) M) (hσ : PlaneCompatible k σ)
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
-local notation "T" => planeJetFD k σ hσ 1
-
-lemma formalPlaneSection_line_action
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (g : SL2 k) (F G : M →ₗ[A] A)
-    (he : ∀ v, linePolynomial k (F (σ g v)) = linePolynomial k (G v)) (t : T) :
-    formalLineMap k (AdicCompletion.map I F (formalPlaneSection k σ hσ s hs ((planeJetFD k σ hσ 1).ρ g t))) =
-      formalLineMap k (AdicCompletion.map I G (formalPlaneSection k σ hσ s hs t)) := by
-  apply formalLine_map_eq_of_representatives
-  intro n
-  obtain ⟨v,hv⟩ := (planeJetRelation (M := M) k (n+1)).mkQ_surjective (fdrepLinear k (s n) t)
-  refine ⟨σ g v, v, ?_, ?_, he v⟩
-  · rw [formalPlaneSection_equivariant, ← hv]
-    rfl
-  · change planeJetAdicEquiv k (n+1) (fdrepLinear k (s n) t) = _
-    rw [← hv]
-    rfl
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.FormalSections
+import OAI.RepresentationTheory.RestrictedTilting.FormalLineContinuity
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory
+open scoped TensorProduct
+universe u
+variable (k : Type u) [Field k]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
+  [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)]
+variable (σ : Representation k (SL2 k) M) (hσ : PlaneCompatible k σ)
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
+local notation "T" => planeJetFD k σ hσ 1
+
+lemma formalPlaneSection_line_action
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (g : SL2 k) (F G : M →ₗ[A] A)
+    (he : ∀ v, linePolynomial k (F (σ g v)) = linePolynomial k (G v)) (t : T) :
+    formalLineMap k (AdicCompletion.map I F (formalPlaneSection k σ hσ s hs ((planeJetFD k σ hσ 1).ρ g t))) =
+      formalLineMap k (AdicCompletion.map I G (formalPlaneSection k σ hσ s hs t)) := by
+  apply formalLine_map_eq_of_representatives
+  intro n
+  obtain ⟨v,hv⟩ := (planeJetRelation (M := M) k (n+1)).mkQ_surjective (fdrepLinear k (s n) t)
+  refine ⟨σ g v, v, ?_, ?_, he v⟩
+  · rw [formalPlaneSection_equivariant, ← hv]
+    rfl
+  · change planeJetAdicEquiv k (n+1) (fdrepLinear k (s n) t) = _
+    rw [← hv]
+    rfl
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FormalSections.lean

@@ -1,169 +1,169 @@
-import OAI.RepresentationTheory.RestrictedTilting.FiniteJetMaps
-import OAI.RepresentationTheory.RestrictedTilting.CompletionTriviality
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory
-open scoped TensorProduct Pointwise
-universe u
-variable (k : Type u) [Field k]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
-  [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)]
-variable (σ : Representation k (SL2 k) M) (hσ : PlaneCompatible k σ)
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
-local notation "T" => planeJetFD k σ hσ 1
-
-noncomputable def adicPlaneSections
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) :
-    (j : ℕ) → T →ₗ[k] M ⧸ (I^j • (⊤ : Submodule A M))
-  | 0 => 0
-  | j+1 => (planeJetAdicEquiv k (j+1)).toLinearMap ∘ₗ fdrepLinear k (s j)
-
-lemma adicPlaneSections_succ
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (j : ℕ) (t : T) :
-    AdicCompletion.transitionMap I M (Nat.le_succ j) (adicPlaneSections k σ hσ s (j+1) t) =
-      adicPlaneSections k σ hσ s j t := by
-  cases j with
-  | zero =>
-    have : Subsingleton (M ⧸ (I^0 • (⊤ : Submodule A M))) := by
-      rw [pow_zero, Submodule.one_smul]
-      infer_instance
-    exact Subsingleton.elim _ _
-  | succ j =>
-    change AdicCompletion.transitionMap I M (Nat.le_succ (j+1))
-      (planeJetAdicEquiv k (j+2) (fdrepLinear k (s (j+1)) t)) =
-        planeJetAdicEquiv k (j+1) (fdrepLinear k (s j) t)
-    trans planeJetAdicEquiv k (j+1)
-      (planeJetTransition k (j+1) (fdrepLinear k (s (j+1)) t))
-    · exact planeJetAdicEquiv_transition k (j+1) _
-    apply congrArg
-    exact congrArg (fun f : T ⟶ planeJetFD k σ hσ (j+1) => fdrepLinear k f t) (hs j)
-
-lemma adicPlaneSections_transition
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (m n : ℕ) (h : m ≤ n) (t : T) :
-    AdicCompletion.transitionMap I M h (adicPlaneSections k σ hσ s n t) =
-      adicPlaneSections k σ hσ s m t := by
-  exact (Submodule.eq_factor_of_eq_factor_succ
-    (fun _ _ h => Submodule.pow_smul_top_le I M h)
-    (fun j => adicPlaneSections k σ hσ s j t)
-    (fun j => (adicPlaneSections_succ k σ hσ s hs j t).symm) h).symm
-
-lemma adicPlaneSections_origin
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _) (t : T) :
-    adicPlaneSections k σ hσ s 1 t = planeJetAdicEquiv k 1 t := by
-  change planeJetAdicEquiv k 1 (fdrepLinear k (s 0) t) = _
-  rw [hs0]
-  rfl
-
-lemma adicPlaneSections_bijective
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) (j : ℕ) :
-    Function.Bijective (polynomialJetExtend j (adicPlaneSections k σ hσ s j)) := by
-  cases j with
-  | zero =>
-    have : Subsingleton (M ⧸ (I^0 • (⊤ : Submodule A M))) := by
-      rw [pow_zero, Submodule.one_smul]; infer_instance
-    have : Subsingleton ((A ⊗[k] T) ⧸ (I^0 • (⊤ : Submodule A (A ⊗[k] T)))) := by
-      rw [pow_zero, Submodule.one_smul]; infer_instance
-    exact ⟨fun _ _ _ => Subsingleton.elim _ _, fun z => ⟨0, Subsingleton.elim _ _⟩⟩
-  | succ j =>
-    let q : M →ₗ[k] T := (planeJetRelation k 1).mkQ
-    let r : (M ⧸ (I^(j+1) • (⊤ : Submodule A M))) →ₗ[k] T :=
-      (planeJetAdicEquiv k 1).symm.toLinearMap ∘ₗ
-        (AdicCompletion.transitionMap I M (Nat.succ_le_succ (Nat.zero_le j))).restrictScalars k
-    apply polynomialJetExtend_bijective (j+1) q _ r
-    · intro n
-      change (Submodule.Quotient.mk n : M ⧸ planeJetRelation k 1) = 0 ↔ _
-      rw [Submodule.Quotient.mk_eq_zero]
-      simp only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one]
-    · intro n; rfl
-    · ext t
-      change (planeJetAdicEquiv k 1).symm
-        (AdicCompletion.transitionMap I M (Nat.succ_le_succ (Nat.zero_le j)) (adicPlaneSections k σ hσ s (j+1) t)) = t
-      rw [adicPlaneSections_transition k σ hσ s hs, adicPlaneSections_origin k σ hσ s hs0]
-      exact (planeJetAdicEquiv k 1).symm_apply_apply t
-    · exact hx
-    · exact hy
-
- 
-noncomputable def formalPlaneSection
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) :
-    T →ₗ[k] AdicCompletion I M where
-  toFun t := ⟨fun j => adicPlaneSections k σ hσ s j t,
-    fun {_ _} h => adicPlaneSections_transition k σ hσ s hs _ _ h t⟩
-  map_add' a b := by ext j; exact map_add _ _ _
-  map_smul' c a := by ext j; exact map_smul _ _ _
-
- 
-
-lemma formalPlaneSection_equivariant
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (g : SL2 k) (j : ℕ) (t : T) :
-    (formalPlaneSection k σ hσ s hs ((planeJetFD k σ hσ 1).ρ g t)).val (j+1) =
-      planeJetAdicEquiv k (j+1)
-        ((planeJetFD k σ hσ (j+1)).ρ g (fdrepLinear k (s j) t)) := by
-  change planeJetAdicEquiv k (j+1) (fdrepLinear k (s j) ((planeJetFD k σ hσ 1).ρ g t)) = _
-  exact congrArg (planeJetAdicEquiv k (j+1)) (fdrepLinear_comm k (s j) g t)
-
- 
-
-noncomputable def formalPlaneTrivialization
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) :
-    (AdicCompletion I A) ⊗[k] T ≃ₗ[AdicCompletion I A] AdicCompletion I M :=
-  (TensorProduct.AlgebraTensorModule.cancelBaseChange k A
-    (AdicCompletion I A) (AdicCompletion I A) T).symm ≪≫ₗ
-  AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I (A ⊗[k] T) ≪≫ₗ
-  LinearEquiv.ofBijective
-    (completionOfJetMaps I (fun j => polynomialJetExtend j (adicPlaneSections k σ hσ s j))
-      (fun m n h z => polynomialJetExtend_transition m n h _ _
-        (adicPlaneSections_transition k σ hσ s hs m n h) z))
-    (completionOfJetMaps_bijective I _ _ (adicPlaneSections_bijective k σ hσ s hs0 hs hx hy))
-
-lemma formalPlaneTrivialization_one_tmul
-    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
-    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) (t : T) :
-    formalPlaneTrivialization k σ hσ s hs0 hs hx hy (1 ⊗ₜ[k] t) =
-      formalPlaneSection k σ hσ s hs t := by
-  simp only [formalPlaneTrivialization, LinearEquiv.trans_apply,
-    TensorProduct.AlgebraTensorModule.cancelBaseChange_symm_tmul,
-    AdicCompletion.ofTensorProductEquivOfFiniteNoetherian_apply,
-    AdicCompletion.ofTensorProduct_tmul, one_smul]
-  apply AdicCompletion.ext
-  intro j
-  change polynomialJetExtend j (adicPlaneSections k σ hσ s j)
-    (Submodule.Quotient.mk ((1 : A) ⊗ₜ[k] t)) = adicPlaneSections k σ hσ s j t
-  rw [polynomialJetExtend_mk_tmul, one_smul]
-
- 
-
-theorem exists_formalPlaneTrivialization [Infinite k]
-    (hr : IsRational k σ)
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : A) • w)
-    (hT : IsTilting k T) :
-    Nonempty ((AdicCompletion I A) ⊗[k] T ≃ₗ[AdicCompletion I A] AdicCompletion I M) := by
-  obtain ⟨s,hs0,hs⟩ := compatible_planeJet_sections k σ hσ hr hx hy hT
-  exact ⟨formalPlaneTrivialization k σ hσ s hs0 hs hx hy⟩
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.FiniteJetMaps
+import OAI.RepresentationTheory.RestrictedTilting.CompletionTriviality
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory
+open scoped TensorProduct Pointwise
+universe u
+variable (k : Type u) [Field k]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
+  [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)]
+variable (σ : Representation k (SL2 k) M) (hσ : PlaneCompatible k σ)
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "I" => MvPolynomial.idealOfVars (Fin 2) k
+local notation "T" => planeJetFD k σ hσ 1
+
+noncomputable def adicPlaneSections
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) :
+    (j : ℕ) → T →ₗ[k] M ⧸ (I^j • (⊤ : Submodule A M))
+  | 0 => 0
+  | j+1 => (planeJetAdicEquiv k (j+1)).toLinearMap ∘ₗ fdrepLinear k (s j)
+
+lemma adicPlaneSections_succ
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (j : ℕ) (t : T) :
+    AdicCompletion.transitionMap I M (Nat.le_succ j) (adicPlaneSections k σ hσ s (j+1) t) =
+      adicPlaneSections k σ hσ s j t := by
+  cases j with
+  | zero =>
+    have : Subsingleton (M ⧸ (I^0 • (⊤ : Submodule A M))) := by
+      rw [pow_zero, Submodule.one_smul]
+      infer_instance
+    exact Subsingleton.elim _ _
+  | succ j =>
+    change AdicCompletion.transitionMap I M (Nat.le_succ (j+1))
+      (planeJetAdicEquiv k (j+2) (fdrepLinear k (s (j+1)) t)) =
+        planeJetAdicEquiv k (j+1) (fdrepLinear k (s j) t)
+    trans planeJetAdicEquiv k (j+1)
+      (planeJetTransition k (j+1) (fdrepLinear k (s (j+1)) t))
+    · exact planeJetAdicEquiv_transition k (j+1) _
+    apply congrArg
+    exact congrArg (fun f : T ⟶ planeJetFD k σ hσ (j+1) => fdrepLinear k f t) (hs j)
+
+lemma adicPlaneSections_transition
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (m n : ℕ) (h : m ≤ n) (t : T) :
+    AdicCompletion.transitionMap I M h (adicPlaneSections k σ hσ s n t) =
+      adicPlaneSections k σ hσ s m t := by
+  exact (Submodule.eq_factor_of_eq_factor_succ
+    (fun _ _ h => Submodule.pow_smul_top_le I M h)
+    (fun j => adicPlaneSections k σ hσ s j t)
+    (fun j => (adicPlaneSections_succ k σ hσ s hs j t).symm) h).symm
+
+lemma adicPlaneSections_origin
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _) (t : T) :
+    adicPlaneSections k σ hσ s 1 t = planeJetAdicEquiv k 1 t := by
+  change planeJetAdicEquiv k 1 (fdrepLinear k (s 0) t) = _
+  rw [hs0]
+  rfl
+
+lemma adicPlaneSections_bijective
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) (j : ℕ) :
+    Function.Bijective (polynomialJetExtend j (adicPlaneSections k σ hσ s j)) := by
+  cases j with
+  | zero =>
+    have : Subsingleton (M ⧸ (I^0 • (⊤ : Submodule A M))) := by
+      rw [pow_zero, Submodule.one_smul]; infer_instance
+    have : Subsingleton ((A ⊗[k] T) ⧸ (I^0 • (⊤ : Submodule A (A ⊗[k] T)))) := by
+      rw [pow_zero, Submodule.one_smul]; infer_instance
+    exact ⟨fun _ _ _ => Subsingleton.elim _ _, fun z => ⟨0, Subsingleton.elim _ _⟩⟩
+  | succ j =>
+    let q : M →ₗ[k] T := (planeJetRelation k 1).mkQ
+    let r : (M ⧸ (I^(j+1) • (⊤ : Submodule A M))) →ₗ[k] T :=
+      (planeJetAdicEquiv k 1).symm.toLinearMap ∘ₗ
+        (AdicCompletion.transitionMap I M (Nat.succ_le_succ (Nat.zero_le j))).restrictScalars k
+    apply polynomialJetExtend_bijective (j+1) q _ r
+    · intro n
+      change (Submodule.Quotient.mk n : M ⧸ planeJetRelation k 1) = 0 ↔ _
+      rw [Submodule.Quotient.mk_eq_zero]
+      simp only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one]
+    · intro n; rfl
+    · ext t
+      change (planeJetAdicEquiv k 1).symm
+        (AdicCompletion.transitionMap I M (Nat.succ_le_succ (Nat.zero_le j)) (adicPlaneSections k σ hσ s (j+1) t)) = t
+      rw [adicPlaneSections_transition k σ hσ s hs, adicPlaneSections_origin k σ hσ s hs0]
+      exact (planeJetAdicEquiv k 1).symm_apply_apply t
+    · exact hx
+    · exact hy
+
+ 
+noncomputable def formalPlaneSection
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j) :
+    T →ₗ[k] AdicCompletion I M where
+  toFun t := ⟨fun j => adicPlaneSections k σ hσ s j t,
+    fun {_ _} h => adicPlaneSections_transition k σ hσ s hs _ _ h t⟩
+  map_add' a b := by ext j; exact map_add _ _ _
+  map_smul' c a := by ext j; exact map_smul _ _ _
+
+ 
+
+lemma formalPlaneSection_equivariant
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1))
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (g : SL2 k) (j : ℕ) (t : T) :
+    (formalPlaneSection k σ hσ s hs ((planeJetFD k σ hσ 1).ρ g t)).val (j+1) =
+      planeJetAdicEquiv k (j+1)
+        ((planeJetFD k σ hσ (j+1)).ρ g (fdrepLinear k (s j) t)) := by
+  change planeJetAdicEquiv k (j+1) (fdrepLinear k (s j) ((planeJetFD k σ hσ 1).ρ g t)) = _
+  exact congrArg (planeJetAdicEquiv k (j+1)) (fdrepLinear_comm k (s j) g t)
+
+ 
+
+noncomputable def formalPlaneTrivialization
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) :
+    (AdicCompletion I A) ⊗[k] T ≃ₗ[AdicCompletion I A] AdicCompletion I M :=
+  (TensorProduct.AlgebraTensorModule.cancelBaseChange k A
+    (AdicCompletion I A) (AdicCompletion I A) T).symm ≪≫ₗ
+  AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I (A ⊗[k] T) ≪≫ₗ
+  LinearEquiv.ofBijective
+    (completionOfJetMaps I (fun j => polynomialJetExtend j (adicPlaneSections k σ hσ s j))
+      (fun m n h z => polynomialJetExtend_transition m n h _ _
+        (adicPlaneSections_transition k σ hσ s hs m n h) z))
+    (completionOfJetMaps_bijective I _ _ (adicPlaneSections_bijective k σ hσ s hs0 hs hx hy))
+
+lemma formalPlaneTrivialization_one_tmul
+    (s : (j : ℕ) → T ⟶ planeJetFD k σ hσ (j+1)) (hs0 : s 0 = 𝟙 _)
+    (hs : ∀ j, s (j+1) ≫ planeJetTransitionHom k σ hσ (j+1) = s j)
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : A) • w) (t : T) :
+    formalPlaneTrivialization k σ hσ s hs0 hs hx hy (1 ⊗ₜ[k] t) =
+      formalPlaneSection k σ hσ s hs t := by
+  simp only [formalPlaneTrivialization, LinearEquiv.trans_apply,
+    TensorProduct.AlgebraTensorModule.cancelBaseChange_symm_tmul,
+    AdicCompletion.ofTensorProductEquivOfFiniteNoetherian_apply,
+    AdicCompletion.ofTensorProduct_tmul, one_smul]
+  apply AdicCompletion.ext
+  intro j
+  change polynomialJetExtend j (adicPlaneSections k σ hσ s j)
+    (Submodule.Quotient.mk ((1 : A) ⊗ₜ[k] t)) = adicPlaneSections k σ hσ s j t
+  rw [polynomialJetExtend_mk_tmul, one_smul]
+
+ 
+
+theorem exists_formalPlaneTrivialization [Infinite k]
+    (hr : IsRational k σ)
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : A) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : A) • v = (MvPolynomial.X 0 : A) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : A) • w)
+    (hT : IsTilting k T) :
+    Nonempty ((AdicCompletion I A) ⊗[k] T ≃ₗ[AdicCompletion I A] AdicCompletion I M) := by
+  obtain ⟨s,hs0,hs⟩ := compatible_planeJet_sections k σ hσ hr hx hy hT
+  exact ⟨formalPlaneTrivialization k σ hσ s hs0 hs hx hy⟩
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/FrobeniusTensor.lean

@@ -1,226 +1,226 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.SteinbergDuality
-import OAI.RepresentationTheory.RestrictedTilting.TensorLimits
-
-namespace OAI
-
-/-! Binary Frobenius multiplication and Steinberg twists of filtrations. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-open scoped TensorProduct
-universe u
-variable (k : Type u) [Field k]
-
-lemma expand_homogeneous {n : ℕ} (p : ℕ)
-    (f : MvPolynomial (Fin 2) k) (hf : f.IsHomogeneous n) :
-    (MvPolynomial.expand p f).IsHomogeneous (p*n) := by
-  exact hf.aeval (fun i => MvPolynomial.X i ^ p)
-    (fun i => by simpa using (MvPolynomial.isHomogeneous_X k i).pow p)
-
-noncomputable def binaryFrobeniusMultiply (p b : ℕ) :
-    Binary k (p-1) ⊗[k] Binary k b →ₗ[k] Binary k (p-1+p*b) :=
-  TensorProduct.lift
-    { toFun := fun f =>
-        { toFun := fun g => ⟨f.val * MvPolynomial.expand p g.val,
-            f.property.mul (expand_homogeneous k p g.val g.property)⟩
-          map_add' := by intro g h; apply Subtype.ext; simp [mul_add]
-          map_smul' := by intro c g; apply Subtype.ext; simp }
-      map_add' := by intro f g; ext h : 1; apply Subtype.ext; simp [add_mul]
-      map_smul' := by intro c f; ext g : 1; apply Subtype.ext; simp }
-
-@[simp] lemma binaryFrobeniusMultiply_tmul (p b : ℕ)
-    (f : Binary k (p-1)) (g : Binary k b) :
-    (binaryFrobeniusMultiply k p b (f ⊗ₜ[k] g)).val =
-      f.val * MvPolynomial.expand p g.val := rfl
-
-lemma binaryFrobeniusMultiply_surjective (p b : ℕ) (hp : 0 < p) :
-    Function.Surjective (binaryFrobeniusMultiply k p b) := by
-  rw [← LinearMap.range_eq_top]
-  apply top_unique
-  rw [← (binaryBasis k (p-1+p*b)).span_eq]
-  apply Submodule.span_le.mpr
-  rintro _ ⟨i,rfl⟩
-  have hj : i.val % p < p := Nat.mod_lt _ hp
-  have hil : i.val < p*(b+1) := by have := i.isLt; nlinarith [Nat.sub_add_cancel hp]
-  have hl : i.val / p < b+1 := (Nat.div_lt_iff_lt_mul hp).mpr (by simpa [mul_comm] using hil)
-  let j : Fin (p-1+1) := ⟨i.val % p, by omega⟩
-  let l : Fin (b+1) := ⟨i.val / p, hl⟩
-  refine ⟨binaryBasis k (p-1) j ⊗ₜ[k] binaryBasis k b l, ?_⟩
-  apply Subtype.ext
-  simp only [binaryFrobeniusMultiply_tmul, binaryBasis_apply, map_mul, map_pow,
-    MvPolynomial.expand_X, ← pow_mul]
-  rw [mul_mul_mul_comm, ← pow_add, ← pow_add]
-  have hi : j.val + p*l.val = i.val := Nat.mod_add_div _ _
-  have hnot : l.val ≤ b := by omega
-  have h₁ : (p-1-j.val) + p*(b-l.val) = p-1+p*b-i.val := by
-    rw [Nat.mul_sub_left_distrib]
-    have hpj : j.val ≤ p-1 := by dsimp [j]; omega
-    have hpb : p*l.val ≤ p*b := Nat.mul_le_mul_left _ hnot
-    omega
-  rw [h₁, hi]
-
-lemma binaryFrobeniusMultiply_bijective (p b : ℕ) (hp : 0 < p) :
-    Function.Bijective (binaryFrobeniusMultiply k p b) := by
-  have he : Module.finrank k (Binary k (p-1) ⊗[k] Binary k b) =
-      Module.finrank k (Binary k (p-1+p*b)) := by
-    rw [Module.finrank_tensorProduct, binaryBasis_finrank, binaryBasis_finrank,
-      binaryBasis_finrank]
-    nlinarith [Nat.sub_add_cancel hp]
-  constructor
-  · apply (LinearMap.injective_iff_surjective_of_finrank_eq_finrank (K := k)
-      (V := Binary k (p-1) ⊗[k] Binary k b) (V₂ := Binary k (p-1+p*b))
-      he (f := binaryFrobeniusMultiply k p b)).mpr
-    exact binaryFrobeniusMultiply_surjective k p b hp
-  · exact binaryFrobeniusMultiply_surjective k p b hp
-
-variable (p : ℕ) [Fact p.Prime] [CharP k p]
-
-noncomputable def frobeniusSL2 : SL2 k →* SL2 k :=
-  Matrix.SpecialLinearGroup.map (frobenius k p)
-
-lemma dualMatrix_frobeniusSL2 (g : SL2 k) :
-    dualMatrix k (frobeniusSL2 k p g) =
-      (frobenius k p).mapMatrix (dualMatrix k g) := by
-  change ((↑((frobeniusSL2 k p g)⁻¹) : Matrix (Fin 2) (Fin 2) k)).transpose = _
-  rw [← map_inv]
-  rfl
-
-lemma linearChange_expand (A : Matrix (Fin 2) (Fin 2) k) (f : MvPolynomial (Fin 2) k) :
-    linearChange A (MvPolynomial.expand p f) =
-      MvPolynomial.expand p (linearChange ((frobenius k p).mapMatrix A) f) := by
-  have he : (linearChange A).comp (MvPolynomial.expand p) =
-      (MvPolynomial.expand p).comp (linearChange ((frobenius k p).mapMatrix A)) := by
-    ext i : 1
-    simp [Fin.sum_univ_two, add_pow_char, mul_pow, frobenius_def, map_pow]
-  exact AlgHom.congr_fun he f
-
-lemma binaryFrobeniusMultiply_intertwines (b : ℕ) (g : SL2 k)
-    (z : Binary k (p-1) ⊗[k] Binary k b) :
-    binaryFrobeniusMultiply k p b
-      (Representation.tprod (costandard k (p-1)).ρ
-        ((costandard k b).ρ.comp (frobeniusSL2 k p)) g z) =
-      (costandard k (p-1+p*b)).ρ g (binaryFrobeniusMultiply k p b z) := by
-  change binaryFrobeniusMultiply k p b
-    (TensorProduct.map (homogeneousRepresentation (p-1) (dualMatrix k g))
-      (homogeneousRepresentation b (dualMatrix k (frobeniusSL2 k p g))) z) =
-    homogeneousRepresentation (p-1+p*b) (dualMatrix k g) (binaryFrobeniusMultiply k p b z)
-  induction z using TensorProduct.inductionOn with
-  | add z w hz hw => simp only [map_add, hz, hw]
-  | tmul f h =>
-    apply Subtype.ext
-    change linearChange (dualMatrix k g) f.val *
-      MvPolynomial.expand p (linearChange (dualMatrix k (frobeniusSL2 k p g)) h.val) =
-      linearChange (dualMatrix k g) (f.val * MvPolynomial.expand p h.val)
-    rw [map_mul, dualMatrix_frobeniusSL2, linearChange_expand]
-
-end
-
-universe u
-variable (k : Type u) [Field k]
-variable (p : ℕ) [Fact p.Prime] [CharP k p]
-
- 
-noncomputable def frobeniusTwist : FDRep k (SL2 k) ⥤ FDRep k (SL2 k) :=
-  Action.res (FGModuleCat k) (frobeniusSL2 k p)
-
-instance : (frobeniusTwist k p).Additive where
-  map_add := by intros; rfl
-
-lemma frobeniusTwist_shortExact (S : ShortComplex (FDRep k (SL2 k)))
-    (hS : S.ShortExact) : (S.map (frobeniusTwist k p)).ShortExact := by
-  have := hS.mono_f
-  have := hS.epi_g
-  exact fdrep_shortExact k _ (fdrep_injective k S.f) (fdrep_surjective k S.g)
-    (fdrep_exact k (S := S) hS.exact)
-
-noncomputable def frobeniusCostandardHom (b : ℕ) :
-    costandard k (p-1) ⊗ (frobeniusTwist k p).obj (costandard k b) ⟶
-      costandard k (p-1+p*b) :=
-  fdrepHom k (binaryFrobeniusMultiply k p b) (binaryFrobeniusMultiply_intertwines k p b)
-
-noncomputable def frobeniusCostandardIso (b : ℕ) :
-    costandard k (p-1) ⊗ (frobeniusTwist k p).obj (costandard k b) ≅
-      costandard k (p-1+p*b) := by
-  let f := frobeniusCostandardHom k p b
-  have : IsIso f := fdrepHom_isIso_of_bijective k f
-    (binaryFrobeniusMultiply_bijective k p b (Fact.out : p.Prime).pos)
-  exact asIso f
-
- 
-
-theorem HasGoodFiltration.steinberg_frobenius {A : FDRep k (SL2 k)}
-    (hA : HasGoodFiltration k A) :
-    HasGoodFiltration k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A) := by
-  induction hA with
-  | zero A hA =>
-    exact .zero _ ((tensorLeft (costandard k (p-1))).map_isZero
-      ((frobeniusTwist k p).map_isZero hA))
-  | @step A B n f g w hS hA ih =>
-    let F := tensorLeft (costandard k (p-1))
-    let := tensorLeft_preservesFiniteLimits (costandard k (p-1))
-    let := tensorLeft_preservesFiniteColimits (costandard k (p-1))
-    have hT := (frobeniusTwist_shortExact k p _ hS).map_of_exact F
-    have hc := (costandard_hasGoodFiltration k (p-1+p*n)).of_iso k
-      (frobeniusCostandardIso k p n).symm
-    exact ih.extension k hc _ _ _ hT
-
-
-lemma IsRational.frobenius {M : Type u} [AddCommGroup M] [Module k M]
-    (ρ : Representation k (SL2 k) M) (hρ : IsRational k ρ) :
-    IsRational k (ρ.comp (frobeniusSL2 k p)) := by
-  intro v l
-  obtain ⟨P,hP⟩ := hρ v l
-  refine ⟨MvPolynomial.expand p P, fun g => ?_⟩
-  change l (ρ (frobeniusSL2 k p g) v) = _
-  rw [hP]
-  change MvPolynomial.eval₂ (RingHom.id k) (fun ij => (g ij.1 ij.2)^p) P =
-    MvPolynomial.eval₂ (RingHom.id k) (fun ij => g ij.1 ij.2) (MvPolynomial.expand p P)
-  rw [MvPolynomial.eval₂_expand]
-  rfl
-
-noncomputable def frobeniusDualIso (A : FDRep k (SL2 k)) :
-    ((frobeniusTwist k p).obj A)ᘁ ≅ (frobeniusTwist k p).obj Aᘁ := by
-  let f : ((frobeniusTwist k p).obj A)ᘁ ⟶ (frobeniusTwist k p).obj Aᘁ :=
-    fdrepHom k LinearMap.id (by
-      intro g l
-      change Module.Dual k A at l
-      rw [fdrep_dual_repr]
-      change Representation.dual (A.ρ.comp (frobeniusSL2 k p)) g l =
-        Aᘁ.ρ (frobeniusSL2 k p g) l
-      rw [fdrep_dual_repr]
-      apply LinearMap.ext
-      intro x
-      change l (A.ρ (frobeniusSL2 k p (g⁻¹)) x) = l (A.ρ ((frobeniusSL2 k p g)⁻¹) x)
-      rw [map_inv])
-  have : IsIso f := fdrepHom_isIso_of_bijective k f Function.bijective_id
-  exact asIso f
-
-variable [Infinite k]
-
- 
-theorem IsTilting.steinberg_frobenius {A : FDRep k (SL2 k)} (hA : IsTilting k A) :
-    IsTilting k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A) := by
-  have hr : IsRational k ((frobeniusTwist k p).obj A).ρ :=
-    IsRational.frobenius k p A.ρ hA.1
-  have hrt : IsRational k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A).ρ :=
-    IsRational.tensor k (costandard k (p-1)).ρ ((frobeniusTwist k p).obj A).ρ
-      (costandard_rational k (p-1)) hr
-  refine ⟨hrt, hA.2.1.steinberg_frobenius k p, ?_⟩
-  obtain ⟨hs⟩ := costandard_self_dual_of_choose_ne_zero k (p-1)
-    (fun i => choose_cast_ne_zero_of_lt_char k p
-      (by have := (Fact.out : p.Prime).pos; omega) (by have := i.isLt; omega))
-  let e : (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A)ᘁ ≅
-      costandard k (p-1) ⊗ (frobeniusTwist k p).obj Aᘁ :=
-    rightDualTensorIso _ _ ≪≫ (tensorIso (frobeniusDualIso k p A) hs) ≪≫
-      (β_ _ _)
-  exact (hA.2.2.steinberg_frobenius k p).of_iso k e.symm
-
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.SteinbergDuality
+import OAI.RepresentationTheory.RestrictedTilting.TensorLimits
+
+namespace OAI
+
+/-! Binary Frobenius multiplication and Steinberg twists of filtrations. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+open scoped TensorProduct
+universe u
+variable (k : Type u) [Field k]
+
+lemma expand_homogeneous {n : ℕ} (p : ℕ)
+    (f : MvPolynomial (Fin 2) k) (hf : f.IsHomogeneous n) :
+    (MvPolynomial.expand p f).IsHomogeneous (p*n) := by
+  exact hf.aeval (fun i => MvPolynomial.X i ^ p)
+    (fun i => by simpa using (MvPolynomial.isHomogeneous_X k i).pow p)
+
+noncomputable def binaryFrobeniusMultiply (p b : ℕ) :
+    Binary k (p-1) ⊗[k] Binary k b →ₗ[k] Binary k (p-1+p*b) :=
+  TensorProduct.lift
+    { toFun := fun f =>
+        { toFun := fun g => ⟨f.val * MvPolynomial.expand p g.val,
+            f.property.mul (expand_homogeneous k p g.val g.property)⟩
+          map_add' := by intro g h; apply Subtype.ext; simp [mul_add]
+          map_smul' := by intro c g; apply Subtype.ext; simp }
+      map_add' := by intro f g; ext h : 1; apply Subtype.ext; simp [add_mul]
+      map_smul' := by intro c f; ext g : 1; apply Subtype.ext; simp }
+
+@[simp] lemma binaryFrobeniusMultiply_tmul (p b : ℕ)
+    (f : Binary k (p-1)) (g : Binary k b) :
+    (binaryFrobeniusMultiply k p b (f ⊗ₜ[k] g)).val =
+      f.val * MvPolynomial.expand p g.val := rfl
+
+lemma binaryFrobeniusMultiply_surjective (p b : ℕ) (hp : 0 < p) :
+    Function.Surjective (binaryFrobeniusMultiply k p b) := by
+  rw [← LinearMap.range_eq_top]
+  apply top_unique
+  rw [← (binaryBasis k (p-1+p*b)).span_eq]
+  apply Submodule.span_le.mpr
+  rintro _ ⟨i,rfl⟩
+  have hj : i.val % p < p := Nat.mod_lt _ hp
+  have hil : i.val < p*(b+1) := by have := i.isLt; nlinarith [Nat.sub_add_cancel hp]
+  have hl : i.val / p < b+1 := (Nat.div_lt_iff_lt_mul hp).mpr (by simpa [mul_comm] using hil)
+  let j : Fin (p-1+1) := ⟨i.val % p, by omega⟩
+  let l : Fin (b+1) := ⟨i.val / p, hl⟩
+  refine ⟨binaryBasis k (p-1) j ⊗ₜ[k] binaryBasis k b l, ?_⟩
+  apply Subtype.ext
+  simp only [binaryFrobeniusMultiply_tmul, binaryBasis_apply, map_mul, map_pow,
+    MvPolynomial.expand_X, ← pow_mul]
+  rw [mul_mul_mul_comm, ← pow_add, ← pow_add]
+  have hi : j.val + p*l.val = i.val := Nat.mod_add_div _ _
+  have hnot : l.val ≤ b := by omega
+  have h₁ : (p-1-j.val) + p*(b-l.val) = p-1+p*b-i.val := by
+    rw [Nat.mul_sub_left_distrib]
+    have hpj : j.val ≤ p-1 := by dsimp [j]; omega
+    have hpb : p*l.val ≤ p*b := Nat.mul_le_mul_left _ hnot
+    omega
+  rw [h₁, hi]
+
+lemma binaryFrobeniusMultiply_bijective (p b : ℕ) (hp : 0 < p) :
+    Function.Bijective (binaryFrobeniusMultiply k p b) := by
+  have he : Module.finrank k (Binary k (p-1) ⊗[k] Binary k b) =
+      Module.finrank k (Binary k (p-1+p*b)) := by
+    rw [Module.finrank_tensorProduct, binaryBasis_finrank, binaryBasis_finrank,
+      binaryBasis_finrank]
+    nlinarith [Nat.sub_add_cancel hp]
+  constructor
+  · apply (LinearMap.injective_iff_surjective_of_finrank_eq_finrank (K := k)
+      (V := Binary k (p-1) ⊗[k] Binary k b) (V₂ := Binary k (p-1+p*b))
+      he (f := binaryFrobeniusMultiply k p b)).mpr
+    exact binaryFrobeniusMultiply_surjective k p b hp
+  · exact binaryFrobeniusMultiply_surjective k p b hp
+
+variable (p : ℕ) [Fact p.Prime] [CharP k p]
+
+noncomputable def frobeniusSL2 : SL2 k →* SL2 k :=
+  Matrix.SpecialLinearGroup.map (frobenius k p)
+
+lemma dualMatrix_frobeniusSL2 (g : SL2 k) :
+    dualMatrix k (frobeniusSL2 k p g) =
+      (frobenius k p).mapMatrix (dualMatrix k g) := by
+  change ((↑((frobeniusSL2 k p g)⁻¹) : Matrix (Fin 2) (Fin 2) k)).transpose = _
+  rw [← map_inv]
+  rfl
+
+lemma linearChange_expand (A : Matrix (Fin 2) (Fin 2) k) (f : MvPolynomial (Fin 2) k) :
+    linearChange A (MvPolynomial.expand p f) =
+      MvPolynomial.expand p (linearChange ((frobenius k p).mapMatrix A) f) := by
+  have he : (linearChange A).comp (MvPolynomial.expand p) =
+      (MvPolynomial.expand p).comp (linearChange ((frobenius k p).mapMatrix A)) := by
+    ext i : 1
+    simp [Fin.sum_univ_two, add_pow_char, mul_pow, frobenius_def, map_pow]
+  exact AlgHom.congr_fun he f
+
+lemma binaryFrobeniusMultiply_intertwines (b : ℕ) (g : SL2 k)
+    (z : Binary k (p-1) ⊗[k] Binary k b) :
+    binaryFrobeniusMultiply k p b
+      (Representation.tprod (costandard k (p-1)).ρ
+        ((costandard k b).ρ.comp (frobeniusSL2 k p)) g z) =
+      (costandard k (p-1+p*b)).ρ g (binaryFrobeniusMultiply k p b z) := by
+  change binaryFrobeniusMultiply k p b
+    (TensorProduct.map (homogeneousRepresentation (p-1) (dualMatrix k g))
+      (homogeneousRepresentation b (dualMatrix k (frobeniusSL2 k p g))) z) =
+    homogeneousRepresentation (p-1+p*b) (dualMatrix k g) (binaryFrobeniusMultiply k p b z)
+  induction z using TensorProduct.inductionOn with
+  | add z w hz hw => simp only [map_add, hz, hw]
+  | tmul f h =>
+    apply Subtype.ext
+    change linearChange (dualMatrix k g) f.val *
+      MvPolynomial.expand p (linearChange (dualMatrix k (frobeniusSL2 k p g)) h.val) =
+      linearChange (dualMatrix k g) (f.val * MvPolynomial.expand p h.val)
+    rw [map_mul, dualMatrix_frobeniusSL2, linearChange_expand]
+
+end
+
+universe u
+variable (k : Type u) [Field k]
+variable (p : ℕ) [Fact p.Prime] [CharP k p]
+
+ 
+noncomputable def frobeniusTwist : FDRep k (SL2 k) ⥤ FDRep k (SL2 k) :=
+  Action.res (FGModuleCat k) (frobeniusSL2 k p)
+
+instance : (frobeniusTwist k p).Additive where
+  map_add := by intros; rfl
+
+lemma frobeniusTwist_shortExact (S : ShortComplex (FDRep k (SL2 k)))
+    (hS : S.ShortExact) : (S.map (frobeniusTwist k p)).ShortExact := by
+  have := hS.mono_f
+  have := hS.epi_g
+  exact fdrep_shortExact k _ (fdrep_injective k S.f) (fdrep_surjective k S.g)
+    (fdrep_exact k (S := S) hS.exact)
+
+noncomputable def frobeniusCostandardHom (b : ℕ) :
+    costandard k (p-1) ⊗ (frobeniusTwist k p).obj (costandard k b) ⟶
+      costandard k (p-1+p*b) :=
+  fdrepHom k (binaryFrobeniusMultiply k p b) (binaryFrobeniusMultiply_intertwines k p b)
+
+noncomputable def frobeniusCostandardIso (b : ℕ) :
+    costandard k (p-1) ⊗ (frobeniusTwist k p).obj (costandard k b) ≅
+      costandard k (p-1+p*b) := by
+  let f := frobeniusCostandardHom k p b
+  have : IsIso f := fdrepHom_isIso_of_bijective k f
+    (binaryFrobeniusMultiply_bijective k p b (Fact.out : p.Prime).pos)
+  exact asIso f
+
+ 
+
+theorem HasGoodFiltration.steinberg_frobenius {A : FDRep k (SL2 k)}
+    (hA : HasGoodFiltration k A) :
+    HasGoodFiltration k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A) := by
+  induction hA with
+  | zero A hA =>
+    exact .zero _ ((tensorLeft (costandard k (p-1))).map_isZero
+      ((frobeniusTwist k p).map_isZero hA))
+  | @step A B n f g w hS hA ih =>
+    let F := tensorLeft (costandard k (p-1))
+    let := tensorLeft_preservesFiniteLimits (costandard k (p-1))
+    let := tensorLeft_preservesFiniteColimits (costandard k (p-1))
+    have hT := (frobeniusTwist_shortExact k p _ hS).map_of_exact F
+    have hc := (costandard_hasGoodFiltration k (p-1+p*n)).of_iso k
+      (frobeniusCostandardIso k p n).symm
+    exact ih.extension k hc _ _ _ hT
+
+
+lemma IsRational.frobenius {M : Type u} [AddCommGroup M] [Module k M]
+    (ρ : Representation k (SL2 k) M) (hρ : IsRational k ρ) :
+    IsRational k (ρ.comp (frobeniusSL2 k p)) := by
+  intro v l
+  obtain ⟨P,hP⟩ := hρ v l
+  refine ⟨MvPolynomial.expand p P, fun g => ?_⟩
+  change l (ρ (frobeniusSL2 k p g) v) = _
+  rw [hP]
+  change MvPolynomial.eval₂ (RingHom.id k) (fun ij => (g ij.1 ij.2)^p) P =
+    MvPolynomial.eval₂ (RingHom.id k) (fun ij => g ij.1 ij.2) (MvPolynomial.expand p P)
+  rw [MvPolynomial.eval₂_expand]
+  rfl
+
+noncomputable def frobeniusDualIso (A : FDRep k (SL2 k)) :
+    ((frobeniusTwist k p).obj A)ᘁ ≅ (frobeniusTwist k p).obj Aᘁ := by
+  let f : ((frobeniusTwist k p).obj A)ᘁ ⟶ (frobeniusTwist k p).obj Aᘁ :=
+    fdrepHom k LinearMap.id (by
+      intro g l
+      change Module.Dual k A at l
+      rw [fdrep_dual_repr]
+      change Representation.dual (A.ρ.comp (frobeniusSL2 k p)) g l =
+        Aᘁ.ρ (frobeniusSL2 k p g) l
+      rw [fdrep_dual_repr]
+      apply LinearMap.ext
+      intro x
+      change l (A.ρ (frobeniusSL2 k p (g⁻¹)) x) = l (A.ρ ((frobeniusSL2 k p g)⁻¹) x)
+      rw [map_inv])
+  have : IsIso f := fdrepHom_isIso_of_bijective k f Function.bijective_id
+  exact asIso f
+
+variable [Infinite k]
+
+ 
+theorem IsTilting.steinberg_frobenius {A : FDRep k (SL2 k)} (hA : IsTilting k A) :
+    IsTilting k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A) := by
+  have hr : IsRational k ((frobeniusTwist k p).obj A).ρ :=
+    IsRational.frobenius k p A.ρ hA.1
+  have hrt : IsRational k (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A).ρ :=
+    IsRational.tensor k (costandard k (p-1)).ρ ((frobeniusTwist k p).obj A).ρ
+      (costandard_rational k (p-1)) hr
+  refine ⟨hrt, hA.2.1.steinberg_frobenius k p, ?_⟩
+  obtain ⟨hs⟩ := costandard_self_dual_of_choose_ne_zero k (p-1)
+    (fun i => choose_cast_ne_zero_of_lt_char k p
+      (by have := (Fact.out : p.Prime).pos; omega) (by have := i.isLt; omega))
+  let e : (costandard k (p-1) ⊗ (frobeniusTwist k p).obj A)ᘁ ≅
+      costandard k (p-1) ⊗ (frobeniusTwist k p).obj Aᘁ :=
+    rightDualTensorIso _ _ ≪≫ (tensorIso (frobeniusDualIso k p A) hs) ≪≫
+      (β_ _ _)
+  exact (hA.2.2.steinberg_frobenius k p).of_iso k e.symm
+
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/GeneratedStableKernel.lean

@@ -1,117 +1,117 @@
-import OAI.RepresentationTheory.RestrictedTilting.TiltingCovers
-import OAI.RepresentationTheory.RestrictedTilting.SteinbergSpan
-import OAI.RepresentationTheory.RestrictedTilting.BoundedStableFaithfulness
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (p r : ℕ) [Fact p.Prime] [CharP k p]
-variable (l : (Fin r → ZMod p) →+ k) (hl : Function.Injective l)
-
- 
-def StableFaithfulPair (A B : FDRep k (SL2 k)) : Prop :=
-  ∀ (f : A ⟶ B), FactorsThroughProjective ((restrictElementary k p r l).map f) →
-    f ∈ steinbergSpan k p r A B
-
-omit [Infinite k] [CharP k p] in
-lemma StableFaithfulPair.iso_left {A A' B : FDRep k (SL2 k)}
-    (h : StableFaithfulPair k p r l A B) (e : A ≅ A') :
-    StableFaithfulPair k p r l A' B := by
-  intro f hf
-  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (e.hom ≫ f)) := by
-    rw [Functor.map_comp]
-    exact hf.precomp _
-  have H := steinbergSpan.precomp k p r e.inv _ (h _ hg)
-  simpa using H
-
-omit [Infinite k] [CharP k p] in
-lemma StableFaithfulPair.iso_right {A B B' : FDRep k (SL2 k)}
-    (h : StableFaithfulPair k p r l A B) (e : B ≅ B') :
-    StableFaithfulPair k p r l A B' := by
-  intro f hf
-  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (f ≫ e.inv)) := by
-    rw [Functor.map_comp]
-    exact hf.postcomp _
-  have H := steinbergSpan.postcomp k p r _ e.hom (h _ hg)
-  simpa using H
-
-omit [Infinite k] [CharP k p] in
-lemma StableFaithfulPair.prod_left {A A' B : FDRep k (SL2 k)}
-    (h : StableFaithfulPair k p r l A B) (h' : StableFaithfulPair k p r l A' B) :
-    StableFaithfulPair k p r l (repProduct k A A') B := by
-  intro f hf
-  have h₁ : FactorsThroughProjective
-      ((restrictElementary k p r l).map (repInl k A A' ≫ f)) := by
-    rw [Functor.map_comp]; exact hf.precomp _
-  have h₂ : FactorsThroughProjective
-      ((restrictElementary k p r l).map (repInr k A A' ≫ f)) := by
-    rw [Functor.map_comp]; exact hf.precomp _
-  have H := (steinbergSpan k p r _ B).add_mem
-    (steinbergSpan.precomp k p r (repFst k A A') _ (h _ h₁))
-    (steinbergSpan.precomp k p r (repSnd k A A') _ (h' _ h₂))
-  have he : (repFst k A A' ≫ repInl k A A' + repSnd k A A' ≫ repInr k A A') ≫ f = f := by
-    rw [repProduct_decomposition, Category.id_comp]
-  rw [Preadditive.add_comp, Category.assoc, Category.assoc] at he
-  rwa [he] at H
-
-omit [Infinite k] [CharP k p] in
-lemma StableFaithfulPair.prod_right {A B B' : FDRep k (SL2 k)}
-    (h : StableFaithfulPair k p r l A B) (h' : StableFaithfulPair k p r l A B') :
-    StableFaithfulPair k p r l A (repProduct k B B') := by
-  intro f hf
-  have h₁ : FactorsThroughProjective
-      ((restrictElementary k p r l).map (f ≫ repFst k B B')) := by
-    rw [Functor.map_comp]; exact hf.postcomp _
-  have h₂ : FactorsThroughProjective
-      ((restrictElementary k p r l).map (f ≫ repSnd k B B')) := by
-    rw [Functor.map_comp]; exact hf.postcomp _
-  have H := (steinbergSpan k p r A _).add_mem
-    (steinbergSpan.postcomp k p r _ (repInl k B B') (h _ h₁))
-    (steinbergSpan.postcomp k p r _ (repInr k B B') (h' _ h₂))
-  have he : f ≫ (repFst k B B' ≫ repInl k B B' + repSnd k B B' ≫ repInr k B B') = f := by
-    rw [repProduct_decomposition, Category.comp_id]
-  rw [Preadditive.comp_add, ← Category.assoc, ← Category.assoc] at he
-  rwa [he] at H
-
-include hl
-
-omit [CharP k p] in
-lemma generated_stable_kernel {A B : FDRep k (SL2 k)}
-    (hA : SteinbergGenerated k p r A) (hB : SteinbergGenerated k p r B) :
-    StableFaithfulPair k p r l A B := by
-  induction hA generalizing B with
-  | low A hA a ha hw =>
-    induction hB with
-    | low B hB b hb hw' =>
-      intro f hf
-      have hz := low_weight_projective_factor_zero p r l hl A B hA.1 hB.1 a b hw hw'
-        (by omega) f hf
-      rw [hz]
-      exact (steinbergSpan k p r A B).zero_mem
-    | high X hX => exact fun f _ => steinbergSpan_of_high_right k p r X hX f
-    | of_iso hB e ih => exact ih.iso_right k p r l e
-    | prod hB hB' ih ih' => exact ih.prod_right k p r l ih'
-  | high X hX => exact fun f _ => steinbergSpan_of_high_left k p r X hX f
-  | of_iso hA e ih => exact (ih hB).iso_left k p r l e
-  | prod hA hA' ih ih' => exact (ih hB).prod_left k p r l (ih' hB)
-
- 
-theorem tilting_projective_factor_mem_steinbergSpan (hr : 1 ≤ r)
-    (A B : FDRep k (SL2 k)) (hA : IsTilting k A) (hB : IsTilting k B)
-    (f : A ⟶ B) (hf : FactorsThroughProjective ((restrictElementary k p r l).map f)) :
-    f ∈ steinbergSpan k p r A B := by
-  obtain ⟨P,a,s,ha,hP⟩ := tilting_retract_generated k p r hr A hA
-  obtain ⟨Q,b,t,hb,hQ⟩ := tilting_retract_generated k p r hr B hB
-  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (a ≫ f ≫ t)) := by
-    simp only [Functor.map_comp]
-    exact (hf.precomp _).postcomp _
-  have H := generated_stable_kernel k p r l hl hP hQ _ hg
-  have H' := steinbergSpan.postcomp k p r _ b (steinbergSpan.precomp k p r s _ H)
-  simp only [Category.assoc] at H'
-  rwa [← Category.assoc s a, ha, Category.id_comp, hb, Category.comp_id] at H'
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.TiltingCovers
+import OAI.RepresentationTheory.RestrictedTilting.SteinbergSpan
+import OAI.RepresentationTheory.RestrictedTilting.BoundedStableFaithfulness
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (p r : ℕ) [Fact p.Prime] [CharP k p]
+variable (l : (Fin r → ZMod p) →+ k) (hl : Function.Injective l)
+
+ 
+def StableFaithfulPair (A B : FDRep k (SL2 k)) : Prop :=
+  ∀ (f : A ⟶ B), FactorsThroughProjective ((restrictElementary k p r l).map f) →
+    f ∈ steinbergSpan k p r A B
+
+omit [Infinite k] [CharP k p] in
+lemma StableFaithfulPair.iso_left {A A' B : FDRep k (SL2 k)}
+    (h : StableFaithfulPair k p r l A B) (e : A ≅ A') :
+    StableFaithfulPair k p r l A' B := by
+  intro f hf
+  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (e.hom ≫ f)) := by
+    rw [Functor.map_comp]
+    exact hf.precomp _
+  have H := steinbergSpan.precomp k p r e.inv _ (h _ hg)
+  simpa using H
+
+omit [Infinite k] [CharP k p] in
+lemma StableFaithfulPair.iso_right {A B B' : FDRep k (SL2 k)}
+    (h : StableFaithfulPair k p r l A B) (e : B ≅ B') :
+    StableFaithfulPair k p r l A B' := by
+  intro f hf
+  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (f ≫ e.inv)) := by
+    rw [Functor.map_comp]
+    exact hf.postcomp _
+  have H := steinbergSpan.postcomp k p r _ e.hom (h _ hg)
+  simpa using H
+
+omit [Infinite k] [CharP k p] in
+lemma StableFaithfulPair.prod_left {A A' B : FDRep k (SL2 k)}
+    (h : StableFaithfulPair k p r l A B) (h' : StableFaithfulPair k p r l A' B) :
+    StableFaithfulPair k p r l (repProduct k A A') B := by
+  intro f hf
+  have h₁ : FactorsThroughProjective
+      ((restrictElementary k p r l).map (repInl k A A' ≫ f)) := by
+    rw [Functor.map_comp]; exact hf.precomp _
+  have h₂ : FactorsThroughProjective
+      ((restrictElementary k p r l).map (repInr k A A' ≫ f)) := by
+    rw [Functor.map_comp]; exact hf.precomp _
+  have H := (steinbergSpan k p r _ B).add_mem
+    (steinbergSpan.precomp k p r (repFst k A A') _ (h _ h₁))
+    (steinbergSpan.precomp k p r (repSnd k A A') _ (h' _ h₂))
+  have he : (repFst k A A' ≫ repInl k A A' + repSnd k A A' ≫ repInr k A A') ≫ f = f := by
+    rw [repProduct_decomposition, Category.id_comp]
+  rw [Preadditive.add_comp, Category.assoc, Category.assoc] at he
+  rwa [he] at H
+
+omit [Infinite k] [CharP k p] in
+lemma StableFaithfulPair.prod_right {A B B' : FDRep k (SL2 k)}
+    (h : StableFaithfulPair k p r l A B) (h' : StableFaithfulPair k p r l A B') :
+    StableFaithfulPair k p r l A (repProduct k B B') := by
+  intro f hf
+  have h₁ : FactorsThroughProjective
+      ((restrictElementary k p r l).map (f ≫ repFst k B B')) := by
+    rw [Functor.map_comp]; exact hf.postcomp _
+  have h₂ : FactorsThroughProjective
+      ((restrictElementary k p r l).map (f ≫ repSnd k B B')) := by
+    rw [Functor.map_comp]; exact hf.postcomp _
+  have H := (steinbergSpan k p r A _).add_mem
+    (steinbergSpan.postcomp k p r _ (repInl k B B') (h _ h₁))
+    (steinbergSpan.postcomp k p r _ (repInr k B B') (h' _ h₂))
+  have he : f ≫ (repFst k B B' ≫ repInl k B B' + repSnd k B B' ≫ repInr k B B') = f := by
+    rw [repProduct_decomposition, Category.comp_id]
+  rw [Preadditive.comp_add, ← Category.assoc, ← Category.assoc] at he
+  rwa [he] at H
+
+include hl
+
+omit [CharP k p] in
+lemma generated_stable_kernel {A B : FDRep k (SL2 k)}
+    (hA : SteinbergGenerated k p r A) (hB : SteinbergGenerated k p r B) :
+    StableFaithfulPair k p r l A B := by
+  induction hA generalizing B with
+  | low A hA a ha hw =>
+    induction hB with
+    | low B hB b hb hw' =>
+      intro f hf
+      have hz := low_weight_projective_factor_zero p r l hl A B hA.1 hB.1 a b hw hw'
+        (by omega) f hf
+      rw [hz]
+      exact (steinbergSpan k p r A B).zero_mem
+    | high X hX => exact fun f _ => steinbergSpan_of_high_right k p r X hX f
+    | of_iso hB e ih => exact ih.iso_right k p r l e
+    | prod hB hB' ih ih' => exact ih.prod_right k p r l ih'
+  | high X hX => exact fun f _ => steinbergSpan_of_high_left k p r X hX f
+  | of_iso hA e ih => exact (ih hB).iso_left k p r l e
+  | prod hA hA' ih ih' => exact (ih hB).prod_left k p r l (ih' hB)
+
+ 
+theorem tilting_projective_factor_mem_steinbergSpan (hr : 1 ≤ r)
+    (A B : FDRep k (SL2 k)) (hA : IsTilting k A) (hB : IsTilting k B)
+    (f : A ⟶ B) (hf : FactorsThroughProjective ((restrictElementary k p r l).map f)) :
+    f ∈ steinbergSpan k p r A B := by
+  obtain ⟨P,a,s,ha,hP⟩ := tilting_retract_generated k p r hr A hA
+  obtain ⟨Q,b,t,hb,hQ⟩ := tilting_retract_generated k p r hr B hB
+  have hg : FactorsThroughProjective ((restrictElementary k p r l).map (a ≫ f ≫ t)) := by
+    simp only [Functor.map_comp]
+    exact (hf.precomp _).postcomp _
+  have H := generated_stable_kernel k p r l hl hP hQ _ hg
+  have H' := steinbergSpan.postcomp k p r _ b (steinbergSpan.precomp k p r s _ H)
+  simp only [Category.assoc] at H'
+  rwa [← Category.assoc s a, ha, Category.id_comp, hb, Category.comp_id] at H'
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/GlobalLattices.lean

@@ -1,323 +1,323 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.OriginCoordinates
-
-namespace OAI
-
-/-! Fraction charts, global lattices and finite origin quotients. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-variable (k : Type*) [Field k]
-abbrev planeFractionField := FractionRing (MvPolynomial (Fin 2) k)
-
-noncomputable instance planeCoordinateRing_gcd : GCDMonoid (MvPolynomial (Fin 2) k) :=
-  UniqueFactorizationMonoid.toGCDMonoid _
-
-lemma planeCoordinates_relPrime :
-    IsRelPrime (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) := by
-  apply (MvPolynomial.X_prime (R := k) (i := (0 : Fin 2))).irreducible.isRelPrime_iff_not_dvd.mpr
-  intro h
-  exact (by decide : (0 : Fin 2) ≠ 1) (MvPolynomial.X_dvd_X.mp h)
-
-lemma planeFractionCoordinate_ne_zero (i : Fin 2) :
-    algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) (MvPolynomial.X i) ≠ 0 :=
-  fun h => MvPolynomial.X_ne_zero i
-    ((FaithfulSMul.algebraMap_injective _ _) (h.trans (map_zero _).symm))
-
-noncomputable def planeChartToFraction (i : Fin 2) :
-    planeCoordinateChart k i →ₐ[k] planeFractionField k :=
-  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeFractionField k))
-    (isUnit_iff_ne_zero.mpr (planeFractionCoordinate_ne_zero k i))
-
-lemma planeChartToFraction_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
-    planeChartToFraction k i
-      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
-      algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P :=
-  IsLocalization.Away.lift_eq _ (isUnit_iff_ne_zero.mpr (planeFractionCoordinate_ne_zero k i)) _
-
-lemma planeChartToFraction_injective (i : Fin 2) :
-    Function.Injective (planeChartToFraction k i) := by
-  apply (IsLocalization.injective_iff_map_algebraMap_eq
-    (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
-    (planeChartToFraction k i).toRingHom).mpr
-  intro P Q
-  constructor
-  · exact congrArg (planeChartToFraction k i)
-  · intro h
-    have h' : algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P =
-        algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) Q := by
-      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe, planeChartToFraction_algebraMap] using h
-    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i))
-      ((FaithfulSMul.algebraMap_injective _ _) h')
-
-noncomputable def planeChartToFractionLinear (i : Fin 2) :
-    planeCoordinateChart k i →ₗ[MvPolynomial (Fin 2) k] planeFractionField k where
-  toFun := planeChartToFraction k i
-  map_add' := (planeChartToFraction k i).map_add
-  map_smul' := by
-    intro P f
-    simp only [Algebra.smul_def, map_mul, planeChartToFraction_algebraMap,
-      RingHom.id_apply]
-
-noncomputable def planeOverlapToFraction : planeOverlapRing k →ₐ[k] planeFractionField k :=
-  IsLocalization.Away.liftAlgHom (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)
-    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeFractionField k))
-    (isUnit_iff_ne_zero.mpr (by
-      change algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-        (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0
-      rw [map_mul]
-      exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)))
-
-lemma planeOverlapToFraction_algebraMap (P : MvPolynomial (Fin 2) k) :
-    planeOverlapToFraction k
-      (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P) =
-      algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P := by
-  unfold planeOverlapToFraction
-  rw [IsLocalization.Away.liftAlgHom_apply, IsLocalization.Away.lift_eq]
-  rfl
-
-lemma planeChartToFraction_overlap (i : Fin 2) (f : planeCoordinateChart k i) :
-    planeOverlapToFraction k (planeChartToOverlap k i f) = planeChartToFraction k i f := by
-  have h : (planeOverlapToFraction k).toRingHom.comp (planeChartToOverlap k i).toRingHom =
-      (planeChartToFraction k i).toRingHom := by
-    apply IsLocalization.ringHom_ext
-      (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
-    apply RingHom.ext
-    intro P
-    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
-      planeChartToOverlap_algebraMap, planeChartToFraction_algebraMap,
-      planeOverlapToFraction_algebraMap]
-  exact RingHom.congr_fun h f
-
-noncomputable def planeOverlapInverse : planeOverlapRing k :=
-  IsLocalization.Away.invSelf (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)
-
-lemma planeOverlapInverse_evaluation (x : planeTorusPoints k) :
-    planeOverlapEvaluation k (planeOverlapInverse k) x = (x.val 0 * x.val 1)⁻¹ := by
-  have h := congrFun (congrArg (planeOverlapEvaluation k)
-    (IsLocalization.Away.mul_invSelf (S := planeOverlapRing k)
-      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k))) x
-  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
-    planeOverlapEvaluation_algebraMap, planeTorusEvaluation_apply,
-    MvPolynomial.eval_X] at h
-  exact mul_left_cancel₀ (mul_ne_zero (x.property 0) (x.property 1))
-    (h.trans (mul_inv_cancel₀ (mul_ne_zero (x.property 0) (x.property 1))).symm)
-
-lemma planeOverlapInverse_fraction :
-    planeOverlapToFraction k (planeOverlapInverse k) =
-      (algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-        (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹ := by
-  have h := congrArg (planeOverlapToFraction k)
-    (IsLocalization.Away.mul_invSelf (S := planeOverlapRing k)
-      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k))
-  simp only [map_mul, map_one, planeOverlapToFraction_algebraMap] at h
-  have hn : algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-      (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0 := by
-    rw [map_mul]
-    exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)
-  apply mul_left_cancel₀ hn
-  rw [mul_inv_cancel₀ hn]
-  simpa only [map_mul, planeOverlapInverse] using h
-
-variable {ι : Type*} [Fintype ι] [DecidableEq ι]
-
-omit [DecidableEq ι] in
-lemma planeChartVector_mem (a : Fin 2) (f : ι → planeCoordinateChart k a) :
-    (fun i => planeChartToFraction k a (f i)) ∈
-      powerLocalization (MvPolynomial.X a : MvPolynomial (Fin 2) k) coordinateLattice := by
-  obtain ⟨s,hs⟩ := IsLocalization.exist_integer_multiples
-    (Submonoid.powers (MvPolynomial.X a : MvPolynomial (Fin 2) k)) Finset.univ f
-  obtain ⟨n,hn⟩ := s.property
-  refine ⟨n, (mem_coordinateLattice _).mpr fun i => ?_⟩
-  obtain ⟨b,hb⟩ := hs i (Finset.mem_univ i)
-  refine ⟨b,?_⟩
-  have h := congrArg (planeChartToFraction k a) hb
-  rw [planeChartToFraction_algebraMap] at h
-  change _ = planeChartToFraction k a (s.val • f i) at h
-  rw [← hn] at h
-  exact h.trans ((planeChartToFractionLinear k a).map_smul (MvPolynomial.X a ^ n) (f i))
-
-variable [Infinite k]
-variable (P : Matrix ι ι (Polynomial k))
-
-omit [DecidableEq ι] in
-lemma planeChartPair_fraction_relation
-    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
-    (hf : ∀ x : planeTorusPoints k,
-      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
-        (polynomialMatrixEval P ((x.val 0 * x.val 1)⁻¹)).mulVec
-          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
-    (fun i => planeChartToFraction k 1 (f₁ i)) =
-      (polynomialMatrixEval P ((algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-        (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹)).mulVec
-          (fun i => planeChartToFraction k 0 (f₀ i)) := by
-  have hov (i : ι) : planeChartToOverlap k 1 (f₁ i) =
-      ∑ j, Polynomial.aeval (planeOverlapInverse k) (P i j) * planeChartToOverlap k 0 (f₀ j) := by
-    apply planeOverlapEvaluation_injective k
-    funext x
-    let ev : planeOverlapRing k →ₐ[k] k :=
-      (Pi.evalAlgHom k _ x).comp (planeOverlapEvaluation k)
-    change ev (planeChartToOverlap k 1 (f₁ i)) = ev _
-    simp only [map_sum, map_mul, map_aeval_polynomial]
-    change planeOverlapEvaluation k (planeChartToOverlap k 1 (f₁ i)) x =
-      ∑ j, Polynomial.aeval (planeOverlapEvaluation k (planeOverlapInverse k) x) (P i j) *
-        planeOverlapEvaluation k (planeChartToOverlap k 0 (f₀ j)) x
-    simp only [planeChartToOverlap_evaluation, planeOverlapInverse_evaluation]
-    exact congrFun (hf x) i
-  funext i
-  have h := congrArg (planeOverlapToFraction k) (hov i)
-  simpa only [map_sum, map_mul, map_aeval_polynomial, planeChartToFraction_overlap,
-    planeOverlapInverse_fraction, Matrix.mulVec, dotProduct, polynomialMatrixEval] using h
-
-variable (h0 : polynomialMatrixEval P (0 : k) = 1)
-    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
-      polynomialMatrixEval P s * polynomialMatrixEval P t)
-
-noncomputable def planeGlobalTransition :
-    (ι → planeFractionField k) ≃ₗ[planeFractionField k] (ι → planeFractionField k) :=
-  polynomialActionEquiv P h0 hadd
-    (-(algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-      (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹)
-
-noncomputable def planeGlobalLattice :
-    Submodule (MvPolynomial (Fin 2) k) (ι → planeFractionField k) :=
-  gluedLattice (MvPolynomial.X 0) (MvPolynomial.X 1) (planeGlobalTransition k P h0 hadd)
-
-omit [Infinite k] in
-lemma planeFraction_product_ne_zero :
-    algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
-      (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0 := by
-  rw [map_mul]
-  exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)
-
-lemma planeGlobalTransition_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    ∀ v ∈ coordinateLattice (R := MvPolynomial (Fin 2) k),
-      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)^d •
-        planeGlobalTransition k P h0 hadd v ∈ coordinateLattice (R := MvPolynomial (Fin 2) k) :=
-  polynomialAction_denominator P h0 hadd _ (planeFraction_product_ne_zero k) d hd
-
-lemma planeGlobalLattice_finite (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    Module.Finite (MvPolynomial (Fin 2) k) (planeGlobalLattice k P h0 hadd) :=
-  gluedLattice_finite _ _ (MvPolynomial.X_ne_zero 0) (planeCoordinates_relPrime k) _ d
-    (planeGlobalTransition_denominator k P h0 hadd d hd)
-
-lemma planeChartPair_mem_globalLattice
-    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
-    (hf : ∀ x : planeTorusPoints k,
-      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
-        (polynomialMatrixEval P ((x.val 0 * x.val 1)⁻¹)).mulVec
-          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
-    (fun i => planeChartToFraction k 0 (f₀ i)) ∈ planeGlobalLattice k P h0 hadd := by
-  constructor
-  · exact planeChartVector_mem k 0 f₀
-  · refine ⟨fun i => planeChartToFraction k 1 (f₁ i), planeChartVector_mem k 1 f₁, ?_⟩
-    have h := planeChartPair_fraction_relation k P f₀ f₁ hf
-    change planeGlobalTransition k P h0 hadd (fun i => planeChartToFraction k 1 (f₁ i)) = _
-    rw [h]
-    change (polynomialMatrixEval P (-_)).mulVec ((polynomialMatrixEval P _).mulVec _) = _
-    rw [Matrix.mulVec_mulVec, ← polynomialMatrixEval_add P hadd, neg_add_cancel,
-      polynomialMatrixEval_zero P h0, Matrix.one_mulVec]
-
-end
-
-section
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-variable (P : Matrix ι ι (Polynomial k))
-variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-
-omit [Infinite k] in
-include hP in
-lemma associatedPolynomial_zero : polynomialMatrixEval P (0 : k) = 1 := by
-  rw [hP]
-  change LinearMap.toMatrix' (ρ 1) = 1
-  rw [map_one]
-  exact LinearMap.toMatrix'_one
-
-omit [Infinite k] in
-include hP in
-lemma associatedPolynomial_add (s t : k) : polynomialMatrixEval P (s+t) =
-    polynomialMatrixEval P s * polynomialMatrixEval P t := by
-  rw [hP, hP, hP]
-  change LinearMap.toMatrix' (ρ (Multiplicative.ofAdd s * Multiplicative.ofAdd t)) = _
-  rw [map_mul, LinearMap.toMatrix'_mul]
-
-noncomputable def associatedFractionChart :
-    (associatedSectionsSubmodule k ι ρ) →ₗ[MvPolynomial (Fin 2) k]
-      (ι → planeFractionField k) :=
-  (LinearMap.pi fun i => (planeChartToFractionLinear k 0).comp
-    (LinearMap.proj i)).comp (associatedXChartPolynomial k ι ρ)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedFractionChart_injective : Function.Injective (associatedFractionChart k ι ρ) := by
-  intro f g h
-  apply associatedXChart_injective k ι ρ
-  funext i
-  exact planeChartToFraction_injective k 0 (congrFun h i)
-
-lemma associatedFractionChart_mem (f : associatedSectionsSubmodule k ι ρ) :
-    associatedFractionChart k ι ρ f ∈ planeGlobalLattice k P
-      (associatedPolynomial_zero k ι ρ P hP) (associatedPolynomial_add k ι ρ P hP) := by
-  apply planeChartPair_mem_globalLattice k P _ _
-    (associatedXChart k ι ρ f) (associatedYChart k ι ρ f)
-  intro x
-  rw [hP, LinearMap.toMatrix'_mulVec]
-  exact associatedCharts_transition k ι ρ f x
-
-include hP in
- 
-
-theorem associatedSections_finite (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    Module.Finite (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) := by
-  let L := planeGlobalLattice k P
-    (associatedPolynomial_zero k ι ρ P hP) (associatedPolynomial_add k ι ρ P hP)
-  let : Module.Finite (MvPolynomial (Fin 2) k) L :=
-    planeGlobalLattice_finite k P _ _ d hd
-  let f := (associatedFractionChart k ι ρ).codRestrict L
-    (associatedFractionChart_mem k ι ρ P hP)
-  exact Module.Finite.of_injective f fun a b h =>
-    associatedFractionChart_injective k ι ρ (congrArg Subtype.val h)
-
-end
-
-variable {k M σ : Type*} [Field k] [AddCommGroup M] [Module k M]
-  [Module (MvPolynomial σ k) M] [IsScalarTower k (MvPolynomial σ k) M]
-
-lemma originQuotient_polynomial_smul (N : Submodule k M)
-    (hX : ∀ (i : σ) (m : M), (MvPolynomial.X i : MvPolynomial σ k) • m ∈ N)
-    (P : MvPolynomial σ k) (m : M) :
-    N.mkQ (P • m) = MvPolynomial.constantCoeff P • N.mkQ m := by
-  induction P using MvPolynomial.induction_on with
-  | C a =>
-    rw [MvPolynomial.constantCoeff_C]
-    change N.mkQ (algebraMap k (MvPolynomial σ k) a • m) = a • N.mkQ m
-    rw [algebraMap_smul, map_smul]
-  | add P Q hP hQ => simp only [add_smul, map_add, hP, hQ]
-  | mul_X P i _ =>
-    rw [mul_comm, mul_smul]
-    have hz : N.mkQ ((MvPolynomial.X i : MvPolynomial σ k) • (P • m)) = 0 :=
-      (Submodule.Quotient.mk_eq_zero N).mpr (hX i (P • m))
-    simpa using hz
-
- 
-
-theorem originQuotient_finite (N : Submodule k M)
-    (hX : ∀ (i : σ) (m : M), (MvPolynomial.X i : MvPolynomial σ k) • m ∈ N)
-    [Module.Finite (MvPolynomial σ k) M] : Module.Finite k (M ⧸ N) := by
-  let f : M →ₛₗ[MvPolynomial.constantCoeff] (M ⧸ N) :=
-    { toFun := N.mkQ
-      map_add' := N.mkQ.map_add
-      map_smul' := originQuotient_polynomial_smul N hX }
-  exact Module.Finite.of_surjective f N.mkQ_surjective
-
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.OriginCoordinates
+
+namespace OAI
+
+/-! Fraction charts, global lattices and finite origin quotients. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+variable (k : Type*) [Field k]
+abbrev planeFractionField := FractionRing (MvPolynomial (Fin 2) k)
+
+noncomputable instance planeCoordinateRing_gcd : GCDMonoid (MvPolynomial (Fin 2) k) :=
+  UniqueFactorizationMonoid.toGCDMonoid _
+
+lemma planeCoordinates_relPrime :
+    IsRelPrime (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) := by
+  apply (MvPolynomial.X_prime (R := k) (i := (0 : Fin 2))).irreducible.isRelPrime_iff_not_dvd.mpr
+  intro h
+  exact (by decide : (0 : Fin 2) ≠ 1) (MvPolynomial.X_dvd_X.mp h)
+
+lemma planeFractionCoordinate_ne_zero (i : Fin 2) :
+    algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) (MvPolynomial.X i) ≠ 0 :=
+  fun h => MvPolynomial.X_ne_zero i
+    ((FaithfulSMul.algebraMap_injective _ _) (h.trans (map_zero _).symm))
+
+noncomputable def planeChartToFraction (i : Fin 2) :
+    planeCoordinateChart k i →ₐ[k] planeFractionField k :=
+  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeFractionField k))
+    (isUnit_iff_ne_zero.mpr (planeFractionCoordinate_ne_zero k i))
+
+lemma planeChartToFraction_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
+    planeChartToFraction k i
+      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
+      algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P :=
+  IsLocalization.Away.lift_eq _ (isUnit_iff_ne_zero.mpr (planeFractionCoordinate_ne_zero k i)) _
+
+lemma planeChartToFraction_injective (i : Fin 2) :
+    Function.Injective (planeChartToFraction k i) := by
+  apply (IsLocalization.injective_iff_map_algebraMap_eq
+    (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
+    (planeChartToFraction k i).toRingHom).mpr
+  intro P Q
+  constructor
+  · exact congrArg (planeChartToFraction k i)
+  · intro h
+    have h' : algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P =
+        algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) Q := by
+      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe, planeChartToFraction_algebraMap] using h
+    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i))
+      ((FaithfulSMul.algebraMap_injective _ _) h')
+
+noncomputable def planeChartToFractionLinear (i : Fin 2) :
+    planeCoordinateChart k i →ₗ[MvPolynomial (Fin 2) k] planeFractionField k where
+  toFun := planeChartToFraction k i
+  map_add' := (planeChartToFraction k i).map_add
+  map_smul' := by
+    intro P f
+    simp only [Algebra.smul_def, map_mul, planeChartToFraction_algebraMap,
+      RingHom.id_apply]
+
+noncomputable def planeOverlapToFraction : planeOverlapRing k →ₐ[k] planeFractionField k :=
+  IsLocalization.Away.liftAlgHom (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)
+    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeFractionField k))
+    (isUnit_iff_ne_zero.mpr (by
+      change algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+        (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0
+      rw [map_mul]
+      exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)))
+
+lemma planeOverlapToFraction_algebraMap (P : MvPolynomial (Fin 2) k) :
+    planeOverlapToFraction k
+      (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P) =
+      algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k) P := by
+  unfold planeOverlapToFraction
+  rw [IsLocalization.Away.liftAlgHom_apply, IsLocalization.Away.lift_eq]
+  rfl
+
+lemma planeChartToFraction_overlap (i : Fin 2) (f : planeCoordinateChart k i) :
+    planeOverlapToFraction k (planeChartToOverlap k i f) = planeChartToFraction k i f := by
+  have h : (planeOverlapToFraction k).toRingHom.comp (planeChartToOverlap k i).toRingHom =
+      (planeChartToFraction k i).toRingHom := by
+    apply IsLocalization.ringHom_ext
+      (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
+    apply RingHom.ext
+    intro P
+    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+      planeChartToOverlap_algebraMap, planeChartToFraction_algebraMap,
+      planeOverlapToFraction_algebraMap]
+  exact RingHom.congr_fun h f
+
+noncomputable def planeOverlapInverse : planeOverlapRing k :=
+  IsLocalization.Away.invSelf (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)
+
+lemma planeOverlapInverse_evaluation (x : planeTorusPoints k) :
+    planeOverlapEvaluation k (planeOverlapInverse k) x = (x.val 0 * x.val 1)⁻¹ := by
+  have h := congrFun (congrArg (planeOverlapEvaluation k)
+    (IsLocalization.Away.mul_invSelf (S := planeOverlapRing k)
+      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k))) x
+  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
+    planeOverlapEvaluation_algebraMap, planeTorusEvaluation_apply,
+    MvPolynomial.eval_X] at h
+  exact mul_left_cancel₀ (mul_ne_zero (x.property 0) (x.property 1))
+    (h.trans (mul_inv_cancel₀ (mul_ne_zero (x.property 0) (x.property 1))).symm)
+
+lemma planeOverlapInverse_fraction :
+    planeOverlapToFraction k (planeOverlapInverse k) =
+      (algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+        (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹ := by
+  have h := congrArg (planeOverlapToFraction k)
+    (IsLocalization.Away.mul_invSelf (S := planeOverlapRing k)
+      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k))
+  simp only [map_mul, map_one, planeOverlapToFraction_algebraMap] at h
+  have hn : algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+      (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0 := by
+    rw [map_mul]
+    exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)
+  apply mul_left_cancel₀ hn
+  rw [mul_inv_cancel₀ hn]
+  simpa only [map_mul, planeOverlapInverse] using h
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+omit [DecidableEq ι] in
+lemma planeChartVector_mem (a : Fin 2) (f : ι → planeCoordinateChart k a) :
+    (fun i => planeChartToFraction k a (f i)) ∈
+      powerLocalization (MvPolynomial.X a : MvPolynomial (Fin 2) k) coordinateLattice := by
+  obtain ⟨s,hs⟩ := IsLocalization.exist_integer_multiples
+    (Submonoid.powers (MvPolynomial.X a : MvPolynomial (Fin 2) k)) Finset.univ f
+  obtain ⟨n,hn⟩ := s.property
+  refine ⟨n, (mem_coordinateLattice _).mpr fun i => ?_⟩
+  obtain ⟨b,hb⟩ := hs i (Finset.mem_univ i)
+  refine ⟨b,?_⟩
+  have h := congrArg (planeChartToFraction k a) hb
+  rw [planeChartToFraction_algebraMap] at h
+  change _ = planeChartToFraction k a (s.val • f i) at h
+  rw [← hn] at h
+  exact h.trans ((planeChartToFractionLinear k a).map_smul (MvPolynomial.X a ^ n) (f i))
+
+variable [Infinite k]
+variable (P : Matrix ι ι (Polynomial k))
+
+omit [DecidableEq ι] in
+lemma planeChartPair_fraction_relation
+    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
+    (hf : ∀ x : planeTorusPoints k,
+      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
+        (polynomialMatrixEval P ((x.val 0 * x.val 1)⁻¹)).mulVec
+          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
+    (fun i => planeChartToFraction k 1 (f₁ i)) =
+      (polynomialMatrixEval P ((algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+        (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹)).mulVec
+          (fun i => planeChartToFraction k 0 (f₀ i)) := by
+  have hov (i : ι) : planeChartToOverlap k 1 (f₁ i) =
+      ∑ j, Polynomial.aeval (planeOverlapInverse k) (P i j) * planeChartToOverlap k 0 (f₀ j) := by
+    apply planeOverlapEvaluation_injective k
+    funext x
+    let ev : planeOverlapRing k →ₐ[k] k :=
+      (Pi.evalAlgHom k _ x).comp (planeOverlapEvaluation k)
+    change ev (planeChartToOverlap k 1 (f₁ i)) = ev _
+    simp only [map_sum, map_mul, map_aeval_polynomial]
+    change planeOverlapEvaluation k (planeChartToOverlap k 1 (f₁ i)) x =
+      ∑ j, Polynomial.aeval (planeOverlapEvaluation k (planeOverlapInverse k) x) (P i j) *
+        planeOverlapEvaluation k (planeChartToOverlap k 0 (f₀ j)) x
+    simp only [planeChartToOverlap_evaluation, planeOverlapInverse_evaluation]
+    exact congrFun (hf x) i
+  funext i
+  have h := congrArg (planeOverlapToFraction k) (hov i)
+  simpa only [map_sum, map_mul, map_aeval_polynomial, planeChartToFraction_overlap,
+    planeOverlapInverse_fraction, Matrix.mulVec, dotProduct, polynomialMatrixEval] using h
+
+variable (h0 : polynomialMatrixEval P (0 : k) = 1)
+    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
+      polynomialMatrixEval P s * polynomialMatrixEval P t)
+
+noncomputable def planeGlobalTransition :
+    (ι → planeFractionField k) ≃ₗ[planeFractionField k] (ι → planeFractionField k) :=
+  polynomialActionEquiv P h0 hadd
+    (-(algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+      (MvPolynomial.X 0 * MvPolynomial.X 1))⁻¹)
+
+noncomputable def planeGlobalLattice :
+    Submodule (MvPolynomial (Fin 2) k) (ι → planeFractionField k) :=
+  gluedLattice (MvPolynomial.X 0) (MvPolynomial.X 1) (planeGlobalTransition k P h0 hadd)
+
+omit [Infinite k] in
+lemma planeFraction_product_ne_zero :
+    algebraMap (MvPolynomial (Fin 2) k) (planeFractionField k)
+      (MvPolynomial.X 0 * MvPolynomial.X 1) ≠ 0 := by
+  rw [map_mul]
+  exact mul_ne_zero (planeFractionCoordinate_ne_zero k 0) (planeFractionCoordinate_ne_zero k 1)
+
+lemma planeGlobalTransition_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    ∀ v ∈ coordinateLattice (R := MvPolynomial (Fin 2) k),
+      (MvPolynomial.X 0 * MvPolynomial.X 1 : MvPolynomial (Fin 2) k)^d •
+        planeGlobalTransition k P h0 hadd v ∈ coordinateLattice (R := MvPolynomial (Fin 2) k) :=
+  polynomialAction_denominator P h0 hadd _ (planeFraction_product_ne_zero k) d hd
+
+lemma planeGlobalLattice_finite (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    Module.Finite (MvPolynomial (Fin 2) k) (planeGlobalLattice k P h0 hadd) :=
+  gluedLattice_finite _ _ (MvPolynomial.X_ne_zero 0) (planeCoordinates_relPrime k) _ d
+    (planeGlobalTransition_denominator k P h0 hadd d hd)
+
+lemma planeChartPair_mem_globalLattice
+    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
+    (hf : ∀ x : planeTorusPoints k,
+      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
+        (polynomialMatrixEval P ((x.val 0 * x.val 1)⁻¹)).mulVec
+          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
+    (fun i => planeChartToFraction k 0 (f₀ i)) ∈ planeGlobalLattice k P h0 hadd := by
+  constructor
+  · exact planeChartVector_mem k 0 f₀
+  · refine ⟨fun i => planeChartToFraction k 1 (f₁ i), planeChartVector_mem k 1 f₁, ?_⟩
+    have h := planeChartPair_fraction_relation k P f₀ f₁ hf
+    change planeGlobalTransition k P h0 hadd (fun i => planeChartToFraction k 1 (f₁ i)) = _
+    rw [h]
+    change (polynomialMatrixEval P (-_)).mulVec ((polynomialMatrixEval P _).mulVec _) = _
+    rw [Matrix.mulVec_mulVec, ← polynomialMatrixEval_add P hadd, neg_add_cancel,
+      polynomialMatrixEval_zero P h0, Matrix.one_mulVec]
+
+end
+
+section
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+variable (P : Matrix ι ι (Polynomial k))
+variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+
+omit [Infinite k] in
+include hP in
+lemma associatedPolynomial_zero : polynomialMatrixEval P (0 : k) = 1 := by
+  rw [hP]
+  change LinearMap.toMatrix' (ρ 1) = 1
+  rw [map_one]
+  exact LinearMap.toMatrix'_one
+
+omit [Infinite k] in
+include hP in
+lemma associatedPolynomial_add (s t : k) : polynomialMatrixEval P (s+t) =
+    polynomialMatrixEval P s * polynomialMatrixEval P t := by
+  rw [hP, hP, hP]
+  change LinearMap.toMatrix' (ρ (Multiplicative.ofAdd s * Multiplicative.ofAdd t)) = _
+  rw [map_mul, LinearMap.toMatrix'_mul]
+
+noncomputable def associatedFractionChart :
+    (associatedSectionsSubmodule k ι ρ) →ₗ[MvPolynomial (Fin 2) k]
+      (ι → planeFractionField k) :=
+  (LinearMap.pi fun i => (planeChartToFractionLinear k 0).comp
+    (LinearMap.proj i)).comp (associatedXChartPolynomial k ι ρ)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedFractionChart_injective : Function.Injective (associatedFractionChart k ι ρ) := by
+  intro f g h
+  apply associatedXChart_injective k ι ρ
+  funext i
+  exact planeChartToFraction_injective k 0 (congrFun h i)
+
+lemma associatedFractionChart_mem (f : associatedSectionsSubmodule k ι ρ) :
+    associatedFractionChart k ι ρ f ∈ planeGlobalLattice k P
+      (associatedPolynomial_zero k ι ρ P hP) (associatedPolynomial_add k ι ρ P hP) := by
+  apply planeChartPair_mem_globalLattice k P _ _
+    (associatedXChart k ι ρ f) (associatedYChart k ι ρ f)
+  intro x
+  rw [hP, LinearMap.toMatrix'_mulVec]
+  exact associatedCharts_transition k ι ρ f x
+
+include hP in
+ 
+
+theorem associatedSections_finite (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    Module.Finite (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) := by
+  let L := planeGlobalLattice k P
+    (associatedPolynomial_zero k ι ρ P hP) (associatedPolynomial_add k ι ρ P hP)
+  let : Module.Finite (MvPolynomial (Fin 2) k) L :=
+    planeGlobalLattice_finite k P _ _ d hd
+  let f := (associatedFractionChart k ι ρ).codRestrict L
+    (associatedFractionChart_mem k ι ρ P hP)
+  exact Module.Finite.of_injective f fun a b h =>
+    associatedFractionChart_injective k ι ρ (congrArg Subtype.val h)
+
+end
+
+variable {k M σ : Type*} [Field k] [AddCommGroup M] [Module k M]
+  [Module (MvPolynomial σ k) M] [IsScalarTower k (MvPolynomial σ k) M]
+
+lemma originQuotient_polynomial_smul (N : Submodule k M)
+    (hX : ∀ (i : σ) (m : M), (MvPolynomial.X i : MvPolynomial σ k) • m ∈ N)
+    (P : MvPolynomial σ k) (m : M) :
+    N.mkQ (P • m) = MvPolynomial.constantCoeff P • N.mkQ m := by
+  induction P using MvPolynomial.induction_on with
+  | C a =>
+    rw [MvPolynomial.constantCoeff_C]
+    change N.mkQ (algebraMap k (MvPolynomial σ k) a • m) = a • N.mkQ m
+    rw [algebraMap_smul, map_smul]
+  | add P Q hP hQ => simp only [add_smul, map_add, hP, hQ]
+  | mul_X P i _ =>
+    rw [mul_comm, mul_smul]
+    have hz : N.mkQ ((MvPolynomial.X i : MvPolynomial σ k) • (P • m)) = 0 :=
+      (Submodule.Quotient.mk_eq_zero N).mpr (hX i (P • m))
+    simpa using hz
+
+ 
+
+theorem originQuotient_finite (N : Submodule k M)
+    (hX : ∀ (i : σ) (m : M), (MvPolynomial.X i : MvPolynomial σ k) • m ∈ N)
+    [Module.Finite (MvPolynomial σ k) M] : Module.Finite k (M ⧸ N) := by
+  let f : M →ₛₗ[MvPolynomial.constantCoeff] (M ⧸ N) :=
+    { toFun := N.mkQ
+      map_add' := N.mkQ.map_add
+      map_smul' := originQuotient_polynomial_smul N hX }
+  exact Module.Finite.of_surjective f N.mkQ_surjective
+
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/GoodKernel.lean

@@ -1,104 +1,104 @@
-import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-universe u
-variable (k : Type u) [Field k]
-
- 
-def HasGoodKernel {P A : FDRep k (SL2 k)} (g : P ⟶ A) : Prop :=
-  ∃ (K : FDRep k (SL2 k)) (i : K ⟶ P) (w : i ≫ g = 0),
-    (ShortComplex.mk i g w).ShortExact ∧ HasGoodFiltration k K
-
-lemma HasGoodKernel.epi {P A : FDRep k (SL2 k)} {g : P ⟶ A}
-    (h : HasGoodKernel k g) : Epi g := by
-  obtain ⟨K,i,w,hs,hK⟩ := h
-  exact hs.epi_g
-
-lemma fdrepKernel_shortExact {P A : FDRep k (SL2 k)} (g : P ⟶ A)
-    (hg : Function.Surjective (fdrepLinear k g)) :
-    (ShortComplex.mk (fdrepKernelι k g) g (by
-      apply fdrep_hom_ext k; intro x; exact x.property)).ShortExact := by
-  apply fdrep_shortExact k _ Subtype.val_injective hg
-  exact Submodule.range_subtype _
-
-lemma HasGoodKernel.id (A : FDRep k (SL2 k)) : HasGoodKernel k (𝟙 A) := by
-  refine ⟨fdrepKernel k (𝟙 A), fdrepKernelι k (𝟙 A), ?_, ?_, ?_⟩
-  · apply fdrep_hom_ext k; intro x; exact x.property
-  · exact fdrepKernel_shortExact k (𝟙 A) Function.surjective_id
-  · have : Subsingleton (fdrepKernel k (𝟙 A)) := by
-      apply subsingleton_of_forall_eq 0
-      intro x
-      apply Subtype.ext
-      exact x.property
-    exact .zero _ (fdrep_isZero_of_subsingleton k _)
-
-lemma HasGoodKernel.comp {P A B : FDRep k (SL2 k)} {g : P ⟶ A} {h : A ⟶ B}
-    (hg : HasGoodKernel k g) (hh : HasGoodKernel k h) : HasGoodKernel k (g ≫ h) := by
-  obtain ⟨K,i,w,hS,hK⟩ := hg
-  obtain ⟨L,j,v,hT,hL⟩ := hh
-  obtain ⟨N,a,b,c,wab,wc,hN,hC⟩ := fdrep_splice k i g w hS j h v hT
-  exact ⟨N,c,wc,hC,hK.extension k hL a b wab hN⟩
-
-lemma HasGoodKernel.tensor_right {P A : FDRep k (SL2 k)} {g : P ⟶ A}
-    (hg : HasGoodKernel k g) (B : FDRep k (SL2 k)) (hB : HasGoodFiltration k B) :
-    HasGoodKernel k ((tensorRight B).map g) := by
-  obtain ⟨K,i,w,hS,hK⟩ := hg
-  let := tensorRight_preservesFiniteLimits B
-  let := tensorRight_preservesFiniteColimits B
-  exact ⟨K ⊗ B, (tensorRight B).map i, (by rw [← Functor.map_comp, w, Functor.map_zero]),
-    hS.map_of_exact (tensorRight B), hK.tensor k hB⟩
-
-lemma HasGoodKernel.split [Infinite k] {P A : FDRep k (SL2 k)} {g : P ⟶ A}
-    (hg : HasGoodKernel k g) (hP : IsRational k P.ρ) (hA : IsTilting k A) :
-    ∃ s : A ⟶ P, s ≫ g = 𝟙 A := by
-  obtain ⟨K,i,w,hS,hK⟩ := hg
-  exact good_weyl_extension_split k hK hA.2.2 P hP i g w hS
-
-lemma HasGoodKernel.of_isIso {P A : FDRep k (SL2 k)} (g : P ⟶ A) [IsIso g] :
-    HasGoodKernel k g := by
-  refine ⟨fdrepKernel k g, fdrepKernelι k g, ?_, ?_, ?_⟩
-  · apply fdrep_hom_ext k; intro x; exact x.property
-  · exact fdrepKernel_shortExact k g (fdrep_surjective k g)
-  · have : Subsingleton (fdrepKernel k g) := by
-      apply subsingleton_of_forall_eq 0
-      intro x
-      apply Subtype.ext
-      apply fdrep_injective k g
-      exact x.property.trans (map_zero _).symm
-    exact .zero _ (fdrep_isZero_of_subsingleton k _)
-
- 
-lemma costandardMultiply_goodKernel (a b : ℕ) : HasGoodKernel k (costandardMultiply k a b) := by
-  rcases a with _ | a
-  · have := costandardMultiply_isIso_of_zero k 0 b (Or.inl rfl)
-    exact HasGoodKernel.of_isIso k _
-  · rcases b with _ | b
-    · have := costandardMultiply_isIso_of_zero k (a+1) 0 (Or.inr rfl)
-      exact HasGoodKernel.of_isIso k _
-    · exact ⟨_, costandardDeterminant k a b, costandardDeterminant_multiply k a b,
-        costandardTensorSequence_shortExact k a b, costandard_tensor_hasGoodFiltration k a b⟩
-
-lemma HasGoodKernel.kernel_good {P A : FDRep k (SL2 k)} {g : P ⟶ A}
-    (hg : HasGoodKernel k g) : HasGoodFiltration k (fdrepKernel k g) := by
-  obtain ⟨K,i,w,hS,hK⟩ := hg
-  have := hS.mono_f
-  let j := fdrepKernelLift k i g w
-  have hj : Function.Bijective (fdrepLinear k j) := by
-    constructor
-    · intro x y h
-      apply fdrep_injective k i
-      exact congrArg Subtype.val h
-    · intro x
-      have hx : x.val ∈ LinearMap.range (fdrepLinear k i) := by
-        rw [fdrep_exact k hS.exact]
-        exact x.property
-      obtain ⟨v,hv⟩ := hx
-      exact ⟨v,Subtype.ext hv⟩
-  have := fdrepHom_isIso_of_bijective k j hj
-  exact hK.of_iso k (asIso j)
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+universe u
+variable (k : Type u) [Field k]
+
+ 
+def HasGoodKernel {P A : FDRep k (SL2 k)} (g : P ⟶ A) : Prop :=
+  ∃ (K : FDRep k (SL2 k)) (i : K ⟶ P) (w : i ≫ g = 0),
+    (ShortComplex.mk i g w).ShortExact ∧ HasGoodFiltration k K
+
+lemma HasGoodKernel.epi {P A : FDRep k (SL2 k)} {g : P ⟶ A}
+    (h : HasGoodKernel k g) : Epi g := by
+  obtain ⟨K,i,w,hs,hK⟩ := h
+  exact hs.epi_g
+
+lemma fdrepKernel_shortExact {P A : FDRep k (SL2 k)} (g : P ⟶ A)
+    (hg : Function.Surjective (fdrepLinear k g)) :
+    (ShortComplex.mk (fdrepKernelι k g) g (by
+      apply fdrep_hom_ext k; intro x; exact x.property)).ShortExact := by
+  apply fdrep_shortExact k _ Subtype.val_injective hg
+  exact Submodule.range_subtype _
+
+lemma HasGoodKernel.id (A : FDRep k (SL2 k)) : HasGoodKernel k (𝟙 A) := by
+  refine ⟨fdrepKernel k (𝟙 A), fdrepKernelι k (𝟙 A), ?_, ?_, ?_⟩
+  · apply fdrep_hom_ext k; intro x; exact x.property
+  · exact fdrepKernel_shortExact k (𝟙 A) Function.surjective_id
+  · have : Subsingleton (fdrepKernel k (𝟙 A)) := by
+      apply subsingleton_of_forall_eq 0
+      intro x
+      apply Subtype.ext
+      exact x.property
+    exact .zero _ (fdrep_isZero_of_subsingleton k _)
+
+lemma HasGoodKernel.comp {P A B : FDRep k (SL2 k)} {g : P ⟶ A} {h : A ⟶ B}
+    (hg : HasGoodKernel k g) (hh : HasGoodKernel k h) : HasGoodKernel k (g ≫ h) := by
+  obtain ⟨K,i,w,hS,hK⟩ := hg
+  obtain ⟨L,j,v,hT,hL⟩ := hh
+  obtain ⟨N,a,b,c,wab,wc,hN,hC⟩ := fdrep_splice k i g w hS j h v hT
+  exact ⟨N,c,wc,hC,hK.extension k hL a b wab hN⟩
+
+lemma HasGoodKernel.tensor_right {P A : FDRep k (SL2 k)} {g : P ⟶ A}
+    (hg : HasGoodKernel k g) (B : FDRep k (SL2 k)) (hB : HasGoodFiltration k B) :
+    HasGoodKernel k ((tensorRight B).map g) := by
+  obtain ⟨K,i,w,hS,hK⟩ := hg
+  let := tensorRight_preservesFiniteLimits B
+  let := tensorRight_preservesFiniteColimits B
+  exact ⟨K ⊗ B, (tensorRight B).map i, (by rw [← Functor.map_comp, w, Functor.map_zero]),
+    hS.map_of_exact (tensorRight B), hK.tensor k hB⟩
+
+lemma HasGoodKernel.split [Infinite k] {P A : FDRep k (SL2 k)} {g : P ⟶ A}
+    (hg : HasGoodKernel k g) (hP : IsRational k P.ρ) (hA : IsTilting k A) :
+    ∃ s : A ⟶ P, s ≫ g = 𝟙 A := by
+  obtain ⟨K,i,w,hS,hK⟩ := hg
+  exact good_weyl_extension_split k hK hA.2.2 P hP i g w hS
+
+lemma HasGoodKernel.of_isIso {P A : FDRep k (SL2 k)} (g : P ⟶ A) [IsIso g] :
+    HasGoodKernel k g := by
+  refine ⟨fdrepKernel k g, fdrepKernelι k g, ?_, ?_, ?_⟩
+  · apply fdrep_hom_ext k; intro x; exact x.property
+  · exact fdrepKernel_shortExact k g (fdrep_surjective k g)
+  · have : Subsingleton (fdrepKernel k g) := by
+      apply subsingleton_of_forall_eq 0
+      intro x
+      apply Subtype.ext
+      apply fdrep_injective k g
+      exact x.property.trans (map_zero _).symm
+    exact .zero _ (fdrep_isZero_of_subsingleton k _)
+
+ 
+lemma costandardMultiply_goodKernel (a b : ℕ) : HasGoodKernel k (costandardMultiply k a b) := by
+  rcases a with _ | a
+  · have := costandardMultiply_isIso_of_zero k 0 b (Or.inl rfl)
+    exact HasGoodKernel.of_isIso k _
+  · rcases b with _ | b
+    · have := costandardMultiply_isIso_of_zero k (a+1) 0 (Or.inr rfl)
+      exact HasGoodKernel.of_isIso k _
+    · exact ⟨_, costandardDeterminant k a b, costandardDeterminant_multiply k a b,
+        costandardTensorSequence_shortExact k a b, costandard_tensor_hasGoodFiltration k a b⟩
+
+lemma HasGoodKernel.kernel_good {P A : FDRep k (SL2 k)} {g : P ⟶ A}
+    (hg : HasGoodKernel k g) : HasGoodFiltration k (fdrepKernel k g) := by
+  obtain ⟨K,i,w,hS,hK⟩ := hg
+  have := hS.mono_f
+  let j := fdrepKernelLift k i g w
+  have hj : Function.Bijective (fdrepLinear k j) := by
+    constructor
+    · intro x y h
+      apply fdrep_injective k i
+      exact congrArg Subtype.val h
+    · intro x
+      have hx : x.val ∈ LinearMap.range (fdrepLinear k i) := by
+        rw [fdrep_exact k hS.exact]
+        exact x.property
+      obtain ⟨v,hv⟩ := hx
+      exact ⟨v,Subtype.ext hv⟩
+  have := fdrepHom_isIso_of_bijective k j hj
+  exact hK.of_iso k (asIso j)
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/GoodKernelExtension.lean

@@ -1,101 +1,101 @@
-import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
-import OAI.RepresentationTheory.RestrictedTilting.RepProducts
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-universe u
-variable (k : Type u) [Field k]
-
- 
-noncomputable def extensionCoverMap {A B P Q : FDRep k (SL2 k)}
-    (f : A ⟶ B) (a : P ⟶ A) (s : Q ⟶ B) : repProduct k P Q ⟶ B :=
-  repFst k P Q ≫ a ≫ f + repSnd k P Q ≫ s
-
-lemma extensionCoverMap_goodKernel {A B C P Q : FDRep k (SL2 k)}
-    (f : A ⟶ B) (g : B ⟶ C) (w : f ≫ g = 0)
-    (hS : (ShortComplex.mk f g w).ShortExact)
-    (a : P ⟶ A) (q : Q ⟶ C) (ha : HasGoodKernel k a) (hq : HasGoodKernel k q)
-    (s : Q ⟶ B) (hs : s ≫ g = q) :
-    HasGoodKernel k (extensionCoverMap k f a s) := by
-  have := hS.mono_f
-  have := ha.epi k
-  have := hq.epi k
-  have hf := fdrep_injective k f
-  have hex := fdrep_exact k hS.exact
-  have hfg (x : A) : fdrepLinear k g (fdrepLinear k f x) = 0 :=
-    congrArg (fun z => fdrepLinear k z x) w
-  have hsg (y : Q) : fdrepLinear k g (fdrepLinear k s y) = fdrepLinear k q y :=
-    congrArg (fun z => fdrepLinear k z y) hs
-  let F := extensionCoverMap k f a s
-  have hF (x : repProduct k P Q) : fdrepLinear k F x =
-      fdrepLinear k f (fdrepLinear k a x.1) + fdrepLinear k s x.2 := rfl
-  have hFsurj : Function.Surjective (fdrepLinear k F) := by
-    intro b
-    obtain ⟨y,hy⟩ := fdrep_surjective k q (fdrepLinear k g b)
-    have hmem : b - fdrepLinear k s y ∈ LinearMap.range (fdrepLinear k f) := by
-      rw [hex]
-      change fdrepLinear k g (b - fdrepLinear k s y) = 0
-      rw [map_sub, hsg, hy, sub_self]
-    obtain ⟨x,hx⟩ := hmem
-    obtain ⟨v,hv⟩ := fdrep_surjective k a x
-    refine ⟨(v,y), ?_⟩
-    erw [hF, hv, hx, sub_add_cancel]
-  let K := fdrepKernel k F
-  let Ka := fdrepKernel k a
-  let Kq := fdrepKernel k q
-  have hker (x : K) : fdrepLinear k q x.val.2 = 0 := by
-    have h := congrArg (fdrepLinear k g) (show fdrepLinear k F x.val = 0 from x.property)
-    rw [hF, map_add, hfg, hsg, zero_add, map_zero] at h
-    exact h
-  let i : Ka ⟶ K := fdrepHom k
-    { toFun := fun x => ⟨(x.val,0), by
-        change fdrepLinear k F (x.val,0) = 0
-        erw [hF, show fdrepLinear k a x.val = 0 from x.property, map_zero, map_zero, add_zero]⟩
-      map_add' := by intros; apply Subtype.ext; exact Prod.ext rfl (zero_add _).symm
-      map_smul' := by intros; apply Subtype.ext; exact Prod.ext rfl (smul_zero _).symm }
-    (by intro t x; apply Subtype.ext; exact Prod.ext rfl (map_zero (Q.ρ t)).symm)
-  let j : K ⟶ Kq := fdrepHom k
-    { toFun := fun x => ⟨x.val.2, hker x⟩
-      map_add' := by intros; rfl
-      map_smul' := by intros; rfl }
-    (by intros; rfl)
-  have wij : i ≫ j = 0 := by apply fdrep_hom_ext k; intro x; rfl
-  have hi : Function.Injective (fdrepLinear k i) := by
-    intro x y h
-    apply Subtype.ext
-    exact congrArg (fun z : K => z.val.1) h
-  have hj : Function.Surjective (fdrepLinear k j) := by
-    intro y
-    have hmem : fdrepLinear k s y.val ∈ LinearMap.range (fdrepLinear k f) := by
-      rw [hex]
-      change fdrepLinear k g (fdrepLinear k s y.val) = 0
-      rw [hsg]
-      exact y.property
-    obtain ⟨x,hx⟩ := hmem
-    obtain ⟨v,hv⟩ := fdrep_surjective k a (-x)
-    have hvy : fdrepLinear k F (v,y.val) = 0 := by
-      erw [hF, hv, map_neg, hx, neg_add_cancel]
-    exact ⟨⟨(v,y.val),hvy⟩,rfl⟩
-  have he : LinearMap.range (fdrepLinear k i) = LinearMap.ker (fdrepLinear k j) := by
-    ext x
-    constructor
-    · rintro ⟨y,rfl⟩; rfl
-    · intro hx
-      have hx2 : x.val.2 = 0 := congrArg Subtype.val (show fdrepLinear k j x = 0 from hx)
-      have hx1 : fdrepLinear k a x.val.1 = 0 := by
-        apply hf
-        have h := show fdrepLinear k F x.val = 0 from x.property
-        rw [hF, hx2, map_zero, add_zero] at h
-        exact h.trans (map_zero _).symm
-      refine ⟨⟨x.val.1,hx1⟩, ?_⟩
-      apply Subtype.ext
-      exact Prod.ext rfl hx2.symm
-  have hK : HasGoodFiltration k K :=
-    (ha.kernel_good k).extension k (hq.kernel_good k) i j wij (fdrep_shortExact k _ hi hj he)
-  exact ⟨K, fdrepKernelι k F, (by apply fdrep_hom_ext k; intro x; exact x.property),
-    fdrepKernel_shortExact k F hFsurj, hK⟩
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
+import OAI.RepresentationTheory.RestrictedTilting.RepProducts
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+universe u
+variable (k : Type u) [Field k]
+
+ 
+noncomputable def extensionCoverMap {A B P Q : FDRep k (SL2 k)}
+    (f : A ⟶ B) (a : P ⟶ A) (s : Q ⟶ B) : repProduct k P Q ⟶ B :=
+  repFst k P Q ≫ a ≫ f + repSnd k P Q ≫ s
+
+lemma extensionCoverMap_goodKernel {A B C P Q : FDRep k (SL2 k)}
+    (f : A ⟶ B) (g : B ⟶ C) (w : f ≫ g = 0)
+    (hS : (ShortComplex.mk f g w).ShortExact)
+    (a : P ⟶ A) (q : Q ⟶ C) (ha : HasGoodKernel k a) (hq : HasGoodKernel k q)
+    (s : Q ⟶ B) (hs : s ≫ g = q) :
+    HasGoodKernel k (extensionCoverMap k f a s) := by
+  have := hS.mono_f
+  have := ha.epi k
+  have := hq.epi k
+  have hf := fdrep_injective k f
+  have hex := fdrep_exact k hS.exact
+  have hfg (x : A) : fdrepLinear k g (fdrepLinear k f x) = 0 :=
+    congrArg (fun z => fdrepLinear k z x) w
+  have hsg (y : Q) : fdrepLinear k g (fdrepLinear k s y) = fdrepLinear k q y :=
+    congrArg (fun z => fdrepLinear k z y) hs
+  let F := extensionCoverMap k f a s
+  have hF (x : repProduct k P Q) : fdrepLinear k F x =
+      fdrepLinear k f (fdrepLinear k a x.1) + fdrepLinear k s x.2 := rfl
+  have hFsurj : Function.Surjective (fdrepLinear k F) := by
+    intro b
+    obtain ⟨y,hy⟩ := fdrep_surjective k q (fdrepLinear k g b)
+    have hmem : b - fdrepLinear k s y ∈ LinearMap.range (fdrepLinear k f) := by
+      rw [hex]
+      change fdrepLinear k g (b - fdrepLinear k s y) = 0
+      rw [map_sub, hsg, hy, sub_self]
+    obtain ⟨x,hx⟩ := hmem
+    obtain ⟨v,hv⟩ := fdrep_surjective k a x
+    refine ⟨(v,y), ?_⟩
+    erw [hF, hv, hx, sub_add_cancel]
+  let K := fdrepKernel k F
+  let Ka := fdrepKernel k a
+  let Kq := fdrepKernel k q
+  have hker (x : K) : fdrepLinear k q x.val.2 = 0 := by
+    have h := congrArg (fdrepLinear k g) (show fdrepLinear k F x.val = 0 from x.property)
+    rw [hF, map_add, hfg, hsg, zero_add, map_zero] at h
+    exact h
+  let i : Ka ⟶ K := fdrepHom k
+    { toFun := fun x => ⟨(x.val,0), by
+        change fdrepLinear k F (x.val,0) = 0
+        erw [hF, show fdrepLinear k a x.val = 0 from x.property, map_zero, map_zero, add_zero]⟩
+      map_add' := by intros; apply Subtype.ext; exact Prod.ext rfl (zero_add _).symm
+      map_smul' := by intros; apply Subtype.ext; exact Prod.ext rfl (smul_zero _).symm }
+    (by intro t x; apply Subtype.ext; exact Prod.ext rfl (map_zero (Q.ρ t)).symm)
+  let j : K ⟶ Kq := fdrepHom k
+    { toFun := fun x => ⟨x.val.2, hker x⟩
+      map_add' := by intros; rfl
+      map_smul' := by intros; rfl }
+    (by intros; rfl)
+  have wij : i ≫ j = 0 := by apply fdrep_hom_ext k; intro x; rfl
+  have hi : Function.Injective (fdrepLinear k i) := by
+    intro x y h
+    apply Subtype.ext
+    exact congrArg (fun z : K => z.val.1) h
+  have hj : Function.Surjective (fdrepLinear k j) := by
+    intro y
+    have hmem : fdrepLinear k s y.val ∈ LinearMap.range (fdrepLinear k f) := by
+      rw [hex]
+      change fdrepLinear k g (fdrepLinear k s y.val) = 0
+      rw [hsg]
+      exact y.property
+    obtain ⟨x,hx⟩ := hmem
+    obtain ⟨v,hv⟩ := fdrep_surjective k a (-x)
+    have hvy : fdrepLinear k F (v,y.val) = 0 := by
+      erw [hF, hv, map_neg, hx, neg_add_cancel]
+    exact ⟨⟨(v,y.val),hvy⟩,rfl⟩
+  have he : LinearMap.range (fdrepLinear k i) = LinearMap.ker (fdrepLinear k j) := by
+    ext x
+    constructor
+    · rintro ⟨y,rfl⟩; rfl
+    · intro hx
+      have hx2 : x.val.2 = 0 := congrArg Subtype.val (show fdrepLinear k j x = 0 from hx)
+      have hx1 : fdrepLinear k a x.val.1 = 0 := by
+        apply hf
+        have h := show fdrepLinear k F x.val = 0 from x.property
+        rw [hF, hx2, map_zero, add_zero] at h
+        exact h.trans (map_zero _).symm
+      refine ⟨⟨x.val.1,hx1⟩, ?_⟩
+      apply Subtype.ext
+      exact Prod.ext rfl hx2.symm
+  have hK : HasGoodFiltration k K :=
+    (ha.kernel_good k).extension k (hq.kernel_good k) i j wij (fdrep_shortExact k _ hi hj he)
+  exact ⟨K, fdrepKernelι k F, (by apply fdrep_hom_ext k; intro x; exact x.property),
+    fdrepKernel_shortExact k F hFsurj, hK⟩
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/IntertwinerDescent.lean

@@ -1,94 +1,94 @@
-import Mathlib
-
-namespace OAI
-
- 
-
-noncomputable section
-open scoped BigOperators
-
-namespace FiberFunctorProof
-
- 
-
-lemma invertible_linear_combination
-    {k K : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
-    {n ι : Type*} [Fintype n] [DecidableEq n] [Fintype ι]
-    (M : ι → Matrix n n k) (v : ι → K)
-    (hv : (∑ a : ι, v a • (M a).map (algebraMap k K)).det ≠ 0) :
-    ∃ c : ι → k, (∑ a : ι, c a • M a).det ≠ 0 := by
-  classical
-  let P : Matrix n n (MvPolynomial ι k) :=
-    fun i j => ∑ a : ι, MvPolynomial.C (M a i j) * MvPolynomial.X a
-  have hP : P.det ≠ 0 := by
-    intro hzero
-    apply hv
-    have heval : P.map (MvPolynomial.eval₂Hom (algebraMap k K) v) =
-        ∑ a : ι, v a • (M a).map (algebraMap k K) := by
-      ext i j
-      simp only [Matrix.map_apply, Matrix.sum_apply, Matrix.smul_apply]
-      dsimp [P]
-      simp [mul_comm]
-    rw [← heval, ← RingHom.mapMatrix_apply, ← RingHom.map_det, hzero, map_zero]
-  have hex : ∃ c : ι → k, MvPolynomial.eval c P.det ≠ 0 := by
-    by_contra! h
-    apply hP
-    apply MvPolynomial.funext
-    intro c
-    simpa only [map_zero] using h c
-  obtain ⟨c, hc⟩ := hex
-  refine ⟨c, ?_⟩
-  have heval : P.map (MvPolynomial.eval c) = ∑ a : ι, c a • M a := by
-    ext i j
-    simp only [Matrix.map_apply, Matrix.sum_apply, Matrix.smul_apply]
-    dsimp [P]
-    simp [mul_comm]
-  rwa [← heval, ← RingHom.mapMatrix_apply, ← RingHom.map_det]
-
- 
-
-theorem intertwiner_descent
-    {k K : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
-    {n : Type*} [Fintype n] [DecidableEq n] {G : Type*}
-    (A B : G → Matrix n n k)
-    (C : Matrix n n K) (hC : C.det ≠ 0)
-    (h : ∀ g, (A g).map (algebraMap k K) * C = C * (B g).map (algebraMap k K)) :
-    ∃ D : Matrix n n k, D.det ≠ 0 ∧ ∀ g, A g * D = D * B g := by
-  classical
-  let W : Submodule k K := Submodule.span k (Set.range (fun ij : n × n => C ij.1 ij.2))
-  have : FiniteDimensional k W := FiniteDimensional.span_of_finite k (Set.finite_range _)
-  let b := Module.finBasis k W
-  let V : Matrix n n W := fun i j => ⟨C i j, Submodule.subset_span ⟨(i, j), rfl⟩⟩
-  let M : Fin (Module.finrank k W) → Matrix n n k := fun a i j => b.repr (V i j) a
-  have hrepr : C = ∑ a, (b a : K) • (M a).map (algebraMap k K) := by
-    ext i j
-    have heq := congrArg (fun x : W => (x : K)) (b.sum_repr (V i j))
-    simp only [Matrix.sum_apply, Matrix.smul_apply, Matrix.map_apply]
-    change (V i j : K) = ∑ a, (b a : K) * algebraMap k K (b.repr (V i j) a)
-    simp only [Submodule.coe_sum, Submodule.coe_smul, Algebra.smul_def] at heq
-    exact heq.symm.trans (Finset.sum_congr rfl fun a _ => mul_comm _ _)
-  have hM : ∀ a g, A g * M a = M a * B g := by
-    intro a g
-    ext i j
-    have hW : ∑ l : n, A g i l • V l j = ∑ l : n, B g l j • V i l := by
-      apply Subtype.val_injective
-      have heq := congrArg (fun X : Matrix n n K => X i j) (h g)
-      simp only [Matrix.mul_apply, Matrix.map_apply] at heq
-      simp only [Submodule.coe_sum, Submodule.coe_smul, Algebra.smul_def]
-      exact heq.trans (Finset.sum_congr rfl fun l _ => mul_comm _ _)
-    have heq := congrArg (b.coord a) hW
-    simp only [Matrix.mul_apply]
-    simp only [map_sum, map_smul, smul_eq_mul, Module.Basis.coord_apply] at heq
-    exact heq.trans (Finset.sum_congr rfl fun l _ => mul_comm _ _)
-  have hcomb : (∑ a, (b a : K) • (M a).map (algebraMap k K)).det ≠ 0 := by
-    rwa [← hrepr]
-  obtain ⟨c, hc⟩ := invertible_linear_combination M (fun a => (b a : K)) hcomb
-  refine ⟨∑ a, c a • M a, hc, ?_⟩
-  intro g
-  simp only [Matrix.mul_sum, Matrix.sum_mul, Matrix.mul_smul, Matrix.smul_mul, hM]
-
-end FiberFunctorProof
-
-end
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+ 
+
+noncomputable section
+open scoped BigOperators
+
+namespace FiberFunctorProof
+
+ 
+
+lemma invertible_linear_combination
+    {k K : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
+    {n ι : Type*} [Fintype n] [DecidableEq n] [Fintype ι]
+    (M : ι → Matrix n n k) (v : ι → K)
+    (hv : (∑ a : ι, v a • (M a).map (algebraMap k K)).det ≠ 0) :
+    ∃ c : ι → k, (∑ a : ι, c a • M a).det ≠ 0 := by
+  classical
+  let P : Matrix n n (MvPolynomial ι k) :=
+    fun i j => ∑ a : ι, MvPolynomial.C (M a i j) * MvPolynomial.X a
+  have hP : P.det ≠ 0 := by
+    intro hzero
+    apply hv
+    have heval : P.map (MvPolynomial.eval₂Hom (algebraMap k K) v) =
+        ∑ a : ι, v a • (M a).map (algebraMap k K) := by
+      ext i j
+      simp only [Matrix.map_apply, Matrix.sum_apply, Matrix.smul_apply]
+      dsimp [P]
+      simp [mul_comm]
+    rw [← heval, ← RingHom.mapMatrix_apply, ← RingHom.map_det, hzero, map_zero]
+  have hex : ∃ c : ι → k, MvPolynomial.eval c P.det ≠ 0 := by
+    by_contra! h
+    apply hP
+    apply MvPolynomial.funext
+    intro c
+    simpa only [map_zero] using h c
+  obtain ⟨c, hc⟩ := hex
+  refine ⟨c, ?_⟩
+  have heval : P.map (MvPolynomial.eval c) = ∑ a : ι, c a • M a := by
+    ext i j
+    simp only [Matrix.map_apply, Matrix.sum_apply, Matrix.smul_apply]
+    dsimp [P]
+    simp [mul_comm]
+  rwa [← heval, ← RingHom.mapMatrix_apply, ← RingHom.map_det]
+
+ 
+
+theorem intertwiner_descent
+    {k K : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
+    {n : Type*} [Fintype n] [DecidableEq n] {G : Type*}
+    (A B : G → Matrix n n k)
+    (C : Matrix n n K) (hC : C.det ≠ 0)
+    (h : ∀ g, (A g).map (algebraMap k K) * C = C * (B g).map (algebraMap k K)) :
+    ∃ D : Matrix n n k, D.det ≠ 0 ∧ ∀ g, A g * D = D * B g := by
+  classical
+  let W : Submodule k K := Submodule.span k (Set.range (fun ij : n × n => C ij.1 ij.2))
+  have : FiniteDimensional k W := FiniteDimensional.span_of_finite k (Set.finite_range _)
+  let b := Module.finBasis k W
+  let V : Matrix n n W := fun i j => ⟨C i j, Submodule.subset_span ⟨(i, j), rfl⟩⟩
+  let M : Fin (Module.finrank k W) → Matrix n n k := fun a i j => b.repr (V i j) a
+  have hrepr : C = ∑ a, (b a : K) • (M a).map (algebraMap k K) := by
+    ext i j
+    have heq := congrArg (fun x : W => (x : K)) (b.sum_repr (V i j))
+    simp only [Matrix.sum_apply, Matrix.smul_apply, Matrix.map_apply]
+    change (V i j : K) = ∑ a, (b a : K) * algebraMap k K (b.repr (V i j) a)
+    simp only [Submodule.coe_sum, Submodule.coe_smul, Algebra.smul_def] at heq
+    exact heq.symm.trans (Finset.sum_congr rfl fun a _ => mul_comm _ _)
+  have hM : ∀ a g, A g * M a = M a * B g := by
+    intro a g
+    ext i j
+    have hW : ∑ l : n, A g i l • V l j = ∑ l : n, B g l j • V i l := by
+      apply Subtype.val_injective
+      have heq := congrArg (fun X : Matrix n n K => X i j) (h g)
+      simp only [Matrix.mul_apply, Matrix.map_apply] at heq
+      simp only [Submodule.coe_sum, Submodule.coe_smul, Algebra.smul_def]
+      exact heq.trans (Finset.sum_congr rfl fun l _ => mul_comm _ _)
+    have heq := congrArg (b.coord a) hW
+    simp only [Matrix.mul_apply]
+    simp only [map_sum, map_smul, smul_eq_mul, Module.Basis.coord_apply] at heq
+    exact heq.trans (Finset.sum_congr rfl fun l _ => mul_comm _ _)
+  have hcomb : (∑ a, (b a : K) • (M a).map (algebraMap k K)).det ≠ 0 := by
+    rwa [← hrepr]
+  obtain ⟨c, hc⟩ := invertible_linear_combination M (fun a => (b a : K)) hcomb
+  refine ⟨∑ a, c a • M a, hc, ?_⟩
+  intro g
+  simp only [Matrix.mul_sum, Matrix.sum_mul, Matrix.mul_smul, Matrix.smul_mul, hM]
+
+end FiberFunctorProof
+
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/JetRelations.lean

@@ -1,277 +1,277 @@
-import Mathlib
-
-namespace OAI
-
-/-! Binary sums, jet relations and their layer quotients. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-open scoped BigOperators Pointwise
-
-variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
-
- 
-def binarySum (x y : R) (n : ℕ) : (Fin (n+1) → M) →ₗ[R] M :=
-  ∑ i : Fin (n+1), (x^i.val * y^(n-i.val)) • LinearMap.proj i
-
-lemma binarySum_apply (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
-    binarySum x y n v = ∑ i : Fin (n+1), (x^i.val * y^(n-i.val)) • v i := by
-  simp [binarySum]
-
-lemma binarySum_zero (x y : R) (v : Fin 1 → M) : binarySum x y 0 v = v 0 := by
-  simp [binarySum_apply]
-
-lemma binarySum_succ (x y : R) (n : ℕ) (v : Fin (n+2) → M) :
-    binarySum x y (n+1) v = y^(n+1) • v 0 + x • binarySum x y n (fun i => v i.succ) := by
-  rw [binarySum_apply, Fin.sum_univ_succ, binarySum_apply, Finset.smul_sum]
-  simp only [Fin.val_zero, pow_zero, Nat.sub_zero, one_mul, Fin.val_succ, Nat.add_sub_add_right]
-  congr 1
-  apply Finset.sum_congr rfl
-  intro i _
-  rw [pow_succ, mul_comm (x^i.val) x, mul_assoc, mul_smul]
-
-lemma binarySum_single_zero (x y : R) (n : ℕ) (v : M) :
-    binarySum x y n (Pi.single 0 v) = y^n • v := by
-  classical
-  rw [binarySum_apply, Finset.sum_eq_single 0]
-  · simp
-  · intro i _ hi
-    simp [Pi.single_eq_of_ne hi]
-  · simp
-
- 
-def pairRelation (x y : R) : Submodule R M :=
-  x • (⊤ : Submodule R M) ⊔ y • (⊤ : Submodule R M)
-
-lemma x_smul_mem_pairRelation (x y : R) (v : M) : x • v ∈ pairRelation x y :=
-  (show x • (⊤ : Submodule R M) ≤ pairRelation x y from le_sup_left)
-    (Submodule.smul_mem_pointwise_smul v x ⊤ (by trivial))
-
-lemma y_smul_mem_pairRelation (x y : R) (v : M) : y • v ∈ pairRelation x y :=
-  (show y • (⊤ : Submodule R M) ≤ pairRelation x y from le_sup_right)
-    (Submodule.smul_mem_pointwise_smul v y ⊤ (by trivial))
-
-lemma regular_pair_y_pow (x y : R)
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
-    (j : ℕ) (v n : M) (h : y^j • v = x • n) : ∃ w : M, v = x • w := by
-  induction j generalizing n with
-  | zero => exact ⟨n, by simpa using h⟩
-  | succ j ih =>
-    obtain ⟨w,hw⟩ := hy (y^j • v) n (by simpa only [pow_succ', mul_smul] using h)
-    exact ih w hw
-
- 
-
-theorem binarySum_kernel_coefficients (x y : R)
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
-    (j : ℕ) (v : Fin (j+1) → M) (hv : binarySum x y j v = 0) :
-    ∀ i, v i ∈ pairRelation x y := by
-  classical
-  induction j with
-  | zero =>
-    intro i
-    have hi : i = 0 := Fin.ext (by omega)
-    rw [binarySum_zero] at hv
-    rw [hi, hv]
-    exact Submodule.zero_mem _
-  | succ j ih =>
-    have h0 : y^(j+1) • v 0 = x • (-binarySum x y j (fun i => v i.succ)) := by
-      rw [smul_neg]
-      exact eq_neg_of_add_eq_zero_left ((binarySum_succ x y j v) ▸ hv)
-    obtain ⟨w,hw⟩ := regular_pair_y_pow x y hy (j+1) (v 0) _ h0
-    let v' : Fin (j+1) → M := (fun i => v i.succ) + Pi.single 0 (y • w)
-    have hv' : binarySum x y j v' = 0 := by
-      apply hx
-      change x • binarySum x y j v' = x • (0 : M)
-      rw [smul_zero]
-      have he : x • binarySum x y j v' = binarySum x y (j+1) v := by
-        change x • binarySum x y j ((fun i => v i.succ) + Pi.single 0 (y • w)) = _
-        rw [map_add, binarySum_single_zero, smul_add, binarySum_succ, hw]
-        rw [smul_comm (y^(j+1)) x, ← mul_smul (y^j) y w, ← pow_succ]
-        exact add_comm _ _
-      exact he.trans hv
-    have hc := ih v' hv'
-    intro i
-    refine Fin.cases ?_ (fun i => ?_) i
-    · rw [hw]
-      exact x_smul_mem_pairRelation x y w
-    · have hu : (Pi.single (0 : Fin (j+1)) (y • w) : Fin (j+1) → M) i ∈ pairRelation x y := by
-        by_cases hi : i = 0
-        · subst i
-          simpa using y_smul_mem_pairRelation x y w
-        · simp [Pi.single_eq_of_ne hi]
-      have hh := (pairRelation (M := M) x y).sub_mem (hc i) hu
-      simpa only [v', Pi.add_apply, add_sub_cancel_right] using hh
-
-lemma binarySum_succ_last (x y : R) (n : ℕ) (v : Fin (n+2) → M) :
-    binarySum x y (n+1) v = y • binarySum x y n (fun i => v i.castSucc) + x^(n+1) • v (Fin.last _) := by
-  rw [binarySum_apply, Fin.sum_univ_castSucc, binarySum_apply, Finset.smul_sum]
-  simp only [Fin.val_last, Nat.sub_self, pow_zero, mul_one, Fin.val_castSucc]
-  congr 1
-  apply Finset.sum_congr rfl
-  intro i _
-  have hi : n+1-i.val = (n-i.val)+1 := by omega
-  rw [hi, pow_succ, ← mul_assoc, mul_comm (x^i.val * y^(n-i.val)) y, mul_smul]
-
-lemma binarySum_prepend_zero (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
-    binarySum x y (n+1) (Fin.cons 0 v) = x • binarySum x y n v := by
-  rw [binarySum_succ]
-  simp
-
-lemma binarySum_append_zero (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
-    binarySum x y (n+1) (Fin.snoc v 0) = y • binarySum x y n v := by
-  rw [binarySum_succ_last]
-  simp
-
- 
-def jetRelation (x y : R) (j : ℕ) : Submodule R M := (binarySum x y j).range
-
-lemma jetRelation_zero (x y : R) : jetRelation (M := M) x y 0 = ⊤ := by
-  apply LinearMap.range_eq_top.mpr
-  intro m
-  exact ⟨fun _ => m, binarySum_zero x y _⟩
-
-lemma mem_pairRelation (x y : R) (m : M) : m ∈ pairRelation x y ↔ ∃ a b : M, m = x • a + y • b := by
-  constructor
-  · intro h
-    obtain ⟨a,ha,b,hb,rfl⟩ := Submodule.mem_sup.mp h
-    obtain ⟨a',_,rfl⟩ := (Submodule.mem_smul_pointwise_iff_exists a x ⊤).mp ha
-    obtain ⟨b',_,rfl⟩ := (Submodule.mem_smul_pointwise_iff_exists b y ⊤).mp hb
-    exact ⟨a',b',rfl⟩
-  · rintro ⟨a,b,rfl⟩
-    exact (pairRelation x y).add_mem (x_smul_mem_pairRelation x y a) (y_smul_mem_pairRelation x y b)
-
-lemma jetRelation_one (x y : R) : jetRelation (M := M) x y 1 = pairRelation x y := by
-  ext m
-  constructor
-  · rintro ⟨v,rfl⟩
-    rw [binarySum_succ, binarySum_zero]
-    simpa only [Nat.zero_add, pow_one] using
-      (pairRelation x y).add_mem (y_smul_mem_pairRelation x y (v 0))
-        (x_smul_mem_pairRelation x y (v (Fin.succ 0)))
-  · intro hm
-    obtain ⟨a,b,rfl⟩ := (mem_pairRelation x y m).mp hm
-    refine ⟨Fin.cons b (fun _ => a), ?_⟩
-    rw [binarySum_succ, binarySum_zero]
-    simp [add_comm]
-
-lemma jetRelation_succ_le (x y : R) (j : ℕ) :
-    jetRelation (M := M) x y (j+1) ≤ jetRelation x y j := by
-  rintro m ⟨v,rfl⟩
-  refine ⟨x • (fun i => v i.succ) + Pi.single 0 (y • v 0), ?_⟩
-  rw [map_add, map_smul, binarySum_single_zero, binarySum_succ, ← mul_smul, ← pow_succ]
-  exact add_comm _ _
-
-lemma binarySum_pairRelation (x y : R) (j : ℕ) (v : Fin (j+1) → M)
-    (hv : ∀ i, v i ∈ pairRelation x y) :
-    binarySum x y j v ∈ jetRelation x y (j+1) := by
-  classical
-  choose a b hab using fun i => (mem_pairRelation x y (v i)).mp (hv i)
-  have he : v = x • a + y • b := funext hab
-  rw [he, map_add, map_smul, map_smul]
-  apply (jetRelation x y (j+1)).add_mem
-  · exact ⟨Fin.cons 0 a, binarySum_prepend_zero x y j a⟩
-  · exact ⟨Fin.snoc b 0, binarySum_append_zero x y j b⟩
-
- 
-
-theorem binarySum_mem_next_iff (x y : R)
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
-    (j : ℕ) (v : Fin (j+1) → M) :
-    binarySum x y j v ∈ jetRelation x y (j+1) ↔ ∀ i, v i ∈ pairRelation x y := by
-  constructor
-  · rintro ⟨w,hw⟩
-    let c : Fin (j+1) → M := x • (fun i => w i.succ) + Pi.single 0 (y • w 0)
-    have hc : ∀ i, c i ∈ pairRelation x y := by
-      intro i
-      apply (pairRelation x y).add_mem (x_smul_mem_pairRelation x y _)
-      classical
-      by_cases hi : i = 0
-      · subst i
-        simp only [Pi.single_eq_same]
-        exact y_smul_mem_pairRelation x y _
-      · simp [Pi.single_eq_of_ne hi]
-    have hbc : binarySum x y j c = binarySum x y (j+1) w := by
-      change binarySum x y j (x • (fun i => w i.succ) + Pi.single 0 (y • w 0)) = _
-      rw [map_add, map_smul, binarySum_single_zero, binarySum_succ, ← mul_smul, ← pow_succ]
-      exact add_comm _ _
-    have hz : binarySum x y j (v-c) = 0 := by rw [map_sub, hbc, hw, sub_self]
-    have hh := binarySum_kernel_coefficients x y hx hy j (v-c) hz
-    intro i
-    have hi := (pairRelation x y).add_mem (hh i) (hc i)
-    simpa only [Pi.sub_apply, sub_add_cancel] using hi
-  · exact binarySum_pairRelation x y j v
-
-abbrev jetLayer (x y : R) (j : ℕ) :=
-  (jetRelation (M := M) x y j) ⧸
-    ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype)
-
-def jetLayerMap (x y : R) (j : ℕ) : (Fin (j+1) → M) →ₗ[R] jetLayer (M := M) x y j :=
-  ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype).mkQ.comp
-    (binarySum x y j).rangeRestrict
-
-lemma jetLayerMap_surjective (x y : R) (j : ℕ) :
-    Function.Surjective (jetLayerMap (M := M) x y j) :=
-  ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype).mkQ_surjective.comp
-    (by rintro ⟨m,v,rfl⟩; exact ⟨v,rfl⟩)
-
-lemma jetLayerMap_eq_zero_iff (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
-    jetLayerMap x y j v = 0 ↔ binarySum x y j v ∈ jetRelation x y (j+1) := by
-  exact Submodule.Quotient.mk_eq_zero _
-
-def originCoefficientMap (x y : R) (j : ℕ) :
-    (Fin (j+1) → M) →ₗ[R] (Fin (j+1) → (M ⧸ pairRelation (M := M) x y)) :=
-  LinearMap.pi (fun i => (pairRelation x y).mkQ.comp (LinearMap.proj i))
-
-lemma originCoefficientMap_surjective (x y : R) (j : ℕ) :
-    Function.Surjective (originCoefficientMap (M := M) x y j) := by
-  intro v
-  choose w hw using fun i => (pairRelation (M := M) x y).mkQ_surjective (v i)
-  exact ⟨w, funext hw⟩
-
-lemma originCoefficientMap_eq_zero_iff (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
-    originCoefficientMap x y j v = 0 ↔ ∀ i, v i ∈ pairRelation x y := by
-  constructor
-  · intro h i
-    exact (Submodule.Quotient.mk_eq_zero _).mp (congrFun h i)
-  · intro h
-    ext i
-    exact (Submodule.Quotient.mk_eq_zero _).mpr (h i)
-
-lemma jetLayerMap_ker (x y : R)
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) (j : ℕ) :
-    (jetLayerMap (M := M) x y j).ker = (originCoefficientMap x y j).ker := by
-  ext v
-  exact (jetLayerMap_eq_zero_iff x y j v).trans
-    ((binarySum_mem_next_iff x y hx hy j v).trans
-      (originCoefficientMap_eq_zero_iff x y j v).symm)
-
- 
-
-noncomputable def jetLayerEquiv (x y : R)
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) (j : ℕ) :
-    (Fin (j+1) → (M ⧸ pairRelation (M := M) x y)) ≃ₗ[R] jetLayer (M := M) x y j :=
-  ((originCoefficientMap x y j).quotKerEquivOfSurjective
-    (originCoefficientMap_surjective x y j)).symm ≪≫ₗ
-    (Submodule.quotEquivOfEq _ _ (jetLayerMap_ker x y hx hy j).symm) ≪≫ₗ
-    (jetLayerMap x y j).quotKerEquivOfSurjective (jetLayerMap_surjective x y j)
-
-lemma jetLayerEquiv_apply (x y : R)
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
-    (j : ℕ) (v : Fin (j+1) → M) :
-    jetLayerEquiv x y hx hy j (originCoefficientMap x y j v) = jetLayerMap x y j v := by
-  simp only [jetLayerEquiv, LinearEquiv.trans_apply,
-    LinearMap.quotKerEquivOfSurjective_symm_apply, Submodule.quotEquivOfEq_mk,
-    LinearMap.quotKerEquivOfSurjective_apply_mk]
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Binary sums, jet relations and their layer quotients. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+open scoped BigOperators Pointwise
+
+variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
+
+ 
+def binarySum (x y : R) (n : ℕ) : (Fin (n+1) → M) →ₗ[R] M :=
+  ∑ i : Fin (n+1), (x^i.val * y^(n-i.val)) • LinearMap.proj i
+
+lemma binarySum_apply (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
+    binarySum x y n v = ∑ i : Fin (n+1), (x^i.val * y^(n-i.val)) • v i := by
+  simp [binarySum]
+
+lemma binarySum_zero (x y : R) (v : Fin 1 → M) : binarySum x y 0 v = v 0 := by
+  simp [binarySum_apply]
+
+lemma binarySum_succ (x y : R) (n : ℕ) (v : Fin (n+2) → M) :
+    binarySum x y (n+1) v = y^(n+1) • v 0 + x • binarySum x y n (fun i => v i.succ) := by
+  rw [binarySum_apply, Fin.sum_univ_succ, binarySum_apply, Finset.smul_sum]
+  simp only [Fin.val_zero, pow_zero, Nat.sub_zero, one_mul, Fin.val_succ, Nat.add_sub_add_right]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro i _
+  rw [pow_succ, mul_comm (x^i.val) x, mul_assoc, mul_smul]
+
+lemma binarySum_single_zero (x y : R) (n : ℕ) (v : M) :
+    binarySum x y n (Pi.single 0 v) = y^n • v := by
+  classical
+  rw [binarySum_apply, Finset.sum_eq_single 0]
+  · simp
+  · intro i _ hi
+    simp [Pi.single_eq_of_ne hi]
+  · simp
+
+ 
+def pairRelation (x y : R) : Submodule R M :=
+  x • (⊤ : Submodule R M) ⊔ y • (⊤ : Submodule R M)
+
+lemma x_smul_mem_pairRelation (x y : R) (v : M) : x • v ∈ pairRelation x y :=
+  (show x • (⊤ : Submodule R M) ≤ pairRelation x y from le_sup_left)
+    (Submodule.smul_mem_pointwise_smul v x ⊤ (by trivial))
+
+lemma y_smul_mem_pairRelation (x y : R) (v : M) : y • v ∈ pairRelation x y :=
+  (show y • (⊤ : Submodule R M) ≤ pairRelation x y from le_sup_right)
+    (Submodule.smul_mem_pointwise_smul v y ⊤ (by trivial))
+
+lemma regular_pair_y_pow (x y : R)
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
+    (j : ℕ) (v n : M) (h : y^j • v = x • n) : ∃ w : M, v = x • w := by
+  induction j generalizing n with
+  | zero => exact ⟨n, by simpa using h⟩
+  | succ j ih =>
+    obtain ⟨w,hw⟩ := hy (y^j • v) n (by simpa only [pow_succ', mul_smul] using h)
+    exact ih w hw
+
+ 
+
+theorem binarySum_kernel_coefficients (x y : R)
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
+    (j : ℕ) (v : Fin (j+1) → M) (hv : binarySum x y j v = 0) :
+    ∀ i, v i ∈ pairRelation x y := by
+  classical
+  induction j with
+  | zero =>
+    intro i
+    have hi : i = 0 := Fin.ext (by omega)
+    rw [binarySum_zero] at hv
+    rw [hi, hv]
+    exact Submodule.zero_mem _
+  | succ j ih =>
+    have h0 : y^(j+1) • v 0 = x • (-binarySum x y j (fun i => v i.succ)) := by
+      rw [smul_neg]
+      exact eq_neg_of_add_eq_zero_left ((binarySum_succ x y j v) ▸ hv)
+    obtain ⟨w,hw⟩ := regular_pair_y_pow x y hy (j+1) (v 0) _ h0
+    let v' : Fin (j+1) → M := (fun i => v i.succ) + Pi.single 0 (y • w)
+    have hv' : binarySum x y j v' = 0 := by
+      apply hx
+      change x • binarySum x y j v' = x • (0 : M)
+      rw [smul_zero]
+      have he : x • binarySum x y j v' = binarySum x y (j+1) v := by
+        change x • binarySum x y j ((fun i => v i.succ) + Pi.single 0 (y • w)) = _
+        rw [map_add, binarySum_single_zero, smul_add, binarySum_succ, hw]
+        rw [smul_comm (y^(j+1)) x, ← mul_smul (y^j) y w, ← pow_succ]
+        exact add_comm _ _
+      exact he.trans hv
+    have hc := ih v' hv'
+    intro i
+    refine Fin.cases ?_ (fun i => ?_) i
+    · rw [hw]
+      exact x_smul_mem_pairRelation x y w
+    · have hu : (Pi.single (0 : Fin (j+1)) (y • w) : Fin (j+1) → M) i ∈ pairRelation x y := by
+        by_cases hi : i = 0
+        · subst i
+          simpa using y_smul_mem_pairRelation x y w
+        · simp [Pi.single_eq_of_ne hi]
+      have hh := (pairRelation (M := M) x y).sub_mem (hc i) hu
+      simpa only [v', Pi.add_apply, add_sub_cancel_right] using hh
+
+lemma binarySum_succ_last (x y : R) (n : ℕ) (v : Fin (n+2) → M) :
+    binarySum x y (n+1) v = y • binarySum x y n (fun i => v i.castSucc) + x^(n+1) • v (Fin.last _) := by
+  rw [binarySum_apply, Fin.sum_univ_castSucc, binarySum_apply, Finset.smul_sum]
+  simp only [Fin.val_last, Nat.sub_self, pow_zero, mul_one, Fin.val_castSucc]
+  congr 1
+  apply Finset.sum_congr rfl
+  intro i _
+  have hi : n+1-i.val = (n-i.val)+1 := by omega
+  rw [hi, pow_succ, ← mul_assoc, mul_comm (x^i.val * y^(n-i.val)) y, mul_smul]
+
+lemma binarySum_prepend_zero (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
+    binarySum x y (n+1) (Fin.cons 0 v) = x • binarySum x y n v := by
+  rw [binarySum_succ]
+  simp
+
+lemma binarySum_append_zero (x y : R) (n : ℕ) (v : Fin (n+1) → M) :
+    binarySum x y (n+1) (Fin.snoc v 0) = y • binarySum x y n v := by
+  rw [binarySum_succ_last]
+  simp
+
+ 
+def jetRelation (x y : R) (j : ℕ) : Submodule R M := (binarySum x y j).range
+
+lemma jetRelation_zero (x y : R) : jetRelation (M := M) x y 0 = ⊤ := by
+  apply LinearMap.range_eq_top.mpr
+  intro m
+  exact ⟨fun _ => m, binarySum_zero x y _⟩
+
+lemma mem_pairRelation (x y : R) (m : M) : m ∈ pairRelation x y ↔ ∃ a b : M, m = x • a + y • b := by
+  constructor
+  · intro h
+    obtain ⟨a,ha,b,hb,rfl⟩ := Submodule.mem_sup.mp h
+    obtain ⟨a',_,rfl⟩ := (Submodule.mem_smul_pointwise_iff_exists a x ⊤).mp ha
+    obtain ⟨b',_,rfl⟩ := (Submodule.mem_smul_pointwise_iff_exists b y ⊤).mp hb
+    exact ⟨a',b',rfl⟩
+  · rintro ⟨a,b,rfl⟩
+    exact (pairRelation x y).add_mem (x_smul_mem_pairRelation x y a) (y_smul_mem_pairRelation x y b)
+
+lemma jetRelation_one (x y : R) : jetRelation (M := M) x y 1 = pairRelation x y := by
+  ext m
+  constructor
+  · rintro ⟨v,rfl⟩
+    rw [binarySum_succ, binarySum_zero]
+    simpa only [Nat.zero_add, pow_one] using
+      (pairRelation x y).add_mem (y_smul_mem_pairRelation x y (v 0))
+        (x_smul_mem_pairRelation x y (v (Fin.succ 0)))
+  · intro hm
+    obtain ⟨a,b,rfl⟩ := (mem_pairRelation x y m).mp hm
+    refine ⟨Fin.cons b (fun _ => a), ?_⟩
+    rw [binarySum_succ, binarySum_zero]
+    simp [add_comm]
+
+lemma jetRelation_succ_le (x y : R) (j : ℕ) :
+    jetRelation (M := M) x y (j+1) ≤ jetRelation x y j := by
+  rintro m ⟨v,rfl⟩
+  refine ⟨x • (fun i => v i.succ) + Pi.single 0 (y • v 0), ?_⟩
+  rw [map_add, map_smul, binarySum_single_zero, binarySum_succ, ← mul_smul, ← pow_succ]
+  exact add_comm _ _
+
+lemma binarySum_pairRelation (x y : R) (j : ℕ) (v : Fin (j+1) → M)
+    (hv : ∀ i, v i ∈ pairRelation x y) :
+    binarySum x y j v ∈ jetRelation x y (j+1) := by
+  classical
+  choose a b hab using fun i => (mem_pairRelation x y (v i)).mp (hv i)
+  have he : v = x • a + y • b := funext hab
+  rw [he, map_add, map_smul, map_smul]
+  apply (jetRelation x y (j+1)).add_mem
+  · exact ⟨Fin.cons 0 a, binarySum_prepend_zero x y j a⟩
+  · exact ⟨Fin.snoc b 0, binarySum_append_zero x y j b⟩
+
+ 
+
+theorem binarySum_mem_next_iff (x y : R)
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
+    (j : ℕ) (v : Fin (j+1) → M) :
+    binarySum x y j v ∈ jetRelation x y (j+1) ↔ ∀ i, v i ∈ pairRelation x y := by
+  constructor
+  · rintro ⟨w,hw⟩
+    let c : Fin (j+1) → M := x • (fun i => w i.succ) + Pi.single 0 (y • w 0)
+    have hc : ∀ i, c i ∈ pairRelation x y := by
+      intro i
+      apply (pairRelation x y).add_mem (x_smul_mem_pairRelation x y _)
+      classical
+      by_cases hi : i = 0
+      · subst i
+        simp only [Pi.single_eq_same]
+        exact y_smul_mem_pairRelation x y _
+      · simp [Pi.single_eq_of_ne hi]
+    have hbc : binarySum x y j c = binarySum x y (j+1) w := by
+      change binarySum x y j (x • (fun i => w i.succ) + Pi.single 0 (y • w 0)) = _
+      rw [map_add, map_smul, binarySum_single_zero, binarySum_succ, ← mul_smul, ← pow_succ]
+      exact add_comm _ _
+    have hz : binarySum x y j (v-c) = 0 := by rw [map_sub, hbc, hw, sub_self]
+    have hh := binarySum_kernel_coefficients x y hx hy j (v-c) hz
+    intro i
+    have hi := (pairRelation x y).add_mem (hh i) (hc i)
+    simpa only [Pi.sub_apply, sub_add_cancel] using hi
+  · exact binarySum_pairRelation x y j v
+
+abbrev jetLayer (x y : R) (j : ℕ) :=
+  (jetRelation (M := M) x y j) ⧸
+    ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype)
+
+def jetLayerMap (x y : R) (j : ℕ) : (Fin (j+1) → M) →ₗ[R] jetLayer (M := M) x y j :=
+  ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype).mkQ.comp
+    (binarySum x y j).rangeRestrict
+
+lemma jetLayerMap_surjective (x y : R) (j : ℕ) :
+    Function.Surjective (jetLayerMap (M := M) x y j) :=
+  ((jetRelation x y (j+1)).comap (jetRelation x y j).subtype).mkQ_surjective.comp
+    (by rintro ⟨m,v,rfl⟩; exact ⟨v,rfl⟩)
+
+lemma jetLayerMap_eq_zero_iff (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
+    jetLayerMap x y j v = 0 ↔ binarySum x y j v ∈ jetRelation x y (j+1) := by
+  exact Submodule.Quotient.mk_eq_zero _
+
+def originCoefficientMap (x y : R) (j : ℕ) :
+    (Fin (j+1) → M) →ₗ[R] (Fin (j+1) → (M ⧸ pairRelation (M := M) x y)) :=
+  LinearMap.pi (fun i => (pairRelation x y).mkQ.comp (LinearMap.proj i))
+
+lemma originCoefficientMap_surjective (x y : R) (j : ℕ) :
+    Function.Surjective (originCoefficientMap (M := M) x y j) := by
+  intro v
+  choose w hw using fun i => (pairRelation (M := M) x y).mkQ_surjective (v i)
+  exact ⟨w, funext hw⟩
+
+lemma originCoefficientMap_eq_zero_iff (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
+    originCoefficientMap x y j v = 0 ↔ ∀ i, v i ∈ pairRelation x y := by
+  constructor
+  · intro h i
+    exact (Submodule.Quotient.mk_eq_zero _).mp (congrFun h i)
+  · intro h
+    ext i
+    exact (Submodule.Quotient.mk_eq_zero _).mpr (h i)
+
+lemma jetLayerMap_ker (x y : R)
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) (j : ℕ) :
+    (jetLayerMap (M := M) x y j).ker = (originCoefficientMap x y j).ker := by
+  ext v
+  exact (jetLayerMap_eq_zero_iff x y j v).trans
+    ((binarySum_mem_next_iff x y hx hy j v).trans
+      (originCoefficientMap_eq_zero_iff x y j v).symm)
+
+ 
+
+noncomputable def jetLayerEquiv (x y : R)
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) (j : ℕ) :
+    (Fin (j+1) → (M ⧸ pairRelation (M := M) x y)) ≃ₗ[R] jetLayer (M := M) x y j :=
+  ((originCoefficientMap x y j).quotKerEquivOfSurjective
+    (originCoefficientMap_surjective x y j)).symm ≪≫ₗ
+    (Submodule.quotEquivOfEq _ _ (jetLayerMap_ker x y hx hy j).symm) ≪≫ₗ
+    (jetLayerMap x y j).quotKerEquivOfSurjective (jetLayerMap_surjective x y j)
+
+lemma jetLayerEquiv_apply (x y : R)
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w)
+    (j : ℕ) (v : Fin (j+1) → M) :
+    jetLayerEquiv x y hx hy j (originCoefficientMap x y j v) = jetLayerMap x y j v := by
+  simp only [jetLayerEquiv, LinearEquiv.trans_apply,
+    LinearMap.quotKerEquivOfSurjective_symm_apply, Submodule.quotEquivOfEq_mk,
+    LinearMap.quotKerEquivOfSurjective_apply_mk]
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/JetRepresentations.lean

@@ -1,357 +1,357 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.JetRelations
-import OAI.RepresentationTheory.RestrictedTilting.WeightBounds
-
-namespace OAI
-
-/-! Plane jet modules, homogeneous layers and equivariant inclusions. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-open scoped TensorProduct BigOperators Pointwise
-universe u
-variable (k : Type u) [Field k]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
-
-noncomputable abbrev planeJetRelation (j : ℕ) : Submodule k M :=
-  (jetRelation (M := M) (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j).restrictScalars k
-
-noncomputable def jetMonomialBasis (j : ℕ) :
-    Module.Basis (Fin (j+1)) k (MvPolynomial.homogeneousSubmodule (Fin 2) k j) :=
-  (binaryBasis k j).reindex Fin.revPerm
-
-lemma jetMonomialBasis_apply (j : ℕ) (i : Fin (j+1)) :
-    (jetMonomialBasis k j i).val =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k)^i.val * MvPolynomial.X 1^(j-i.val) := by
-  simp only [jetMonomialBasis, Module.Basis.reindex_apply, Fin.revPerm_symm,
-    Fin.revPerm_apply, binaryBasis_apply, Fin.val_rev]
-  congr 2 <;> omega
-
-lemma homogeneous_smul_mem_jet (j : ℕ)
-    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M) :
-    P.val • v ∈ planeJetRelation (M := M) k j := by
-  have hp := (jetMonomialBasis k j).sum_repr P
-  have hv := congrArg (fun Q : MvPolynomial.homogeneousSubmodule (Fin 2) k j => Q.val • v) hp
-  have he : P.val • v = binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
-      (fun i => (jetMonomialBasis k j).repr P i • v) := by
-    rw [← hv, binarySum_apply]
-    simp only [Submodule.coe_sum, Submodule.coe_smul_of_tower, Finset.sum_smul,
-      jetMonomialBasis_apply, smul_assoc]
-    apply Finset.sum_congr rfl
-    intro i _
-    exact smul_comm _ _ _
-  exact ⟨_,he.symm⟩
-
-lemma homogeneous_smul_pair_mem_next (j : ℕ)
-    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M)
-    (hv : v ∈ planeJetRelation (M := M) k 1) : P.val • v ∈ planeJetRelation (M := M) k (j+1) := by
-  have hp := (jetMonomialBasis k j).sum_repr P
-  have he : P.val • v = binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
-      (fun i => (jetMonomialBasis k j).repr P i • v) := by
-    rw [← congrArg (fun Q : MvPolynomial.homogeneousSubmodule (Fin 2) k j => Q.val • v) hp,
-      binarySum_apply]
-    simp only [Submodule.coe_sum, Submodule.coe_smul_of_tower, Finset.sum_smul,
-      jetMonomialBasis_apply, smul_assoc]
-    apply Finset.sum_congr rfl
-    intro i _
-    exact smul_comm _ _ _
-  rw [he]
-  apply binarySum_pairRelation
-  intro i
-  change _ ∈ (jetRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) 1).restrictScalars k at hv
-  have : (jetMonomialBasis k j).repr P i • v ∈ planeJetRelation (M := M) k 1 :=
-    (planeJetRelation (M := M) k 1).smul_mem _ hv
-  simpa only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one] using this
-
- 
-def PlaneCompatible (σ : Representation k (SL2 k) M) : Prop :=
-  ∀ (g : SL2 k) (P : MvPolynomial (Fin 2) k) (v : M),
-    σ g (P • v) = linearChange (dualMatrix k g) P • σ g v
-
-lemma planeJetRelation_stable (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) :
-    planeJetRelation (M := M) k j ≤ (planeJetRelation (M := M) k j).comap (σ g) := by
-  rintro m ⟨v,rfl⟩
-  change σ g (binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j v) ∈ planeJetRelation (M := M) k j
-  rw [binarySum_apply, map_sum]
-  apply (planeJetRelation (M := M) k j).sum_mem
-  intro i _
-  rw [hσ]
-  have hh : ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k)^i.val *
-      MvPolynomial.X 1^(j-i.val)).IsHomogeneous j := by
-    rw [← jetMonomialBasis_apply k j i]
-    exact (jetMonomialBasis k j i).property
-  exact homogeneous_smul_mem_jet k j
-    ⟨_, linearChange_homogeneous (dualMatrix k g) hh⟩ _
-
-noncomputable def planeJetRep (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) :
-    Representation k (SL2 k) (M ⧸ planeJetRelation (M := M) k j) :=
-  Representation.quotient σ (planeJetRelation (M := M) k j) (planeJetRelation_stable k σ hσ j)
-
-lemma planeJetRep_mk (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) (v : M) :
-    planeJetRep k σ hσ j g ((planeJetRelation (M := M) k j).mkQ v) =
-      (planeJetRelation (M := M) k j).mkQ (σ g v) := rfl
-
-lemma planeJetRep_rational (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (hr : IsRational k σ) (j : ℕ) :
-    IsRational k (planeJetRep k σ hσ j) := by
-  intro v l
-  obtain ⟨w, rfl⟩ := (planeJetRelation (M := M) k j).mkQ_surjective v
-  obtain ⟨P,hP⟩ := hr w (l.comp (planeJetRelation (M := M) k j).mkQ)
-  exact ⟨P,hP⟩
-
-noncomputable abbrev planeJetLayerRelation (j : ℕ) : Submodule k (planeJetRelation (M := M) k j) :=
-  (planeJetRelation (M := M) k (j+1)).comap (planeJetRelation (M := M) k j).subtype
-noncomputable abbrev planeJetLayer (j : ℕ) := (planeJetRelation (M := M) k j) ⧸ planeJetLayerRelation (M := M) k j
-
-noncomputable def planeHomogeneousMultiply (j : ℕ)
-    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) : M →ₗ[k] planeJetRelation (M := M) k j where
-  toFun v := ⟨P.val • v, homogeneous_smul_mem_jet k j P v⟩
-  map_add' _ _ := Subtype.ext (smul_add _ _ _)
-  map_smul' _ _ := Subtype.ext (smul_comm _ _ _)
-
-noncomputable def planeLayerMul (j : ℕ) (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) :
-    M →ₗ[k] planeJetLayer (M := M) k j :=
-  (planeJetLayerRelation (M := M) k j).mkQ.comp (planeHomogeneousMultiply k j P)
-
-lemma planeLayerMul_ker (j : ℕ) (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) :
-    planeJetRelation (M := M) k 1 ≤ (planeLayerMul k j P).ker := by
-  intro v hv
-  exact (Submodule.Quotient.mk_eq_zero _).mpr (homogeneous_smul_pair_mem_next k j P v hv)
-
-noncomputable def planeLayerBilinear (j : ℕ) :
-    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) →ₗ[k]
-      ((M ⧸ planeJetRelation (M := M) k 1) →ₗ[k] planeJetLayer (M := M) k j) where
-  toFun P := (planeJetRelation (M := M) k 1).liftQ (planeLayerMul k j P) (planeLayerMul_ker k j P)
-  map_add' P Q := by
-    apply LinearMap.ext
-    intro t
-    obtain ⟨v,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective t
-    change (planeJetLayerRelation (M := M) k j).mkQ _ =
-      (planeJetLayerRelation (M := M) k j).mkQ _ + (planeJetLayerRelation (M := M) k j).mkQ _
-    rw [← map_add]
-    congr 1
-    exact Subtype.ext (add_smul P.val Q.val v)
-  map_smul' a P := by
-    apply LinearMap.ext
-    intro t
-    obtain ⟨v,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective t
-    change (planeJetLayerRelation (M := M) k j).mkQ _ = a • (planeJetLayerRelation (M := M) k j).mkQ _
-    rw [← map_smul]
-    congr 1
-    exact Subtype.ext (smul_assoc a P.val v)
-
-noncomputable def planeLayerMultiply (j : ℕ) :
-    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
-      (M ⧸ planeJetRelation (M := M) k 1) →ₗ[k] planeJetLayer (M := M) k j :=
-  TensorProduct.lift (planeLayerBilinear k j)
-
-lemma planeLayerMultiply_tmul_mk (j : ℕ)
-    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M) :
-    planeLayerMultiply k j (P ⊗ₜ[k] (planeJetRelation (M := M) k 1).mkQ v) =
-      (planeJetLayerRelation (M := M) k j).mkQ ⟨P.val • v, homogeneous_smul_mem_jet k j P v⟩ := rfl
-
-lemma planeLayerMultiply_sum (j : ℕ) (v : Fin (j+1) → M) :
-    planeLayerMultiply k j (∑ i, jetMonomialBasis k j i ⊗ₜ[k] (planeJetRelation (M := M) k 1).mkQ (v i)) =
-      (planeJetLayerRelation (M := M) k j).mkQ
-        ⟨binarySum (MvPolynomial.X 0) (MvPolynomial.X 1) j v, ⟨v,rfl⟩⟩ := by
-  rw [map_sum]
-  simp only [planeLayerMultiply_tmul_mk, ← map_sum]
-  congr 1
-  apply Subtype.ext
-  simp only [Submodule.coe_sum, jetMonomialBasis_apply, binarySum_apply]
-
-lemma tensor_basis_decomposition {H T : Type u} [AddCommGroup H] [Module k H]
-    [AddCommGroup T] [Module k T] {ι : Type*} [Fintype ι]
-    (b : Module.Basis ι k H) (z : H ⊗[k] T) :
-    ∃ v : ι → T, z = ∑ i, b i ⊗ₜ[k] v i := by
-  classical
-  induction z using TensorProduct.inductionOn with
-  | tmul h t =>
-    refine ⟨fun i => b.repr h i • t, ?_⟩
-    conv_lhs => rw [← b.sum_repr h, TensorProduct.sum_tmul]
-    apply Finset.sum_congr rfl
-    intro i _
-    rw [TensorProduct.smul_tmul, TensorProduct.tmul_smul]
-  | add z w hz hw =>
-    obtain ⟨v,rfl⟩ := hz
-    obtain ⟨w,rfl⟩ := hw
-    exact ⟨v+w, by simp only [Pi.add_apply, TensorProduct.tmul_add, Finset.sum_add_distrib]⟩
-
-lemma planeLayerMultiply_surjective (j : ℕ) :
-    Function.Surjective (planeLayerMultiply (M := M) k j) := by
-  intro z
-  obtain ⟨⟨m,v,rfl⟩,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective z
-  exact ⟨_, planeLayerMultiply_sum k j v⟩
-
-lemma planeLayerMultiply_injective
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
-    Function.Injective (planeLayerMultiply (M := M) k j) := by
-  have hzero : ∀ z, planeLayerMultiply (M := M) k j z = 0 → z = 0 := by
-    intro z hz
-    obtain ⟨v,rfl⟩ := tensor_basis_decomposition k (jetMonomialBasis k j) z
-    choose w hw using fun i => (planeJetRelation (M := M) k 1).mkQ_surjective (v i)
-    have he : v = fun i => (planeJetRelation (M := M) k 1).mkQ (w i) := funext fun i => (hw i).symm
-    rw [he, planeLayerMultiply_sum] at hz
-    have hm := (Submodule.Quotient.mk_eq_zero _).mp hz
-    have hc := (binarySum_mem_next_iff (MvPolynomial.X 0 : MvPolynomial (Fin 2) k)
-      (MvPolynomial.X 1) hx hy j w).mp hm
-    have hv : ∀ i, v i = 0 := by
-      intro i
-      rw [← hw i]
-      apply (Submodule.Quotient.mk_eq_zero _).mpr
-      simpa only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one] using hc i
-    simp only [hv, TensorProduct.tmul_zero, Finset.sum_const_zero]
-  intro a b hab
-  apply sub_eq_zero.mp
-  apply hzero
-  rw [map_sub,hab,sub_self]
-
-noncomputable def planeLayerEquiv
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m))
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
-      ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
-    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
-      (M ⧸ planeJetRelation (M := M) k 1) ≃ₗ[k] planeJetLayer (M := M) k j :=
-  LinearEquiv.ofBijective (planeLayerMultiply k j)
-    ⟨planeLayerMultiply_injective k hx hy j, planeLayerMultiply_surjective k j⟩
-
-noncomputable def planeJetSubrep (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) :
-    Representation k (SL2 k) (planeJetRelation (M := M) k j) :=
-  Representation.subrepresentation σ _ (planeJetRelation_stable k σ hσ j)
-
-lemma planeJetLayerRelation_stable (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) :
-    planeJetLayerRelation (M := M) k j ≤
-      (planeJetLayerRelation k j).comap (planeJetSubrep k σ hσ j g) := by
-  intro v hv
-  exact planeJetRelation_stable k σ hσ (j+1) g hv
-
-noncomputable def planeJetLayerRep (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) :
-    Representation k (SL2 k) (planeJetLayer (M := M) k j) :=
-  Representation.quotient (planeJetSubrep k σ hσ j) _
-    (planeJetLayerRelation_stable k σ hσ j)
-
-lemma planeLayerMultiply_intertwines (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
-    (z : (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
-      (M ⧸ planeJetRelation (M := M) k 1)) :
-    planeLayerMultiply (M := M) k j
-      (Representation.tprod ((homogeneousRepresentation j).comp (dualMatrix k))
-        (planeJetRep k σ hσ 1) g z) =
-      planeJetLayerRep k σ hσ j g (planeLayerMultiply k j z) := by
-  induction z using TensorProduct.inductionOn with
-  | tmul P v =>
-    obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective v
-    simp only [Representation.tprod_apply, TensorProduct.map_tmul,
-      planeJetRep_mk, planeLayerMultiply_tmul_mk]
-    change (planeJetLayerRelation k j).mkQ ⟨_,_⟩ =
-      (planeJetLayerRelation k j).mkQ ⟨σ g (P.val • w),_⟩
-    congr 1
-    apply Subtype.ext
-    exact (hσ g P.val w).symm
-  | add x y hx hy => simp only [map_add, hx, hy]
-
-lemma planeLayer_finite [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)] (j : ℕ) :
-    Module.Finite k (planeJetLayer (M := M) k j) :=
-  Module.Finite.of_surjective (planeLayerMultiply k j) (planeLayerMultiply_surjective k j)
-
-lemma planeJetRelation_succ_le (j : ℕ) :
-    planeJetRelation (M := M) k (j+1) ≤ planeJetRelation (M := M) k j :=
-  jetRelation_succ_le (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
-
-lemma planeJetRelation_zero : planeJetRelation (M := M) k 0 = ⊤ := by
-  simp only [planeJetRelation, jetRelation_zero, Submodule.restrictScalars_top]
-
-noncomputable def planeJetTransition (j : ℕ) :
-    (M ⧸ planeJetRelation (M := M) k (j+1)) →ₗ[k] (M ⧸ planeJetRelation (M := M) k j) :=
-  (planeJetRelation k (j+1)).mapQ (planeJetRelation k j) LinearMap.id
-    (planeJetRelation_succ_le k j)
-
-lemma planeJetTransition_mk (j : ℕ) (v : M) :
-    planeJetTransition k j ((planeJetRelation (M := M) k (j+1)).mkQ v) =
-      (planeJetRelation (M := M) k j).mkQ v := rfl
-
-lemma planeJetTransition_surjective (j : ℕ) :
-    Function.Surjective (planeJetTransition (M := M) k j) := by
-  intro v
-  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k j).mkQ_surjective v
-  exact ⟨(planeJetRelation k (j+1)).mkQ w,rfl⟩
-
-noncomputable def planeJetLayerInclusion (j : ℕ) :
-    planeJetLayer (M := M) k j →ₗ[k] (M ⧸ planeJetRelation (M := M) k (j+1)) :=
-  (planeJetLayerRelation k j).liftQ
-    ((planeJetRelation k (j+1)).mkQ.comp (planeJetRelation k j).subtype) (by
-      intro v hv
-      exact (Submodule.Quotient.mk_eq_zero _).mpr hv)
-
-lemma planeJetLayerInclusion_mk (j : ℕ) (v : planeJetRelation (M := M) k j) :
-    planeJetLayerInclusion k j ((planeJetLayerRelation k j).mkQ v) =
-      (planeJetRelation (M := M) k (j+1)).mkQ v.val := rfl
-
-lemma planeJetLayerInclusion_injective (j : ℕ) :
-    Function.Injective (planeJetLayerInclusion (M := M) k j) := by
-  apply (LinearMap.ker_eq_bot (f := planeJetLayerInclusion (M := M) k j)).mp
-  apply (LinearMap.ker_eq_bot' (f := planeJetLayerInclusion (M := M) k j)).mpr
-  intro v hv
-  obtain ⟨w,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective v
-  rw [planeJetLayerInclusion_mk] at hv
-  have hw : w.val ∈ planeJetRelation (M := M) k (j+1) :=
-    (Submodule.Quotient.mk_eq_zero (planeJetRelation k (j+1))).mp hv
-  exact (Submodule.Quotient.mk_eq_zero _).mpr hw
-
-lemma planeJet_shortExact (j : ℕ) :
-    Function.Exact (planeJetLayerInclusion (M := M) k j) (planeJetTransition k j) := by
-  intro v
-  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k (j+1)).mkQ_surjective v
-  constructor
-  · intro hw
-    have hj : w ∈ planeJetRelation (M := M) k j := (Submodule.Quotient.mk_eq_zero _).mp hw
-    exact ⟨(planeJetLayerRelation k j).mkQ ⟨w,hj⟩,rfl⟩
-  · rintro ⟨z,hz⟩
-    obtain ⟨t,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective z
-    rw [← hz, planeJetLayerInclusion_mk, planeJetTransition_mk]
-    exact (Submodule.Quotient.mk_eq_zero _).mpr t.property
-
-lemma planeJet_finite [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)] (j : ℕ) :
-    Module.Finite k (M ⧸ planeJetRelation (M := M) k j) := by
-  induction j with
-  | zero =>
-    rw [planeJetRelation_zero]
-    infer_instance
-  | succ j ih =>
-    let := ih
-    let := planeLayer_finite (M := M) k j
-    exact Module.Finite.of_exact (planeJet_shortExact k j) (planeJetTransition_surjective k j)
-
-lemma planeJetTransition_intertwines (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
-    (v : M ⧸ planeJetRelation (M := M) k (j+1)) :
-    planeJetTransition k j (planeJetRep k σ hσ (j+1) g v) =
-      planeJetRep k σ hσ j g (planeJetTransition k j v) := by
-  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k (j+1)).mkQ_surjective v
-  rfl
-
-lemma planeJetLayerInclusion_intertwines (σ : Representation k (SL2 k) M)
-    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
-    (v : planeJetLayer (M := M) k j) :
-    planeJetLayerInclusion k j (planeJetLayerRep k σ hσ j g v) =
-      planeJetRep k σ hσ (j+1) g (planeJetLayerInclusion k j v) := by
-  obtain ⟨w,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective v
-  rfl
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.JetRelations
+import OAI.RepresentationTheory.RestrictedTilting.WeightBounds
+
+namespace OAI
+
+/-! Plane jet modules, homogeneous layers and equivariant inclusions. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+open scoped TensorProduct BigOperators Pointwise
+universe u
+variable (k : Type u) [Field k]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
+
+noncomputable abbrev planeJetRelation (j : ℕ) : Submodule k M :=
+  (jetRelation (M := M) (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j).restrictScalars k
+
+noncomputable def jetMonomialBasis (j : ℕ) :
+    Module.Basis (Fin (j+1)) k (MvPolynomial.homogeneousSubmodule (Fin 2) k j) :=
+  (binaryBasis k j).reindex Fin.revPerm
+
+lemma jetMonomialBasis_apply (j : ℕ) (i : Fin (j+1)) :
+    (jetMonomialBasis k j i).val =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k)^i.val * MvPolynomial.X 1^(j-i.val) := by
+  simp only [jetMonomialBasis, Module.Basis.reindex_apply, Fin.revPerm_symm,
+    Fin.revPerm_apply, binaryBasis_apply, Fin.val_rev]
+  congr 2 <;> omega
+
+lemma homogeneous_smul_mem_jet (j : ℕ)
+    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M) :
+    P.val • v ∈ planeJetRelation (M := M) k j := by
+  have hp := (jetMonomialBasis k j).sum_repr P
+  have hv := congrArg (fun Q : MvPolynomial.homogeneousSubmodule (Fin 2) k j => Q.val • v) hp
+  have he : P.val • v = binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
+      (fun i => (jetMonomialBasis k j).repr P i • v) := by
+    rw [← hv, binarySum_apply]
+    simp only [Submodule.coe_sum, Submodule.coe_smul_of_tower, Finset.sum_smul,
+      jetMonomialBasis_apply, smul_assoc]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact smul_comm _ _ _
+  exact ⟨_,he.symm⟩
+
+lemma homogeneous_smul_pair_mem_next (j : ℕ)
+    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M)
+    (hv : v ∈ planeJetRelation (M := M) k 1) : P.val • v ∈ planeJetRelation (M := M) k (j+1) := by
+  have hp := (jetMonomialBasis k j).sum_repr P
+  have he : P.val • v = binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
+      (fun i => (jetMonomialBasis k j).repr P i • v) := by
+    rw [← congrArg (fun Q : MvPolynomial.homogeneousSubmodule (Fin 2) k j => Q.val • v) hp,
+      binarySum_apply]
+    simp only [Submodule.coe_sum, Submodule.coe_smul_of_tower, Finset.sum_smul,
+      jetMonomialBasis_apply, smul_assoc]
+    apply Finset.sum_congr rfl
+    intro i _
+    exact smul_comm _ _ _
+  rw [he]
+  apply binarySum_pairRelation
+  intro i
+  change _ ∈ (jetRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) 1).restrictScalars k at hv
+  have : (jetMonomialBasis k j).repr P i • v ∈ planeJetRelation (M := M) k 1 :=
+    (planeJetRelation (M := M) k 1).smul_mem _ hv
+  simpa only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one] using this
+
+ 
+def PlaneCompatible (σ : Representation k (SL2 k) M) : Prop :=
+  ∀ (g : SL2 k) (P : MvPolynomial (Fin 2) k) (v : M),
+    σ g (P • v) = linearChange (dualMatrix k g) P • σ g v
+
+lemma planeJetRelation_stable (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) :
+    planeJetRelation (M := M) k j ≤ (planeJetRelation (M := M) k j).comap (σ g) := by
+  rintro m ⟨v,rfl⟩
+  change σ g (binarySum (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j v) ∈ planeJetRelation (M := M) k j
+  rw [binarySum_apply, map_sum]
+  apply (planeJetRelation (M := M) k j).sum_mem
+  intro i _
+  rw [hσ]
+  have hh : ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k)^i.val *
+      MvPolynomial.X 1^(j-i.val)).IsHomogeneous j := by
+    rw [← jetMonomialBasis_apply k j i]
+    exact (jetMonomialBasis k j i).property
+  exact homogeneous_smul_mem_jet k j
+    ⟨_, linearChange_homogeneous (dualMatrix k g) hh⟩ _
+
+noncomputable def planeJetRep (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) :
+    Representation k (SL2 k) (M ⧸ planeJetRelation (M := M) k j) :=
+  Representation.quotient σ (planeJetRelation (M := M) k j) (planeJetRelation_stable k σ hσ j)
+
+lemma planeJetRep_mk (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) (v : M) :
+    planeJetRep k σ hσ j g ((planeJetRelation (M := M) k j).mkQ v) =
+      (planeJetRelation (M := M) k j).mkQ (σ g v) := rfl
+
+lemma planeJetRep_rational (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (hr : IsRational k σ) (j : ℕ) :
+    IsRational k (planeJetRep k σ hσ j) := by
+  intro v l
+  obtain ⟨w, rfl⟩ := (planeJetRelation (M := M) k j).mkQ_surjective v
+  obtain ⟨P,hP⟩ := hr w (l.comp (planeJetRelation (M := M) k j).mkQ)
+  exact ⟨P,hP⟩
+
+noncomputable abbrev planeJetLayerRelation (j : ℕ) : Submodule k (planeJetRelation (M := M) k j) :=
+  (planeJetRelation (M := M) k (j+1)).comap (planeJetRelation (M := M) k j).subtype
+noncomputable abbrev planeJetLayer (j : ℕ) := (planeJetRelation (M := M) k j) ⧸ planeJetLayerRelation (M := M) k j
+
+noncomputable def planeHomogeneousMultiply (j : ℕ)
+    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) : M →ₗ[k] planeJetRelation (M := M) k j where
+  toFun v := ⟨P.val • v, homogeneous_smul_mem_jet k j P v⟩
+  map_add' _ _ := Subtype.ext (smul_add _ _ _)
+  map_smul' _ _ := Subtype.ext (smul_comm _ _ _)
+
+noncomputable def planeLayerMul (j : ℕ) (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) :
+    M →ₗ[k] planeJetLayer (M := M) k j :=
+  (planeJetLayerRelation (M := M) k j).mkQ.comp (planeHomogeneousMultiply k j P)
+
+lemma planeLayerMul_ker (j : ℕ) (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) :
+    planeJetRelation (M := M) k 1 ≤ (planeLayerMul k j P).ker := by
+  intro v hv
+  exact (Submodule.Quotient.mk_eq_zero _).mpr (homogeneous_smul_pair_mem_next k j P v hv)
+
+noncomputable def planeLayerBilinear (j : ℕ) :
+    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) →ₗ[k]
+      ((M ⧸ planeJetRelation (M := M) k 1) →ₗ[k] planeJetLayer (M := M) k j) where
+  toFun P := (planeJetRelation (M := M) k 1).liftQ (planeLayerMul k j P) (planeLayerMul_ker k j P)
+  map_add' P Q := by
+    apply LinearMap.ext
+    intro t
+    obtain ⟨v,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective t
+    change (planeJetLayerRelation (M := M) k j).mkQ _ =
+      (planeJetLayerRelation (M := M) k j).mkQ _ + (planeJetLayerRelation (M := M) k j).mkQ _
+    rw [← map_add]
+    congr 1
+    exact Subtype.ext (add_smul P.val Q.val v)
+  map_smul' a P := by
+    apply LinearMap.ext
+    intro t
+    obtain ⟨v,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective t
+    change (planeJetLayerRelation (M := M) k j).mkQ _ = a • (planeJetLayerRelation (M := M) k j).mkQ _
+    rw [← map_smul]
+    congr 1
+    exact Subtype.ext (smul_assoc a P.val v)
+
+noncomputable def planeLayerMultiply (j : ℕ) :
+    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
+      (M ⧸ planeJetRelation (M := M) k 1) →ₗ[k] planeJetLayer (M := M) k j :=
+  TensorProduct.lift (planeLayerBilinear k j)
+
+lemma planeLayerMultiply_tmul_mk (j : ℕ)
+    (P : MvPolynomial.homogeneousSubmodule (Fin 2) k j) (v : M) :
+    planeLayerMultiply k j (P ⊗ₜ[k] (planeJetRelation (M := M) k 1).mkQ v) =
+      (planeJetLayerRelation (M := M) k j).mkQ ⟨P.val • v, homogeneous_smul_mem_jet k j P v⟩ := rfl
+
+lemma planeLayerMultiply_sum (j : ℕ) (v : Fin (j+1) → M) :
+    planeLayerMultiply k j (∑ i, jetMonomialBasis k j i ⊗ₜ[k] (planeJetRelation (M := M) k 1).mkQ (v i)) =
+      (planeJetLayerRelation (M := M) k j).mkQ
+        ⟨binarySum (MvPolynomial.X 0) (MvPolynomial.X 1) j v, ⟨v,rfl⟩⟩ := by
+  rw [map_sum]
+  simp only [planeLayerMultiply_tmul_mk, ← map_sum]
+  congr 1
+  apply Subtype.ext
+  simp only [Submodule.coe_sum, jetMonomialBasis_apply, binarySum_apply]
+
+lemma tensor_basis_decomposition {H T : Type u} [AddCommGroup H] [Module k H]
+    [AddCommGroup T] [Module k T] {ι : Type*} [Fintype ι]
+    (b : Module.Basis ι k H) (z : H ⊗[k] T) :
+    ∃ v : ι → T, z = ∑ i, b i ⊗ₜ[k] v i := by
+  classical
+  induction z using TensorProduct.inductionOn with
+  | tmul h t =>
+    refine ⟨fun i => b.repr h i • t, ?_⟩
+    conv_lhs => rw [← b.sum_repr h, TensorProduct.sum_tmul]
+    apply Finset.sum_congr rfl
+    intro i _
+    rw [TensorProduct.smul_tmul, TensorProduct.tmul_smul]
+  | add z w hz hw =>
+    obtain ⟨v,rfl⟩ := hz
+    obtain ⟨w,rfl⟩ := hw
+    exact ⟨v+w, by simp only [Pi.add_apply, TensorProduct.tmul_add, Finset.sum_add_distrib]⟩
+
+lemma planeLayerMultiply_surjective (j : ℕ) :
+    Function.Surjective (planeLayerMultiply (M := M) k j) := by
+  intro z
+  obtain ⟨⟨m,v,rfl⟩,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective z
+  exact ⟨_, planeLayerMultiply_sum k j v⟩
+
+lemma planeLayerMultiply_injective
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
+    Function.Injective (planeLayerMultiply (M := M) k j) := by
+  have hzero : ∀ z, planeLayerMultiply (M := M) k j z = 0 → z = 0 := by
+    intro z hz
+    obtain ⟨v,rfl⟩ := tensor_basis_decomposition k (jetMonomialBasis k j) z
+    choose w hw using fun i => (planeJetRelation (M := M) k 1).mkQ_surjective (v i)
+    have he : v = fun i => (planeJetRelation (M := M) k 1).mkQ (w i) := funext fun i => (hw i).symm
+    rw [he, planeLayerMultiply_sum] at hz
+    have hm := (Submodule.Quotient.mk_eq_zero _).mp hz
+    have hc := (binarySum_mem_next_iff (MvPolynomial.X 0 : MvPolynomial (Fin 2) k)
+      (MvPolynomial.X 1) hx hy j w).mp hm
+    have hv : ∀ i, v i = 0 := by
+      intro i
+      rw [← hw i]
+      apply (Submodule.Quotient.mk_eq_zero _).mpr
+      simpa only [planeJetRelation, Submodule.restrictScalars_mem, jetRelation_one] using hc i
+    simp only [hv, TensorProduct.tmul_zero, Finset.sum_const_zero]
+  intro a b hab
+  apply sub_eq_zero.mp
+  apply hzero
+  rw [map_sub,hab,sub_self]
+
+noncomputable def planeLayerEquiv
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m))
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
+      ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
+    (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
+      (M ⧸ planeJetRelation (M := M) k 1) ≃ₗ[k] planeJetLayer (M := M) k j :=
+  LinearEquiv.ofBijective (planeLayerMultiply k j)
+    ⟨planeLayerMultiply_injective k hx hy j, planeLayerMultiply_surjective k j⟩
+
+noncomputable def planeJetSubrep (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) :
+    Representation k (SL2 k) (planeJetRelation (M := M) k j) :=
+  Representation.subrepresentation σ _ (planeJetRelation_stable k σ hσ j)
+
+lemma planeJetLayerRelation_stable (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k) :
+    planeJetLayerRelation (M := M) k j ≤
+      (planeJetLayerRelation k j).comap (planeJetSubrep k σ hσ j g) := by
+  intro v hv
+  exact planeJetRelation_stable k σ hσ (j+1) g hv
+
+noncomputable def planeJetLayerRep (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) :
+    Representation k (SL2 k) (planeJetLayer (M := M) k j) :=
+  Representation.quotient (planeJetSubrep k σ hσ j) _
+    (planeJetLayerRelation_stable k σ hσ j)
+
+lemma planeLayerMultiply_intertwines (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
+    (z : (MvPolynomial.homogeneousSubmodule (Fin 2) k j) ⊗[k]
+      (M ⧸ planeJetRelation (M := M) k 1)) :
+    planeLayerMultiply (M := M) k j
+      (Representation.tprod ((homogeneousRepresentation j).comp (dualMatrix k))
+        (planeJetRep k σ hσ 1) g z) =
+      planeJetLayerRep k σ hσ j g (planeLayerMultiply k j z) := by
+  induction z using TensorProduct.inductionOn with
+  | tmul P v =>
+    obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k 1).mkQ_surjective v
+    simp only [Representation.tprod_apply, TensorProduct.map_tmul,
+      planeJetRep_mk, planeLayerMultiply_tmul_mk]
+    change (planeJetLayerRelation k j).mkQ ⟨_,_⟩ =
+      (planeJetLayerRelation k j).mkQ ⟨σ g (P.val • w),_⟩
+    congr 1
+    apply Subtype.ext
+    exact (hσ g P.val w).symm
+  | add x y hx hy => simp only [map_add, hx, hy]
+
+lemma planeLayer_finite [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)] (j : ℕ) :
+    Module.Finite k (planeJetLayer (M := M) k j) :=
+  Module.Finite.of_surjective (planeLayerMultiply k j) (planeLayerMultiply_surjective k j)
+
+lemma planeJetRelation_succ_le (j : ℕ) :
+    planeJetRelation (M := M) k (j+1) ≤ planeJetRelation (M := M) k j :=
+  jetRelation_succ_le (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j
+
+lemma planeJetRelation_zero : planeJetRelation (M := M) k 0 = ⊤ := by
+  simp only [planeJetRelation, jetRelation_zero, Submodule.restrictScalars_top]
+
+noncomputable def planeJetTransition (j : ℕ) :
+    (M ⧸ planeJetRelation (M := M) k (j+1)) →ₗ[k] (M ⧸ planeJetRelation (M := M) k j) :=
+  (planeJetRelation k (j+1)).mapQ (planeJetRelation k j) LinearMap.id
+    (planeJetRelation_succ_le k j)
+
+lemma planeJetTransition_mk (j : ℕ) (v : M) :
+    planeJetTransition k j ((planeJetRelation (M := M) k (j+1)).mkQ v) =
+      (planeJetRelation (M := M) k j).mkQ v := rfl
+
+lemma planeJetTransition_surjective (j : ℕ) :
+    Function.Surjective (planeJetTransition (M := M) k j) := by
+  intro v
+  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k j).mkQ_surjective v
+  exact ⟨(planeJetRelation k (j+1)).mkQ w,rfl⟩
+
+noncomputable def planeJetLayerInclusion (j : ℕ) :
+    planeJetLayer (M := M) k j →ₗ[k] (M ⧸ planeJetRelation (M := M) k (j+1)) :=
+  (planeJetLayerRelation k j).liftQ
+    ((planeJetRelation k (j+1)).mkQ.comp (planeJetRelation k j).subtype) (by
+      intro v hv
+      exact (Submodule.Quotient.mk_eq_zero _).mpr hv)
+
+lemma planeJetLayerInclusion_mk (j : ℕ) (v : planeJetRelation (M := M) k j) :
+    planeJetLayerInclusion k j ((planeJetLayerRelation k j).mkQ v) =
+      (planeJetRelation (M := M) k (j+1)).mkQ v.val := rfl
+
+lemma planeJetLayerInclusion_injective (j : ℕ) :
+    Function.Injective (planeJetLayerInclusion (M := M) k j) := by
+  apply (LinearMap.ker_eq_bot (f := planeJetLayerInclusion (M := M) k j)).mp
+  apply (LinearMap.ker_eq_bot' (f := planeJetLayerInclusion (M := M) k j)).mpr
+  intro v hv
+  obtain ⟨w,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective v
+  rw [planeJetLayerInclusion_mk] at hv
+  have hw : w.val ∈ planeJetRelation (M := M) k (j+1) :=
+    (Submodule.Quotient.mk_eq_zero (planeJetRelation k (j+1))).mp hv
+  exact (Submodule.Quotient.mk_eq_zero _).mpr hw
+
+lemma planeJet_shortExact (j : ℕ) :
+    Function.Exact (planeJetLayerInclusion (M := M) k j) (planeJetTransition k j) := by
+  intro v
+  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k (j+1)).mkQ_surjective v
+  constructor
+  · intro hw
+    have hj : w ∈ planeJetRelation (M := M) k j := (Submodule.Quotient.mk_eq_zero _).mp hw
+    exact ⟨(planeJetLayerRelation k j).mkQ ⟨w,hj⟩,rfl⟩
+  · rintro ⟨z,hz⟩
+    obtain ⟨t,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective z
+    rw [← hz, planeJetLayerInclusion_mk, planeJetTransition_mk]
+    exact (Submodule.Quotient.mk_eq_zero _).mpr t.property
+
+lemma planeJet_finite [Module.Finite k (M ⧸ planeJetRelation (M := M) k 1)] (j : ℕ) :
+    Module.Finite k (M ⧸ planeJetRelation (M := M) k j) := by
+  induction j with
+  | zero =>
+    rw [planeJetRelation_zero]
+    infer_instance
+  | succ j ih =>
+    let := ih
+    let := planeLayer_finite (M := M) k j
+    exact Module.Finite.of_exact (planeJet_shortExact k j) (planeJetTransition_surjective k j)
+
+lemma planeJetTransition_intertwines (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
+    (v : M ⧸ planeJetRelation (M := M) k (j+1)) :
+    planeJetTransition k j (planeJetRep k σ hσ (j+1) g v) =
+      planeJetRep k σ hσ j g (planeJetTransition k j v) := by
+  obtain ⟨w,rfl⟩ := (planeJetRelation (M := M) k (j+1)).mkQ_surjective v
+  rfl
+
+lemma planeJetLayerInclusion_intertwines (σ : Representation k (SL2 k) M)
+    (hσ : PlaneCompatible k σ) (j : ℕ) (g : SL2 k)
+    (v : planeJetLayer (M := M) k j) :
+    planeJetLayerInclusion k j (planeJetLayerRep k σ hσ j g v) =
+      planeJetRep k σ hσ (j+1) g (planeJetLayerInclusion k j v) := by
+  obtain ⟨w,rfl⟩ := (planeJetLayerRelation (M := M) k j).mkQ_surjective v
+  rfl
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/JetTriviality.lean

@@ -1,108 +1,108 @@
-import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators Pointwise
-section
-variable {R M N : Type*} [CommRing R] [AddCommGroup M] [Module R M]
-  [AddCommGroup N] [Module R N]
-
-lemma map_binarySum (f : M →ₗ[R] N) (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
-    f (binarySum x y j v) = binarySum x y j (f ∘ v) := by
-  simp only [binarySum_apply, map_sum, map_smul, Function.comp_apply]
-
-lemma jetRelation_map_le (f : M →ₗ[R] N) (x y : R) (j : ℕ) :
-    jetRelation x y j ≤ (jetRelation x y j).comap f := by
-  rintro m ⟨v,rfl⟩
-  exact ⟨f ∘ v, (map_binarySum f x y j v).symm⟩
-
- 
-def jetMap (f : M →ₗ[R] N) (x y : R) (j : ℕ) :
-    (M ⧸ jetRelation (M := M) x y j) →ₗ[R] (N ⧸ jetRelation (M := N) x y j) :=
-  (jetRelation (M := M) x y j).mapQ (jetRelation (M := N) x y j) f (jetRelation_map_le f x y j)
-
-lemma jetMap_mk (f : M →ₗ[R] N) (x y : R) (j : ℕ) (m : M) :
-    jetMap f x y j ((jetRelation x y j).mkQ m) = (jetRelation x y j).mkQ (f m) := rfl
-
- 
-
-lemma jetMap_surjective (f : M →ₗ[R] N) (x y : R)
-    (h0 : ∀ n : N, ∃ m : M, n - f m ∈ pairRelation x y) (j : ℕ) :
-    Function.Surjective (jetMap f x y j) := by
-  suffices H : ∀ n : N, ∃ m : M, n - f m ∈ jetRelation x y j by
-    intro z
-    obtain ⟨n,rfl⟩ := (jetRelation (M := N) x y j).mkQ_surjective z
-    obtain ⟨m,hm⟩ := H n
-    refine ⟨(jetRelation x y j).mkQ m, ?_⟩
-    rw [jetMap_mk, ← sub_eq_zero, ← map_sub]
-    apply (Submodule.Quotient.mk_eq_zero _).mpr
-    simpa only [neg_sub] using (jetRelation x y j).neg_mem hm
-  induction j with
-  | zero => intro n; exact ⟨0, by rw [jetRelation_zero]; trivial⟩
-  | succ j ih =>
-    intro n
-    obtain ⟨m, v, hv⟩ := ih n
-    choose w hw using fun i => h0 (v i)
-    refine ⟨m + binarySum x y j w, ?_⟩
-    have he : n - f (m + binarySum x y j w) =
-        binarySum x y j (v - f ∘ w) := by
-      rw [map_add, map_binarySum, map_sub, hv]
-      abel
-    rw [he]
-    exact binarySum_pairRelation x y j _ hw
-
- 
-
-lemma jetMap_injective (f : M →ₗ[R] N) (x y : R)
-    (hx : Function.Injective (fun n : N => x • n))
-    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w)
-    (h0 : ∀ m : M, f m ∈ pairRelation x y → m ∈ pairRelation x y) (j : ℕ) :
-    Function.Injective (jetMap f x y j) := by
-  have H : ∀ j (m : M), f m ∈ jetRelation x y j → m ∈ jetRelation x y j := by
-    intro j
-    induction j with
-    | zero => intros; rw [jetRelation_zero]; trivial
-    | succ j ih =>
-      intro m hm
-      obtain ⟨v,rfl⟩ := ih m (jetRelation_succ_le x y j hm)
-      rw [map_binarySum] at hm
-      apply binarySum_pairRelation
-      intro i
-      exact h0 (v i) ((binarySum_mem_next_iff x y hx hy j (f ∘ v)).mp hm i)
-  apply (LinearMap.ker_eq_bot (f := jetMap f x y j)).mp
-  apply (LinearMap.ker_eq_bot' (f := jetMap f x y j)).mpr
-  intro z hz
-  obtain ⟨m,rfl⟩ := (jetRelation (M := M) x y j).mkQ_surjective z
-  rw [jetMap_mk] at hz
-  exact (Submodule.Quotient.mk_eq_zero _).mpr
-    (H j m ((Submodule.Quotient.mk_eq_zero _).mp hz))
-
- 
-
-theorem jetMap_bijective (f : M →ₗ[R] N) (x y : R)
-    (hx : Function.Injective (fun n : N => x • n))
-    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w)
-    (h0 : Function.Bijective (jetMap f x y 1)) (j : ℕ) :
-    Function.Bijective (jetMap f x y j) := by
-  constructor
-  · apply jetMap_injective f x y hx hy
-    intro m hm
-    have hz : jetMap f x y 1 ((jetRelation x y 1).mkQ m) = 0 := by
-      rw [jetMap_mk]
-      apply (Submodule.Quotient.mk_eq_zero _).mpr
-      simpa only [jetRelation_one] using hm
-    have hm0 := h0.1 (hz.trans (map_zero _).symm)
-    simpa only [jetRelation_one] using (Submodule.Quotient.mk_eq_zero _).mp hm0
-  · apply jetMap_surjective f x y
-    intro n
-    obtain ⟨z,hz⟩ := h0.2 ((jetRelation x y 1).mkQ n)
-    obtain ⟨m,rfl⟩ := (jetRelation x y 1).mkQ_surjective z
-    refine ⟨m, ?_⟩
-    rw [jetMap_mk] at hz
-    have hh : (jetRelation x y 1).mkQ (n - f m) = 0 := by rw [map_sub, hz, sub_self]
-    simpa only [jetRelation_one] using (Submodule.Quotient.mk_eq_zero _).mp hh
-end
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators Pointwise
+section
+variable {R M N : Type*} [CommRing R] [AddCommGroup M] [Module R M]
+  [AddCommGroup N] [Module R N]
+
+lemma map_binarySum (f : M →ₗ[R] N) (x y : R) (j : ℕ) (v : Fin (j+1) → M) :
+    f (binarySum x y j v) = binarySum x y j (f ∘ v) := by
+  simp only [binarySum_apply, map_sum, map_smul, Function.comp_apply]
+
+lemma jetRelation_map_le (f : M →ₗ[R] N) (x y : R) (j : ℕ) :
+    jetRelation x y j ≤ (jetRelation x y j).comap f := by
+  rintro m ⟨v,rfl⟩
+  exact ⟨f ∘ v, (map_binarySum f x y j v).symm⟩
+
+ 
+def jetMap (f : M →ₗ[R] N) (x y : R) (j : ℕ) :
+    (M ⧸ jetRelation (M := M) x y j) →ₗ[R] (N ⧸ jetRelation (M := N) x y j) :=
+  (jetRelation (M := M) x y j).mapQ (jetRelation (M := N) x y j) f (jetRelation_map_le f x y j)
+
+lemma jetMap_mk (f : M →ₗ[R] N) (x y : R) (j : ℕ) (m : M) :
+    jetMap f x y j ((jetRelation x y j).mkQ m) = (jetRelation x y j).mkQ (f m) := rfl
+
+ 
+
+lemma jetMap_surjective (f : M →ₗ[R] N) (x y : R)
+    (h0 : ∀ n : N, ∃ m : M, n - f m ∈ pairRelation x y) (j : ℕ) :
+    Function.Surjective (jetMap f x y j) := by
+  suffices H : ∀ n : N, ∃ m : M, n - f m ∈ jetRelation x y j by
+    intro z
+    obtain ⟨n,rfl⟩ := (jetRelation (M := N) x y j).mkQ_surjective z
+    obtain ⟨m,hm⟩ := H n
+    refine ⟨(jetRelation x y j).mkQ m, ?_⟩
+    rw [jetMap_mk, ← sub_eq_zero, ← map_sub]
+    apply (Submodule.Quotient.mk_eq_zero _).mpr
+    simpa only [neg_sub] using (jetRelation x y j).neg_mem hm
+  induction j with
+  | zero => intro n; exact ⟨0, by rw [jetRelation_zero]; trivial⟩
+  | succ j ih =>
+    intro n
+    obtain ⟨m, v, hv⟩ := ih n
+    choose w hw using fun i => h0 (v i)
+    refine ⟨m + binarySum x y j w, ?_⟩
+    have he : n - f (m + binarySum x y j w) =
+        binarySum x y j (v - f ∘ w) := by
+      rw [map_add, map_binarySum, map_sub, hv]
+      abel
+    rw [he]
+    exact binarySum_pairRelation x y j _ hw
+
+ 
+
+lemma jetMap_injective (f : M →ₗ[R] N) (x y : R)
+    (hx : Function.Injective (fun n : N => x • n))
+    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w)
+    (h0 : ∀ m : M, f m ∈ pairRelation x y → m ∈ pairRelation x y) (j : ℕ) :
+    Function.Injective (jetMap f x y j) := by
+  have H : ∀ j (m : M), f m ∈ jetRelation x y j → m ∈ jetRelation x y j := by
+    intro j
+    induction j with
+    | zero => intros; rw [jetRelation_zero]; trivial
+    | succ j ih =>
+      intro m hm
+      obtain ⟨v,rfl⟩ := ih m (jetRelation_succ_le x y j hm)
+      rw [map_binarySum] at hm
+      apply binarySum_pairRelation
+      intro i
+      exact h0 (v i) ((binarySum_mem_next_iff x y hx hy j (f ∘ v)).mp hm i)
+  apply (LinearMap.ker_eq_bot (f := jetMap f x y j)).mp
+  apply (LinearMap.ker_eq_bot' (f := jetMap f x y j)).mpr
+  intro z hz
+  obtain ⟨m,rfl⟩ := (jetRelation (M := M) x y j).mkQ_surjective z
+  rw [jetMap_mk] at hz
+  exact (Submodule.Quotient.mk_eq_zero _).mpr
+    (H j m ((Submodule.Quotient.mk_eq_zero _).mp hz))
+
+ 
+
+theorem jetMap_bijective (f : M →ₗ[R] N) (x y : R)
+    (hx : Function.Injective (fun n : N => x • n))
+    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w)
+    (h0 : Function.Bijective (jetMap f x y 1)) (j : ℕ) :
+    Function.Bijective (jetMap f x y j) := by
+  constructor
+  · apply jetMap_injective f x y hx hy
+    intro m hm
+    have hz : jetMap f x y 1 ((jetRelation x y 1).mkQ m) = 0 := by
+      rw [jetMap_mk]
+      apply (Submodule.Quotient.mk_eq_zero _).mpr
+      simpa only [jetRelation_one] using hm
+    have hm0 := h0.1 (hz.trans (map_zero _).symm)
+    simpa only [jetRelation_one] using (Submodule.Quotient.mk_eq_zero _).mp hm0
+  · apply jetMap_surjective f x y
+    intro n
+    obtain ⟨z,hz⟩ := h0.2 ((jetRelation x y 1).mkQ n)
+    obtain ⟨m,rfl⟩ := (jetRelation x y 1).mkQ_surjective z
+    refine ⟨m, ?_⟩
+    rw [jetMap_mk] at hz
+    have hh : (jetRelation x y 1).mkQ (n - f m) = 0 := by rw [map_sub, hz, sub_self]
+    simpa only [jetRelation_one] using (Submodule.Quotient.mk_eq_zero _).mp hh
+end
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LatticeGluing.lean

@@ -1,313 +1,313 @@
-import Mathlib
-
-namespace OAI
-
-/-! Free intersections, power localizations and finite glued lattices. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators TensorProduct
-
-namespace FiberFunctorProof
-section
-
-variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
-
-lemma tensor_span_pair (x y : R) (I : Ideal R) (hI : I = Ideal.span {x,y})
-    (z : I ⊗[R] M) :
-    ∃ u v : M, z = (⟨x, by rw [hI]; exact Ideal.subset_span (by simp)⟩ : I) ⊗ₜ[R] u +
-      (⟨y, by rw [hI]; exact Ideal.subset_span (by simp)⟩ : I) ⊗ₜ[R] v := by
-  let ix : I := ⟨x, by rw [hI]; exact Ideal.subset_span (by simp)⟩
-  let iy : I := ⟨y, by rw [hI]; exact Ideal.subset_span (by simp)⟩
-  change ∃ u v, z = ix ⊗ₜ[R] u + iy ⊗ₜ[R] v
-  induction z using TensorProduct.inductionOn with
-  | tmul a m =>
-    have ha : a.val ∈ Ideal.span {x,y} := hI ▸ a.property
-    obtain ⟨b,c,hbc⟩ := Ideal.mem_span_pair.mp ha
-    have heq : a = b • ix + c • iy := by
-      apply Subtype.ext
-      exact hbc.symm
-    refine ⟨b • m, c • m, ?_⟩
-    rw [heq, TensorProduct.add_tmul, TensorProduct.smul_tmul, TensorProduct.smul_tmul]
-  | add a b ha hb =>
-    obtain ⟨u,v,rfl⟩ := ha
-    obtain ⟨u',v',rfl⟩ := hb
-    exact ⟨u+u', v+v', by simp only [TensorProduct.tmul_add]; abel⟩
-
- 
-
-theorem free_of_two_generators [IsLocalRing R] [Module.FinitePresentation R M]
-    (x y : R) (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) :
-    Module.Free R M := by
-  apply Module.free_of_maximalIdeal_rTensor_injective
-  apply LinearMap.ker_eq_bot.mp
-  apply LinearMap.ker_eq_bot'.mpr
-  intro z hz
-  let I := IsLocalRing.maximalIdeal R
-  let ix : I := ⟨x, by dsimp [I]; rw [hm]; exact Ideal.subset_span (by simp)⟩
-  let iy : I := ⟨y, by dsimp [I]; rw [hm]; exact Ideal.subset_span (by simp)⟩
-  obtain ⟨u,v,hz'⟩ := tensor_span_pair x y I hm z
-  change z = ix ⊗ₜ[R] u + iy ⊗ₜ[R] v at hz'
-  have huv : x • u + y • v = 0 := by
-    have h := congrArg (TensorProduct.lid R M) hz
-    rw [hz'] at h
-    simpa [LinearMap.rTensor_tmul, ix, iy] using h
-  have hv : y • v = x • (-u) := by
-    rw [smul_neg]
-    exact eq_neg_of_add_eq_zero_right huv
-  obtain ⟨w,hw⟩ := hy v (-u) hv
-  have hu : u = -(y • w) := by
-    apply hx
-    change x • u = x • (-(y • w))
-    rw [smul_neg]
-    have := huv
-    rw [hw, smul_comm y x] at this
-    exact eq_neg_of_add_eq_zero_left this
-  rw [hz', hu, hw]
-  simp only [TensorProduct.tmul_neg, TensorProduct.tmul_smul, TensorProduct.smul_tmul']
-  have heq : y • ix = x • iy := by
-    apply Subtype.ext
-    exact mul_comm y x
-  rw [heq]
-  exact neg_add_cancel _
-
-end
-
-section
-
-variable {R K W : Type*} [CommRing R] [Field K] [Algebra R K]
-    [AddCommGroup W] [Module K W] [Module R W] [IsScalarTower R K W]
-
- 
-
-theorem intersection_regular (A B : Submodule R W) (x y : R)
-    (hx : algebraMap R K x ≠ 0) (hy : algebraMap R K y ≠ 0)
-    (hA : ∀ v ∈ A, (algebraMap R K x)⁻¹ • v ∈ A)
-    (hB : ∀ v ∈ B, (algebraMap R K y)⁻¹ • v ∈ B) :
-    Function.Injective (fun m : ↥(A ⊓ B) => x • m) ∧
-      ∀ v n : ↥(A ⊓ B), y • v = x • n → ∃ w : ↥(A ⊓ B), v = x • w := by
-  constructor
-  · intro a b hab
-    apply Subtype.ext
-    have h : (algebraMap R K x) • (a : W) = (algebraMap R K x) • (b : W) := by
-      simpa only [algebraMap_smul, Submodule.coe_smul] using congrArg Subtype.val hab
-    exact (smul_right_injective W hx) h
-  · intro v n hvn
-    have h : (algebraMap R K y) • (v : W) = (algebraMap R K x) • (n : W) := by
-      simpa only [algebraMap_smul, Submodule.coe_smul] using congrArg Subtype.val hvn
-    have hw : (algebraMap R K x)⁻¹ • (v : W) =
-        (algebraMap R K y)⁻¹ • (n : W) := by
-      apply (smul_right_injective W hx)
-      simp only [smul_inv_smul₀ hx]
-      rw [smul_comm, ← h, inv_smul_smul₀ hy]
-    refine ⟨⟨(algebraMap R K x)⁻¹ • (v : W),
-      hA v v.property.1, hw ▸ hB n n.property.2⟩, ?_⟩
-    apply Subtype.ext
-    change (v : W) = x • ((algebraMap R K x)⁻¹ • (v : W))
-    rw [← algebraMap_smul K x, smul_inv_smul₀ hx]
-
- 
-
-theorem intersection_free [IsLocalRing R]
-    (A B : Submodule R W) [Module.FinitePresentation R ↥(A ⊓ B)] (x y : R)
-    (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
-    (hx : algebraMap R K x ≠ 0) (hy : algebraMap R K y ≠ 0)
-    (hA : ∀ v ∈ A, (algebraMap R K x)⁻¹ • v ∈ A)
-    (hB : ∀ v ∈ B, (algebraMap R K y)⁻¹ • v ∈ B) :
-    Module.Free R ↥(A ⊓ B) := by
-  obtain ⟨h1,h2⟩ := intersection_regular A B x y hx hy hA hB
-  exact free_of_two_generators x y hm h1 h2
-
-end
-
- 
-
-section PowerLocalization
-variable {R W : Type*} [CommRing R] [AddCommGroup W] [Module R W]
-
- 
-def powerLocalization (x : R) (L : Submodule R W) : Submodule R W where
-  carrier := {v | ∃ n : ℕ, x ^ n • v ∈ L}
-  zero_mem' := ⟨0, by simp⟩
-  add_mem' := by
-    rintro a b ⟨n,hn⟩ ⟨m,hm⟩
-    refine ⟨n+m, ?_⟩
-    rw [smul_add, pow_add]
-    exact L.add_mem
-      (by rw [mul_comm, mul_smul]; exact L.smul_mem _ hn)
-      (by rw [mul_smul]; exact L.smul_mem _ hm)
-  smul_mem' := by
-    rintro c a ⟨n,hn⟩
-    exact ⟨n, by rw [smul_comm]; exact L.smul_mem c hn⟩
-
-lemma le_powerLocalization (x : R) (L : Submodule R W) : L ≤ powerLocalization x L := by
-  intro v hv
-  exact ⟨0, by simpa using hv⟩
-
-lemma powerLocalization_mono (x : R) {L L' : Submodule R W} (h : L ≤ L') :
-    powerLocalization x L ≤ powerLocalization x L' := by
-  rintro v ⟨n,hn⟩
-  exact ⟨n,h hn⟩
-
-end PowerLocalization
-
-section Field
-variable {R K W : Type*} [CommRing R] [Field K] [Algebra R K]
-    [AddCommGroup W] [Module K W] [Module R W] [IsScalarTower R K W]
-
-lemma powerLocalization_div (x : R) (L : Submodule R W)
-    (hx : algebraMap R K x ≠ 0) {v : W} (hv : v ∈ powerLocalization x L) :
-    (algebraMap R K x)⁻¹ • v ∈ powerLocalization x L := by
-  obtain ⟨n,hn⟩ := hv
-  refine ⟨n+1, ?_⟩
-  rw [pow_succ, mul_smul, ← algebraMap_smul K x, smul_inv_smul₀ hx]
-  exact hn
-
-end Field
-
-section
-variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
-
- 
-def coordinateMap : (ι → R) →ₗ[R] (ι → K) where
-  toFun v i := algebraMap R K (v i)
-  map_add' v w := by ext i; exact map_add _ _ _
-  map_smul' c v := by ext i; simp [Algebra.smul_def]
-
-def coordinateLattice : Submodule R (ι → K) :=
-  LinearMap.range (coordinateMap (R := R) (K := K) (ι := ι))
-
-lemma mem_coordinateLattice (v : ι → K) : v ∈ coordinateLattice (R := R) ↔
-    ∀ i, ∃ r : R, algebraMap R K r = v i := by
-  constructor
-  · rintro ⟨w,rfl⟩ i
-    exact ⟨w i,rfl⟩
-  · intro hv
-    choose w hw using hv
-    exact ⟨w,funext hw⟩
-
-instance coordinateLattice_finite [Finite ι] :
-    Module.Finite R (coordinateLattice (R := R) (K := K) (ι := ι)) := by
-  exact Module.Finite.range _
-
- 
-
-theorem coordinateLattice_intersection [IsDomain R] [GCDMonoid R] [IsFractionRing R K]
-    (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y) :
-    powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι)) ⊓
-      powerLocalization y (coordinateLattice (R := R) (K := K) (ι := ι)) =
-      coordinateLattice (R := R) (K := K) (ι := ι) := by
-  apply le_antisymm
-  · rintro v ⟨⟨n,hn⟩,⟨m,hm⟩⟩
-    apply (mem_coordinateLattice v).mpr
-    intro i
-    obtain ⟨a,ha⟩ := (mem_coordinateLattice _).mp hn i
-    obtain ⟨b,hb⟩ := (mem_coordinateLattice _).mp hm i
-    have hinj : Function.Injective (algebraMap R K) := FaithfulSMul.algebraMap_injective R K
-    have hab : y ^ m * a = x ^ n * b := by
-      apply hinj
-      simp only [map_mul, ha, hb]
-      change algebraMap R K (y ^ m) * (x^n • v i) =
-        algebraMap R K (x ^ n) * (y^m • v i)
-      simp only [Algebra.smul_def]
-      ring
-    have hdiv : x ^ n ∣ a :=
-      (hxy.pow (m := n) (n := m)).dvd_of_dvd_mul_left ⟨b, hab⟩
-    obtain ⟨c,hc⟩ := hdiv
-    refine ⟨c, ?_⟩
-    have hxn : algebraMap R K (x^n) ≠ 0 := by
-      exact fun h => pow_ne_zero n hx (hinj (h.trans (map_zero _).symm))
-    apply mul_left_cancel₀ hxn
-    rw [← map_mul, ← hc, ha]
-    exact Algebra.smul_def _ _
-  · exact le_inf (le_powerLocalization ..) (le_powerLocalization ..)
-
-end
-
-section
-variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
-    [Field K] [Algebra R K] [IsFractionRing R K]
-
- 
-def gluedLattice (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K)) : Submodule R (ι → K) :=
-  powerLocalization x coordinateLattice ⊓
-    (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
-
- 
-
-lemma gluedLattice_bound (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
-    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
-    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
-    {z : ι → K} (hz : z ∈ gluedLattice x y P) :
-    x^d • z ∈ coordinateLattice (R := R) := by
-  change z ∈ powerLocalization x coordinateLattice ∧
-    z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) at hz
-  rw [← coordinateLattice_intersection x y hx hxy]
-  constructor
-  · exact (powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι))).smul_mem (x^d) hz.1
-  change ∃ m : ℕ, y^m • (x^d • z) ∈ coordinateLattice (R := R)
-  obtain ⟨v,hv,hvP⟩ := hz.2
-  obtain ⟨m,hm⟩ := hv
-  refine ⟨d+m, ?_⟩
-  have h := hP (y^m • v) hm
-  have hlin : P (y^m • v) = y^m • P v := (P.restrictScalars R).map_smul _ _
-  rw [hlin, mul_pow, mul_smul] at h
-  change P v = z at hvP
-  rw [hvP, ← mul_smul (y^d) (y^m), ← pow_add, smul_comm (x^d)] at h
-  exact h
-
-theorem gluedLattice_finite [Finite ι] [IsNoetherianRing R]
-    (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
-    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
-    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R)) :
-    Module.Finite R (gluedLattice x y P) := by
-  let f : (ι → K) →ₗ[R] (ι → K) :=
-    (algebraMap R K (x ^ d))⁻¹ • LinearMap.id
-  let L := (coordinateLattice (R := R) (K := K) (ι := ι)).map f
-  have hle : gluedLattice x y P ≤ L := by
-    intro z hz
-    refine ⟨x^d • z, gluedLattice_bound x y hx hxy P d hP hz, ?_⟩
-    change (algebraMap R K (x^d))⁻¹ • (x^d • z) = z
-    rw [← algebraMap_smul K (x^d), inv_smul_smul₀]
-    exact fun h => pow_ne_zero d hx
-      ((FaithfulSMul.algebraMap_injective R K) (h.trans (map_zero _).symm))
-  exact Module.Finite.of_injective (Submodule.inclusion hle) (Submodule.inclusion_injective hle)
-
-end
-
-variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
-    [Field K] [Algebra R K] [IsFractionRing R K]
-
- 
-
-theorem gluedLattice_free [Finite ι] [IsNoetherianRing R] [IsLocalRing R]
-    (x y : R) (hx : x ≠ 0) (hy : y ≠ 0) (hxy : IsRelPrime x y)
-    (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
-    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
-    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R)) :
-    Module.Free R (gluedLattice x y P) := by
-  have hinj := FaithfulSMul.algebraMap_injective R K
-  have hxK : algebraMap R K x ≠ 0 := fun h => hx (hinj (h.trans (map_zero _).symm))
-  have hyK : algebraMap R K y ≠ 0 := fun h => hy (hinj (h.trans (map_zero _).symm))
-  have : Module.Finite R (gluedLattice x y P) := gluedLattice_finite x y hx hxy P d hP
-  have : Module.FinitePresentation R (gluedLattice x y P) :=
-    Module.finitePresentation_of_finite R (gluedLattice x y P)
-  have hB : ∀ z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R),
-      (algebraMap R K y)⁻¹ • z ∈
-        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
-    rintro z ⟨v,hv,rfl⟩
-    refine ⟨(algebraMap R K y)⁻¹ • v, powerLocalization_div y _ hyK hv, ?_⟩
-    exact P.map_smul _ _
-  have : Module.FinitePresentation R
-      ↥(powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι)) ⊓
-        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)) := by
-    change Module.FinitePresentation R (gluedLattice x y P)
-    infer_instance
-  exact intersection_free _ _ x y hm hxK hyK (fun _ hv => powerLocalization_div x _ hxK hv) hB
-
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+/-! Free intersections, power localizations and finite glued lattices. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators TensorProduct
+
+namespace FiberFunctorProof
+section
+
+variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
+
+lemma tensor_span_pair (x y : R) (I : Ideal R) (hI : I = Ideal.span {x,y})
+    (z : I ⊗[R] M) :
+    ∃ u v : M, z = (⟨x, by rw [hI]; exact Ideal.subset_span (by simp)⟩ : I) ⊗ₜ[R] u +
+      (⟨y, by rw [hI]; exact Ideal.subset_span (by simp)⟩ : I) ⊗ₜ[R] v := by
+  let ix : I := ⟨x, by rw [hI]; exact Ideal.subset_span (by simp)⟩
+  let iy : I := ⟨y, by rw [hI]; exact Ideal.subset_span (by simp)⟩
+  change ∃ u v, z = ix ⊗ₜ[R] u + iy ⊗ₜ[R] v
+  induction z using TensorProduct.inductionOn with
+  | tmul a m =>
+    have ha : a.val ∈ Ideal.span {x,y} := hI ▸ a.property
+    obtain ⟨b,c,hbc⟩ := Ideal.mem_span_pair.mp ha
+    have heq : a = b • ix + c • iy := by
+      apply Subtype.ext
+      exact hbc.symm
+    refine ⟨b • m, c • m, ?_⟩
+    rw [heq, TensorProduct.add_tmul, TensorProduct.smul_tmul, TensorProduct.smul_tmul]
+  | add a b ha hb =>
+    obtain ⟨u,v,rfl⟩ := ha
+    obtain ⟨u',v',rfl⟩ := hb
+    exact ⟨u+u', v+v', by simp only [TensorProduct.tmul_add]; abel⟩
+
+ 
+
+theorem free_of_two_generators [IsLocalRing R] [Module.FinitePresentation R M]
+    (x y : R) (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) :
+    Module.Free R M := by
+  apply Module.free_of_maximalIdeal_rTensor_injective
+  apply LinearMap.ker_eq_bot.mp
+  apply LinearMap.ker_eq_bot'.mpr
+  intro z hz
+  let I := IsLocalRing.maximalIdeal R
+  let ix : I := ⟨x, by dsimp [I]; rw [hm]; exact Ideal.subset_span (by simp)⟩
+  let iy : I := ⟨y, by dsimp [I]; rw [hm]; exact Ideal.subset_span (by simp)⟩
+  obtain ⟨u,v,hz'⟩ := tensor_span_pair x y I hm z
+  change z = ix ⊗ₜ[R] u + iy ⊗ₜ[R] v at hz'
+  have huv : x • u + y • v = 0 := by
+    have h := congrArg (TensorProduct.lid R M) hz
+    rw [hz'] at h
+    simpa [LinearMap.rTensor_tmul, ix, iy] using h
+  have hv : y • v = x • (-u) := by
+    rw [smul_neg]
+    exact eq_neg_of_add_eq_zero_right huv
+  obtain ⟨w,hw⟩ := hy v (-u) hv
+  have hu : u = -(y • w) := by
+    apply hx
+    change x • u = x • (-(y • w))
+    rw [smul_neg]
+    have := huv
+    rw [hw, smul_comm y x] at this
+    exact eq_neg_of_add_eq_zero_left this
+  rw [hz', hu, hw]
+  simp only [TensorProduct.tmul_neg, TensorProduct.tmul_smul, TensorProduct.smul_tmul']
+  have heq : y • ix = x • iy := by
+    apply Subtype.ext
+    exact mul_comm y x
+  rw [heq]
+  exact neg_add_cancel _
+
+end
+
+section
+
+variable {R K W : Type*} [CommRing R] [Field K] [Algebra R K]
+    [AddCommGroup W] [Module K W] [Module R W] [IsScalarTower R K W]
+
+ 
+
+theorem intersection_regular (A B : Submodule R W) (x y : R)
+    (hx : algebraMap R K x ≠ 0) (hy : algebraMap R K y ≠ 0)
+    (hA : ∀ v ∈ A, (algebraMap R K x)⁻¹ • v ∈ A)
+    (hB : ∀ v ∈ B, (algebraMap R K y)⁻¹ • v ∈ B) :
+    Function.Injective (fun m : ↥(A ⊓ B) => x • m) ∧
+      ∀ v n : ↥(A ⊓ B), y • v = x • n → ∃ w : ↥(A ⊓ B), v = x • w := by
+  constructor
+  · intro a b hab
+    apply Subtype.ext
+    have h : (algebraMap R K x) • (a : W) = (algebraMap R K x) • (b : W) := by
+      simpa only [algebraMap_smul, Submodule.coe_smul] using congrArg Subtype.val hab
+    exact (smul_right_injective W hx) h
+  · intro v n hvn
+    have h : (algebraMap R K y) • (v : W) = (algebraMap R K x) • (n : W) := by
+      simpa only [algebraMap_smul, Submodule.coe_smul] using congrArg Subtype.val hvn
+    have hw : (algebraMap R K x)⁻¹ • (v : W) =
+        (algebraMap R K y)⁻¹ • (n : W) := by
+      apply (smul_right_injective W hx)
+      simp only [smul_inv_smul₀ hx]
+      rw [smul_comm, ← h, inv_smul_smul₀ hy]
+    refine ⟨⟨(algebraMap R K x)⁻¹ • (v : W),
+      hA v v.property.1, hw ▸ hB n n.property.2⟩, ?_⟩
+    apply Subtype.ext
+    change (v : W) = x • ((algebraMap R K x)⁻¹ • (v : W))
+    rw [← algebraMap_smul K x, smul_inv_smul₀ hx]
+
+ 
+
+theorem intersection_free [IsLocalRing R]
+    (A B : Submodule R W) [Module.FinitePresentation R ↥(A ⊓ B)] (x y : R)
+    (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
+    (hx : algebraMap R K x ≠ 0) (hy : algebraMap R K y ≠ 0)
+    (hA : ∀ v ∈ A, (algebraMap R K x)⁻¹ • v ∈ A)
+    (hB : ∀ v ∈ B, (algebraMap R K y)⁻¹ • v ∈ B) :
+    Module.Free R ↥(A ⊓ B) := by
+  obtain ⟨h1,h2⟩ := intersection_regular A B x y hx hy hA hB
+  exact free_of_two_generators x y hm h1 h2
+
+end
+
+ 
+
+section PowerLocalization
+variable {R W : Type*} [CommRing R] [AddCommGroup W] [Module R W]
+
+ 
+def powerLocalization (x : R) (L : Submodule R W) : Submodule R W where
+  carrier := {v | ∃ n : ℕ, x ^ n • v ∈ L}
+  zero_mem' := ⟨0, by simp⟩
+  add_mem' := by
+    rintro a b ⟨n,hn⟩ ⟨m,hm⟩
+    refine ⟨n+m, ?_⟩
+    rw [smul_add, pow_add]
+    exact L.add_mem
+      (by rw [mul_comm, mul_smul]; exact L.smul_mem _ hn)
+      (by rw [mul_smul]; exact L.smul_mem _ hm)
+  smul_mem' := by
+    rintro c a ⟨n,hn⟩
+    exact ⟨n, by rw [smul_comm]; exact L.smul_mem c hn⟩
+
+lemma le_powerLocalization (x : R) (L : Submodule R W) : L ≤ powerLocalization x L := by
+  intro v hv
+  exact ⟨0, by simpa using hv⟩
+
+lemma powerLocalization_mono (x : R) {L L' : Submodule R W} (h : L ≤ L') :
+    powerLocalization x L ≤ powerLocalization x L' := by
+  rintro v ⟨n,hn⟩
+  exact ⟨n,h hn⟩
+
+end PowerLocalization
+
+section Field
+variable {R K W : Type*} [CommRing R] [Field K] [Algebra R K]
+    [AddCommGroup W] [Module K W] [Module R W] [IsScalarTower R K W]
+
+lemma powerLocalization_div (x : R) (L : Submodule R W)
+    (hx : algebraMap R K x ≠ 0) {v : W} (hv : v ∈ powerLocalization x L) :
+    (algebraMap R K x)⁻¹ • v ∈ powerLocalization x L := by
+  obtain ⟨n,hn⟩ := hv
+  refine ⟨n+1, ?_⟩
+  rw [pow_succ, mul_smul, ← algebraMap_smul K x, smul_inv_smul₀ hx]
+  exact hn
+
+end Field
+
+section
+variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
+
+ 
+def coordinateMap : (ι → R) →ₗ[R] (ι → K) where
+  toFun v i := algebraMap R K (v i)
+  map_add' v w := by ext i; exact map_add _ _ _
+  map_smul' c v := by ext i; simp [Algebra.smul_def]
+
+def coordinateLattice : Submodule R (ι → K) :=
+  LinearMap.range (coordinateMap (R := R) (K := K) (ι := ι))
+
+lemma mem_coordinateLattice (v : ι → K) : v ∈ coordinateLattice (R := R) ↔
+    ∀ i, ∃ r : R, algebraMap R K r = v i := by
+  constructor
+  · rintro ⟨w,rfl⟩ i
+    exact ⟨w i,rfl⟩
+  · intro hv
+    choose w hw using hv
+    exact ⟨w,funext hw⟩
+
+instance coordinateLattice_finite [Finite ι] :
+    Module.Finite R (coordinateLattice (R := R) (K := K) (ι := ι)) := by
+  exact Module.Finite.range _
+
+ 
+
+theorem coordinateLattice_intersection [IsDomain R] [GCDMonoid R] [IsFractionRing R K]
+    (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y) :
+    powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι)) ⊓
+      powerLocalization y (coordinateLattice (R := R) (K := K) (ι := ι)) =
+      coordinateLattice (R := R) (K := K) (ι := ι) := by
+  apply le_antisymm
+  · rintro v ⟨⟨n,hn⟩,⟨m,hm⟩⟩
+    apply (mem_coordinateLattice v).mpr
+    intro i
+    obtain ⟨a,ha⟩ := (mem_coordinateLattice _).mp hn i
+    obtain ⟨b,hb⟩ := (mem_coordinateLattice _).mp hm i
+    have hinj : Function.Injective (algebraMap R K) := FaithfulSMul.algebraMap_injective R K
+    have hab : y ^ m * a = x ^ n * b := by
+      apply hinj
+      simp only [map_mul, ha, hb]
+      change algebraMap R K (y ^ m) * (x^n • v i) =
+        algebraMap R K (x ^ n) * (y^m • v i)
+      simp only [Algebra.smul_def]
+      ring
+    have hdiv : x ^ n ∣ a :=
+      (hxy.pow (m := n) (n := m)).dvd_of_dvd_mul_left ⟨b, hab⟩
+    obtain ⟨c,hc⟩ := hdiv
+    refine ⟨c, ?_⟩
+    have hxn : algebraMap R K (x^n) ≠ 0 := by
+      exact fun h => pow_ne_zero n hx (hinj (h.trans (map_zero _).symm))
+    apply mul_left_cancel₀ hxn
+    rw [← map_mul, ← hc, ha]
+    exact Algebra.smul_def _ _
+  · exact le_inf (le_powerLocalization ..) (le_powerLocalization ..)
+
+end
+
+section
+variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
+    [Field K] [Algebra R K] [IsFractionRing R K]
+
+ 
+def gluedLattice (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K)) : Submodule R (ι → K) :=
+  powerLocalization x coordinateLattice ⊓
+    (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
+
+ 
+
+lemma gluedLattice_bound (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
+    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
+    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
+    {z : ι → K} (hz : z ∈ gluedLattice x y P) :
+    x^d • z ∈ coordinateLattice (R := R) := by
+  change z ∈ powerLocalization x coordinateLattice ∧
+    z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) at hz
+  rw [← coordinateLattice_intersection x y hx hxy]
+  constructor
+  · exact (powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι))).smul_mem (x^d) hz.1
+  change ∃ m : ℕ, y^m • (x^d • z) ∈ coordinateLattice (R := R)
+  obtain ⟨v,hv,hvP⟩ := hz.2
+  obtain ⟨m,hm⟩ := hv
+  refine ⟨d+m, ?_⟩
+  have h := hP (y^m • v) hm
+  have hlin : P (y^m • v) = y^m • P v := (P.restrictScalars R).map_smul _ _
+  rw [hlin, mul_pow, mul_smul] at h
+  change P v = z at hvP
+  rw [hvP, ← mul_smul (y^d) (y^m), ← pow_add, smul_comm (x^d)] at h
+  exact h
+
+theorem gluedLattice_finite [Finite ι] [IsNoetherianRing R]
+    (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
+    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
+    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R)) :
+    Module.Finite R (gluedLattice x y P) := by
+  let f : (ι → K) →ₗ[R] (ι → K) :=
+    (algebraMap R K (x ^ d))⁻¹ • LinearMap.id
+  let L := (coordinateLattice (R := R) (K := K) (ι := ι)).map f
+  have hle : gluedLattice x y P ≤ L := by
+    intro z hz
+    refine ⟨x^d • z, gluedLattice_bound x y hx hxy P d hP hz, ?_⟩
+    change (algebraMap R K (x^d))⁻¹ • (x^d • z) = z
+    rw [← algebraMap_smul K (x^d), inv_smul_smul₀]
+    exact fun h => pow_ne_zero d hx
+      ((FaithfulSMul.algebraMap_injective R K) (h.trans (map_zero _).symm))
+  exact Module.Finite.of_injective (Submodule.inclusion hle) (Submodule.inclusion_injective hle)
+
+end
+
+variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
+    [Field K] [Algebra R K] [IsFractionRing R K]
+
+ 
+
+theorem gluedLattice_free [Finite ι] [IsNoetherianRing R] [IsLocalRing R]
+    (x y : R) (hx : x ≠ 0) (hy : y ≠ 0) (hxy : IsRelPrime x y)
+    (hm : IsLocalRing.maximalIdeal R = Ideal.span {x,y})
+    (P : (ι → K) ≃ₗ[K] (ι → K)) (d : ℕ)
+    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R)) :
+    Module.Free R (gluedLattice x y P) := by
+  have hinj := FaithfulSMul.algebraMap_injective R K
+  have hxK : algebraMap R K x ≠ 0 := fun h => hx (hinj (h.trans (map_zero _).symm))
+  have hyK : algebraMap R K y ≠ 0 := fun h => hy (hinj (h.trans (map_zero _).symm))
+  have : Module.Finite R (gluedLattice x y P) := gluedLattice_finite x y hx hxy P d hP
+  have : Module.FinitePresentation R (gluedLattice x y P) :=
+    Module.finitePresentation_of_finite R (gluedLattice x y P)
+  have hB : ∀ z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R),
+      (algebraMap R K y)⁻¹ • z ∈
+        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
+    rintro z ⟨v,hv,rfl⟩
+    refine ⟨(algebraMap R K y)⁻¹ • v, powerLocalization_div y _ hyK hv, ?_⟩
+    exact P.map_smul _ _
+  have : Module.FinitePresentation R
+      ↥(powerLocalization x (coordinateLattice (R := R) (K := K) (ι := ι)) ⊓
+        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)) := by
+    change Module.FinitePresentation R (gluedLattice x y P)
+    infer_instance
+  exact intersection_free _ _ x y hm hxK hyK (fun _ hv => powerLocalization_div x _ hxK hv) hB
+
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LatticeLocalProjectivity.lean

@@ -1,28 +1,28 @@
-import OAI.RepresentationTheory.RestrictedTilting.BaseChangeProjective
-import OAI.RepresentationTheory.RestrictedTilting.LatticeSwap
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped TensorProduct
-variable {R K S ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
-  [Field K] [Algebra R K] [IsFractionRing R K] [Fintype ι]
-  [CommRing S] [Algebra R S]
-
- 
-
-theorem gluedLattice_projective_baseChange (x y : R) (hx : x ≠ 0)
-    (hxy : IsRelPrime x y) (P : (ι → K) ≃ₗ[K] (ι → K)) (d e : ℕ)
-    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
-    (hQ : ∀ v ∈ coordinateLattice (R := R), (x*y)^e • P.symm v ∈ coordinateLattice (R := R))
-    (hu : IsUnit (algebraMap R S x)) :
-    Module.Projective S (S ⊗[R] gluedLattice x y P) := by
-  apply projective_baseChange_of_split_smul
-    (latticeNumerator x y hx hxy P d hP) (latticeDenominator x y P e hQ) (x^(d+e))
-  · ext v : 1
-    exact latticeDenominator_numerator x y hx hxy P d e hP hQ v
-  · simpa only [map_pow] using hu.pow (d+e)
-
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.BaseChangeProjective
+import OAI.RepresentationTheory.RestrictedTilting.LatticeSwap
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped TensorProduct
+variable {R K S ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
+  [Field K] [Algebra R K] [IsFractionRing R K] [Fintype ι]
+  [CommRing S] [Algebra R S]
+
+ 
+
+theorem gluedLattice_projective_baseChange (x y : R) (hx : x ≠ 0)
+    (hxy : IsRelPrime x y) (P : (ι → K) ≃ₗ[K] (ι → K)) (d e : ℕ)
+    (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
+    (hQ : ∀ v ∈ coordinateLattice (R := R), (x*y)^e • P.symm v ∈ coordinateLattice (R := R))
+    (hu : IsUnit (algebraMap R S x)) :
+    Module.Projective S (S ⊗[R] gluedLattice x y P) := by
+  apply projective_baseChange_of_split_smul
+    (latticeNumerator x y hx hxy P d hP) (latticeDenominator x y P e hQ) (x^(d+e))
+  · ext v : 1
+    exact latticeDenominator_numerator x y hx hxy P d e hP hQ v
+  · simpa only [map_pow] using hu.pow (d+e)
+
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LatticeNumerator.lean

@@ -1,76 +1,76 @@
-import OAI.RepresentationTheory.RestrictedTilting.Basic
-
-namespace OAI
-
-namespace FiberFunctorProof
-section Numerator
-variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
-  [Field K] [Algebra R K] [IsFractionRing R K]
-
-omit [IsDomain R] [GCDMonoid R] in
-lemma coordinateMap_injective : Function.Injective (coordinateMap (R := R) (K := K) (ι := ι)) := by
-  intro v w h
-  funext i
-  exact (FaithfulSMul.algebraMap_injective R K) (congrFun h i)
-
-noncomputable def coordinateEquiv : (ι → R) ≃ₗ[R] coordinateLattice (R := R) (K := K) (ι := ι) :=
-  LinearEquiv.ofInjective (coordinateMap (R := R) (K := K) (ι := ι)) coordinateMap_injective
-
-omit [IsDomain R] [GCDMonoid R] in
-lemma coordinateEquiv_apply (v : ι → R) :
-    (coordinateEquiv (K := K) v).val = coordinateMap v := rfl
-
-variable (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
-  (P : (ι → K) ≃ₗ[K] (ι → K)) (d e : ℕ)
-  (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
-  (hQ : ∀ v ∈ coordinateLattice (R := R), (x*y)^e • P.symm v ∈ coordinateLattice (R := R))
-
- 
-
-noncomputable def latticeNumerator : gluedLattice x y P →ₗ[R] (ι → R) :=
-  (coordinateEquiv (K := K)).symm.toLinearMap ∘ₗ
-    (((x^d) • (gluedLattice x y P).subtype).codRestrict _
-      (fun z => gluedLattice_bound x y hx hxy P d hP z.property))
-
-lemma latticeNumerator_coordinates (z : gluedLattice x y P) :
-    coordinateMap (latticeNumerator x y hx hxy P d hP z) = x^d • z.val := by
-  change (coordinateEquiv (K := K)
-    ((coordinateEquiv (K := K)).symm _)).val = _
-  rw [LinearEquiv.apply_symm_apply]
-  rfl
-
-include hQ in
-omit [IsDomain R] [GCDMonoid R] [IsFractionRing R K] in
-lemma latticeDenominator_mem (v : ι → R) :
-    x^e • coordinateMap (K := K) v ∈ gluedLattice x y P := by
-  have hv : coordinateMap (K := K) v ∈ coordinateLattice (R := R) := ⟨v,rfl⟩
-  constructor
-  · exact ⟨0, by simpa using (coordinateLattice (R := R)).smul_mem (x^e) hv⟩
-  · refine ⟨x^e • P.symm (coordinateMap v), ⟨e, ?_⟩, ?_⟩
-    · simpa only [mul_pow, mul_smul, smul_comm (y^e)] using hQ _ hv
-    · change P (x^e • P.symm (coordinateMap v)) = _
-      rw [linearEquiv_map_base_smul, LinearEquiv.apply_symm_apply]
-
-noncomputable def latticeDenominator : (ι → R) →ₗ[R] gluedLattice x y P :=
-  ((x^e) • coordinateMap (R := R) (K := K)).codRestrict _
-    (latticeDenominator_mem x y P e hQ)
-
-lemma latticeNumerator_denominator (v : ι → R) :
-    latticeNumerator x y hx hxy P d hP (latticeDenominator x y P e hQ v) =
-      x^(d+e) • v := by
-  apply coordinateMap_injective (K := K)
-  rw [latticeNumerator_coordinates, map_smul]
-  change x^d • (x^e • coordinateMap v) = _
-  rw [← mul_smul, ← pow_add]
-
-lemma latticeDenominator_numerator (z : gluedLattice x y P) :
-    latticeDenominator x y P e hQ (latticeNumerator x y hx hxy P d hP z) =
-      x^(d+e) • z := by
-  apply Subtype.ext
-  change x^e • coordinateMap (latticeNumerator x y hx hxy P d hP z) = x^(d+e) • z.val
-  rw [latticeNumerator_coordinates, ← mul_smul, ← pow_add, Nat.add_comm]
-
-end Numerator
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.Basic
+
+namespace OAI
+
+namespace FiberFunctorProof
+section Numerator
+variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
+  [Field K] [Algebra R K] [IsFractionRing R K]
+
+omit [IsDomain R] [GCDMonoid R] in
+lemma coordinateMap_injective : Function.Injective (coordinateMap (R := R) (K := K) (ι := ι)) := by
+  intro v w h
+  funext i
+  exact (FaithfulSMul.algebraMap_injective R K) (congrFun h i)
+
+noncomputable def coordinateEquiv : (ι → R) ≃ₗ[R] coordinateLattice (R := R) (K := K) (ι := ι) :=
+  LinearEquiv.ofInjective (coordinateMap (R := R) (K := K) (ι := ι)) coordinateMap_injective
+
+omit [IsDomain R] [GCDMonoid R] in
+lemma coordinateEquiv_apply (v : ι → R) :
+    (coordinateEquiv (K := K) v).val = coordinateMap v := rfl
+
+variable (x y : R) (hx : x ≠ 0) (hxy : IsRelPrime x y)
+  (P : (ι → K) ≃ₗ[K] (ι → K)) (d e : ℕ)
+  (hP : ∀ v ∈ coordinateLattice (R := R), (x*y)^d • P v ∈ coordinateLattice (R := R))
+  (hQ : ∀ v ∈ coordinateLattice (R := R), (x*y)^e • P.symm v ∈ coordinateLattice (R := R))
+
+ 
+
+noncomputable def latticeNumerator : gluedLattice x y P →ₗ[R] (ι → R) :=
+  (coordinateEquiv (K := K)).symm.toLinearMap ∘ₗ
+    (((x^d) • (gluedLattice x y P).subtype).codRestrict _
+      (fun z => gluedLattice_bound x y hx hxy P d hP z.property))
+
+lemma latticeNumerator_coordinates (z : gluedLattice x y P) :
+    coordinateMap (latticeNumerator x y hx hxy P d hP z) = x^d • z.val := by
+  change (coordinateEquiv (K := K)
+    ((coordinateEquiv (K := K)).symm _)).val = _
+  rw [LinearEquiv.apply_symm_apply]
+  rfl
+
+include hQ in
+omit [IsDomain R] [GCDMonoid R] [IsFractionRing R K] in
+lemma latticeDenominator_mem (v : ι �� R) :
+    x^e • coordinateMap (K := K) v ∈ gluedLattice x y P := by
+  have hv : coordinateMap (K := K) v ∈ coordinateLattice (R := R) := ⟨v,rfl⟩
+  constructor
+  · exact ⟨0, by simpa using (coordinateLattice (R := R)).smul_mem (x^e) hv⟩
+  · refine ⟨x^e • P.symm (coordinateMap v), ⟨e, ?_⟩, ?_⟩
+    · simpa only [mul_pow, mul_smul, smul_comm (y^e)] using hQ _ hv
+    · change P (x^e • P.symm (coordinateMap v)) = _
+      rw [linearEquiv_map_base_smul, LinearEquiv.apply_symm_apply]
+
+noncomputable def latticeDenominator : (ι → R) →ₗ[R] gluedLattice x y P :=
+  ((x^e) • coordinateMap (R := R) (K := K)).codRestrict _
+    (latticeDenominator_mem x y P e hQ)
+
+lemma latticeNumerator_denominator (v : ι → R) :
+    latticeNumerator x y hx hxy P d hP (latticeDenominator x y P e hQ v) =
+      x^(d+e) • v := by
+  apply coordinateMap_injective (K := K)
+  rw [latticeNumerator_coordinates, map_smul]
+  change x^d • (x^e • coordinateMap v) = _
+  rw [← mul_smul, ← pow_add]
+
+lemma latticeDenominator_numerator (z : gluedLattice x y P) :
+    latticeDenominator x y P e hQ (latticeNumerator x y hx hxy P d hP z) =
+      x^(d+e) • z := by
+  apply Subtype.ext
+  change x^e • coordinateMap (latticeNumerator x y hx hxy P d hP z) = x^(d+e) • z.val
+  rw [latticeNumerator_coordinates, ← mul_smul, ← pow_add, Nat.add_comm]
+
+end Numerator
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LatticeSwap.lean

@@ -1,33 +1,33 @@
-import OAI.RepresentationTheory.RestrictedTilting.LatticeNumerator
-
-namespace OAI
-
-namespace FiberFunctorProof
-variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
-  [Field K] [Algebra R K] [IsFractionRing R K]
-
-omit [IsDomain R] [GCDMonoid R] [IsFractionRing R K] in
-lemma lattice_swap_mem (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
-    {v : ι → K} (hv : v ∈ gluedLattice x y P) :
-    P.symm v ∈ gluedLattice y x P.symm := by
-  obtain ⟨h₁,w,h₂,hw⟩ := hv
-  change P w = v at hw
-  constructor
-  · simpa only [← hw, LinearEquiv.symm_apply_apply] using h₂
-  · exact ⟨v,h₁,rfl⟩
-
- 
-
-noncomputable def latticeSwap (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K)) :
-    gluedLattice x y P ≃ₗ[R] gluedLattice y x P.symm where
-  toFun v := ⟨P.symm v.val, lattice_swap_mem x y P v.property⟩
-  invFun v := ⟨P v.val, by
-    simpa only [LinearEquiv.symm_symm] using lattice_swap_mem y x P.symm v.property⟩
-  left_inv v := by apply Subtype.ext; exact P.apply_symm_apply v.val
-  right_inv v := by apply Subtype.ext; exact P.symm_apply_apply v.val
-  map_add' v w := by apply Subtype.ext; exact P.symm.map_add _ _
-  map_smul' a v := by apply Subtype.ext; exact linearEquiv_map_base_smul P.symm a v.val
-
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.LatticeNumerator
+
+namespace OAI
+
+namespace FiberFunctorProof
+variable {R K ι : Type*} [CommRing R] [IsDomain R] [GCDMonoid R]
+  [Field K] [Algebra R K] [IsFractionRing R K]
+
+omit [IsDomain R] [GCDMonoid R] [IsFractionRing R K] in
+lemma lattice_swap_mem (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
+    {v : ι → K} (hv : v ∈ gluedLattice x y P) :
+    P.symm v ∈ gluedLattice y x P.symm := by
+  obtain ⟨h₁,w,h₂,hw⟩ := hv
+  change P w = v at hw
+  constructor
+  · simpa only [← hw, LinearEquiv.symm_apply_apply] using h₂
+  · exact ⟨v,h₁,rfl⟩
+
+ 
+
+noncomputable def latticeSwap (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K)) :
+    gluedLattice x y P ≃ₗ[R] gluedLattice y x P.symm where
+  toFun v := ⟨P.symm v.val, lattice_swap_mem x y P v.property⟩
+  invFun v := ⟨P v.val, by
+    simpa only [LinearEquiv.symm_symm] using lattice_swap_mem y x P.symm v.property⟩
+  left_inv v := by apply Subtype.ext; exact P.apply_symm_apply v.val
+  right_inv v := by apply Subtype.ext; exact P.symm_apply_apply v.val
+  map_add' v w := by apply Subtype.ext; exact P.symm.map_add _ _
+  map_smul' a v := by apply Subtype.ext; exact linearEquiv_map_base_smul P.symm a v.val
+
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LaurentPolynomialSeparation.lean

@@ -1,71 +1,71 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped LaurentPolynomial
-section
-variable {k L : Type*} [Field k] [Infinite k] [Field L] [Algebra k L]
-
-lemma polynomial_eq_of_base_evals (P Q : Polynomial L)
-    (h : ∀ t : k, P.eval (algebraMap k L t) = Q.eval (algebraMap k L t)) : P = Q := by
-  apply Polynomial.eq_of_infinite_eval_eq
-  apply (Set.infinite_range_of_injective (FaithfulSMul.algebraMap_injective k L)).mono
-  rintro _ ⟨t,rfl⟩
-  exact h t
-
-lemma laurent_eq_zero_of_base_evals (P : LaurentPolynomial L)
-    (h : ∀ a : kˣ,
-      LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) P = 0) : P = 0 := by
-  obtain ⟨n,p,hp⟩ := P.exists_T_pow
-  have hp0 : p = 0 := by
-    apply Polynomial.eq_of_infinite_eval_eq
-    apply (((Set.finite_singleton (0:k)).infinite_compl).image
-      (FaithfulSMul.algebraMap_injective k L).injOn).mono
-    rintro b ⟨a,ha,rfl⟩
-    let x : kˣ := Units.mk0 a ha
-    have he := congrArg (LaurentPolynomial.eval₂ (RingHom.id L)
-      (Units.map (algebraMap k L) x)) hp
-    simp only [LaurentPolynomial.eval₂_toLaurent, map_mul, h x, zero_mul,
-      Polynomial.eval₂_id] at he
-    change p.eval (algebraMap k L a) = Polynomial.eval (algebraMap k L a) 0
-    have hx : ((Units.map (algebraMap k L) x : Lˣ) : L) = algebraMap k L a := rfl
-    rw [hx] at he
-    simpa only [Polynomial.eval_zero] using he
-  rw [hp0, map_zero] at hp
-  exact (mul_eq_zero.mp hp.symm).resolve_right (IsUnit.ne_zero (LaurentPolynomial.isUnit_T n))
-
-lemma laurent_eq_of_base_evals (P Q : LaurentPolynomial L)
-    (h : ∀ a : kˣ,
-      LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) P =
-        LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) Q) : P = Q := by
-  apply sub_eq_zero.mp
-  apply laurent_eq_zero_of_base_evals (k := k)
-  intro a
-  rw [map_sub, h a, sub_self]
-lemma laurent_eq_of_evals (P Q : LaurentPolynomial k)
-    (h : ∀ a : kˣ, LaurentPolynomial.eval₂ (RingHom.id k) a P =
-      LaurentPolynomial.eval₂ (RingHom.id k) a Q) : P = Q := by
-  have hz (a : kˣ) : LaurentPolynomial.eval₂ (RingHom.id k) a (P-Q) = 0 := by
-    rw [map_sub, h a, sub_self]
-  obtain ⟨n,p,hp⟩ := (P-Q).exists_T_pow
-  have hp0 : p = 0 := by
-    apply Polynomial.eq_of_infinite_eval_eq
-    apply ((Set.finite_singleton (0:k)).infinite_compl).mono
-    intro a ha
-    let x : kˣ := Units.mk0 a ha
-    have he := congrArg (LaurentPolynomial.eval₂ (RingHom.id k) x) hp
-    simp only [LaurentPolynomial.eval₂_toLaurent, map_mul, hz x, zero_mul,
-      Polynomial.eval₂_id] at he
-    have hx : (x : k) = a := rfl
-    rw [hx] at he
-    change p.eval a = Polynomial.eval a 0
-    simpa only [Polynomial.eval_zero] using he
-  rw [hp0, map_zero] at hp
-  exact sub_eq_zero.mp ((mul_eq_zero.mp hp.symm).resolve_right
-    (IsUnit.ne_zero (LaurentPolynomial.isUnit_T n)))
-
-end
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped LaurentPolynomial
+section
+variable {k L : Type*} [Field k] [Infinite k] [Field L] [Algebra k L]
+
+lemma polynomial_eq_of_base_evals (P Q : Polynomial L)
+    (h : ∀ t : k, P.eval (algebraMap k L t) = Q.eval (algebraMap k L t)) : P = Q := by
+  apply Polynomial.eq_of_infinite_eval_eq
+  apply (Set.infinite_range_of_injective (FaithfulSMul.algebraMap_injective k L)).mono
+  rintro _ ⟨t,rfl⟩
+  exact h t
+
+lemma laurent_eq_zero_of_base_evals (P : LaurentPolynomial L)
+    (h : ∀ a : kˣ,
+      LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) P = 0) : P = 0 := by
+  obtain ⟨n,p,hp⟩ := P.exists_T_pow
+  have hp0 : p = 0 := by
+    apply Polynomial.eq_of_infinite_eval_eq
+    apply (((Set.finite_singleton (0:k)).infinite_compl).image
+      (FaithfulSMul.algebraMap_injective k L).injOn).mono
+    rintro b ⟨a,ha,rfl⟩
+    let x : kˣ := Units.mk0 a ha
+    have he := congrArg (LaurentPolynomial.eval₂ (RingHom.id L)
+      (Units.map (algebraMap k L) x)) hp
+    simp only [LaurentPolynomial.eval₂_toLaurent, map_mul, h x, zero_mul,
+      Polynomial.eval₂_id] at he
+    change p.eval (algebraMap k L a) = Polynomial.eval (algebraMap k L a) 0
+    have hx : ((Units.map (algebraMap k L) x : Lˣ) : L) = algebraMap k L a := rfl
+    rw [hx] at he
+    simpa only [Polynomial.eval_zero] using he
+  rw [hp0, map_zero] at hp
+  exact (mul_eq_zero.mp hp.symm).resolve_right (IsUnit.ne_zero (LaurentPolynomial.isUnit_T n))
+
+lemma laurent_eq_of_base_evals (P Q : LaurentPolynomial L)
+    (h : ∀ a : kˣ,
+      LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) P =
+        LaurentPolynomial.eval₂ (RingHom.id L) (Units.map (algebraMap k L) a) Q) : P = Q := by
+  apply sub_eq_zero.mp
+  apply laurent_eq_zero_of_base_evals (k := k)
+  intro a
+  rw [map_sub, h a, sub_self]
+lemma laurent_eq_of_evals (P Q : LaurentPolynomial k)
+    (h : ∀ a : kˣ, LaurentPolynomial.eval₂ (RingHom.id k) a P =
+      LaurentPolynomial.eval₂ (RingHom.id k) a Q) : P = Q := by
+  have hz (a : kˣ) : LaurentPolynomial.eval₂ (RingHom.id k) a (P-Q) = 0 := by
+    rw [map_sub, h a, sub_self]
+  obtain ⟨n,p,hp⟩ := (P-Q).exists_T_pow
+  have hp0 : p = 0 := by
+    apply Polynomial.eq_of_infinite_eval_eq
+    apply ((Set.finite_singleton (0:k)).infinite_compl).mono
+    intro a ha
+    let x : kˣ := Units.mk0 a ha
+    have he := congrArg (LaurentPolynomial.eval₂ (RingHom.id k) x) hp
+    simp only [LaurentPolynomial.eval₂_toLaurent, map_mul, hz x, zero_mul,
+      Polynomial.eval₂_id] at he
+    have hx : (x : k) = a := rfl
+    rw [hx] at he
+    change p.eval a = Polynomial.eval a 0
+    simpa only [Polynomial.eval_zero] using he
+  rw [hp0, map_zero] at hp
+  exact sub_eq_zero.mp ((mul_eq_zero.mp hp.symm).resolve_right
+    (IsUnit.ne_zero (LaurentPolynomial.isUnit_T n)))
+
+end
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LinearFormalComparison.lean

@@ -1,85 +1,85 @@
-import OAI.RepresentationTheory.RestrictedTilting.MatrixFormalComparison
-import OAI.RepresentationTheory.RestrictedTilting.CoordinateTensor
-
-namespace OAI
-
-namespace FiberFunctorProof
-open Matrix
-open scoped TensorProduct BigOperators
-universe u v
-variable {k : Type u} [Field k] [Infinite k]
-variable {K : Type v} [Field K] [Algebra k K]
-variable {ι : Type u} [Fintype ι] [DecidableEq ι]
-variable {T : Type u} [AddCommGroup T] [Module k T] [Module.Finite k T]
-
-omit [Infinite k] in
-lemma scalarCoordinates_one (v : ι → k) :
-    (TensorProduct.piScalarRight k K K ι) (1 ⊗ₜ[k] v) = fun i => algebraMap k K (v i) := by
-  simp only [TensorProduct.piScalarRight_apply, TensorProduct.piScalarRightHom_tmul,
-    Algebra.smul_def, mul_one]
-
-omit [Infinite k] in
-lemma scalarCoordinates_symm_base (v : ι → k) :
-    (TensorProduct.piScalarRight k K K ι).symm (fun i => algebraMap k K (v i)) = 1 ⊗ₜ[k] v := by
-  rw [← scalarCoordinates_one, LinearEquiv.symm_apply_apply]
-
-omit [Infinite k] [DecidableEq ι] in
-lemma eq_finrank_of_field_equiv (F : (K ⊗[k] T) ≃ₗ[K] (ι → K)) :
-    Module.finrank k T = Module.finrank k (ι → k) := by
-  rw [Module.finrank_fintype_fun_eq_card, ← Module.finrank_baseChange (R := K)]
-  exact F.finrank_eq.trans (Module.finrank_fintype_fun_eq_card K)
-
- 
-
-theorem linear_formal_comparison
-    (ρ : Representation k (SL2 k) T) (hρ : IsRational k ρ)
-    (P : Matrix ι ι (Polynomial k)) (x : K) (hx : x ≠ 0)
-    (F : (K ⊗[k] T) ≃ₗ[K] (ι → K))
-    (hF : ∀ t : k, ∀ v : T,
-      F (1 ⊗ₜ[k] ρ (unipotent k t) v) =
-        polynomialMatrixEval P (algebraMap k K t / x^2) *ᵥ F (1 ⊗ₜ[k] v)) :
-    ∃ E : T ≃ₗ[k] (ι → k), ∀ t : k, ∀ v : T,
-      E (ρ (unipotent k t) v) = polynomialMatrixEval P t *ᵥ E v := by
-  let e : T ≃ₗ[k] (ι → k) := LinearEquiv.ofFinrankEq T (ι → k) (eq_finrank_of_field_equiv F)
-  let τ := coordinateRepresentation k ρ e
-  have hτ : IsRational k τ := coordinateRepresentation_rational k ρ e hρ
-  let Q := TensorProduct.piScalarRight k K K ι
-  let C₀ : (ι → K) ≃ₗ[K] (ι → K) := Q.symm ≪≫ₗ e.symm.baseChange k K _ _ ≪≫ₗ F
-  let C := LinearMap.toMatrix' C₀.toLinearMap
-  have hC : C.det ≠ 0 := (C₀.isUnit_det (Pi.basisFun K ι) (Pi.basisFun K ι)).ne_zero
-  have hCv (v : ι → k) : C *ᵥ (fun i => algebraMap k K (v i)) = F (1 ⊗ₜ[k] e.symm v) := by
-    rw [LinearMap.toMatrix'_mulVec]
-    change F (e.symm.baseChange k K _ _ (Q.symm (fun i => algebraMap k K (v i)))) = _
-    rw [scalarCoordinates_symm_base, LinearEquiv.baseChange_tmul]
-  have hCeq (t : k) : C * (LinearMap.toMatrix' (τ (unipotent k t))).map (algebraMap k K) =
-      polynomialMatrixEval P (algebraMap k K t / x^2) * C := by
-    apply Matrix.ext_of_mulVec_single
-    intro j
-    rw [← Matrix.mulVec_mulVec, ← Matrix.mulVec_mulVec]
-    have hsingle : (Pi.single j 1 : ι → K) = fun i => algebraMap k K ((Pi.single j 1 : ι → k) i) := by
-      funext i
-      simp [Pi.single_apply]
-    have hmap (B : Matrix ι ι k) (v : ι → k) :
-        B.map (algebraMap k K) *ᵥ (fun i => algebraMap k K (v i)) =
-          fun i => algebraMap k K ((B *ᵥ v) i) := by
-      funext i
-      exact (RingHom.map_mulVec (algebraMap k K) B v i).symm
-    rw [hsingle, hmap, hCv, hCv, LinearMap.toMatrix'_mulVec]
-    have heq : e.symm (τ (unipotent k t) (Pi.single j 1)) =
-        ρ (unipotent k t) (e.symm (Pi.single j 1)) := by
-      apply e.injective
-      rw [e.apply_symm_apply, coordinateRepresentation_equiv, e.apply_symm_apply]
-    rw [heq]
-    exact hF t _
-  obtain ⟨D,hD,heD⟩ := matrix_formal_comparison τ hτ P x hx C hC hCeq
-  let E₀ := Matrix.toLinearEquiv (Pi.basisFun k ι) D (isUnit_iff_ne_zero.mpr hD)
-  have hE₀ (v : ι → k) : E₀ v = D *ᵥ v := by
-    rw [Matrix.toLinearEquiv_apply]
-    rfl
-  refine ⟨e.trans E₀, fun t v => ?_⟩
-  simp only [LinearEquiv.trans_apply, hE₀, coordinateRepresentation_equiv]
-  rw [← LinearMap.toMatrix'_mulVec (τ (unipotent k t)), Matrix.mulVec_mulVec,
-    ← heD, ← Matrix.mulVec_mulVec]
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.MatrixFormalComparison
+import OAI.RepresentationTheory.RestrictedTilting.CoordinateTensor
+
+namespace OAI
+
+namespace FiberFunctorProof
+open Matrix
+open scoped TensorProduct BigOperators
+universe u v
+variable {k : Type u} [Field k] [Infinite k]
+variable {K : Type v} [Field K] [Algebra k K]
+variable {ι : Type u} [Fintype ι] [DecidableEq ι]
+variable {T : Type u} [AddCommGroup T] [Module k T] [Module.Finite k T]
+
+omit [Infinite k] in
+lemma scalarCoordinates_one (v : ι → k) :
+    (TensorProduct.piScalarRight k K K ι) (1 ⊗ₜ[k] v) = fun i => algebraMap k K (v i) := by
+  simp only [TensorProduct.piScalarRight_apply, TensorProduct.piScalarRightHom_tmul,
+    Algebra.smul_def, mul_one]
+
+omit [Infinite k] in
+lemma scalarCoordinates_symm_base (v : ι → k) :
+    (TensorProduct.piScalarRight k K K ι).symm (fun i => algebraMap k K (v i)) = 1 ⊗ₜ[k] v := by
+  rw [← scalarCoordinates_one, LinearEquiv.symm_apply_apply]
+
+omit [Infinite k] [DecidableEq ι] in
+lemma eq_finrank_of_field_equiv (F : (K ⊗[k] T) ≃ₗ[K] (ι → K)) :
+    Module.finrank k T = Module.finrank k (ι → k) := by
+  rw [Module.finrank_fintype_fun_eq_card, ← Module.finrank_baseChange (R := K)]
+  exact F.finrank_eq.trans (Module.finrank_fintype_fun_eq_card K)
+
+ 
+
+theorem linear_formal_comparison
+    (ρ : Representation k (SL2 k) T) (hρ : IsRational k ρ)
+    (P : Matrix ι ι (Polynomial k)) (x : K) (hx : x ≠ 0)
+    (F : (K ⊗[k] T) ≃ₗ[K] (ι → K))
+    (hF : ∀ t : k, ∀ v : T,
+      F (1 ⊗ₜ[k] ρ (unipotent k t) v) =
+        polynomialMatrixEval P (algebraMap k K t / x^2) *ᵥ F (1 ⊗ₜ[k] v)) :
+    ∃ E : T ≃ₗ[k] (ι → k), ∀ t : k, ∀ v : T,
+      E (ρ (unipotent k t) v) = polynomialMatrixEval P t *ᵥ E v := by
+  let e : T ≃ₗ[k] (ι → k) := LinearEquiv.ofFinrankEq T (ι → k) (eq_finrank_of_field_equiv F)
+  let τ := coordinateRepresentation k ρ e
+  have hτ : IsRational k τ := coordinateRepresentation_rational k ρ e hρ
+  let Q := TensorProduct.piScalarRight k K K ι
+  let C₀ : (ι → K) ≃ₗ[K] (ι → K) := Q.symm ≪≫ₗ e.symm.baseChange k K _ _ ≪≫ₗ F
+  let C := LinearMap.toMatrix' C₀.toLinearMap
+  have hC : C.det ≠ 0 := (C₀.isUnit_det (Pi.basisFun K ι) (Pi.basisFun K ι)).ne_zero
+  have hCv (v : ι → k) : C *ᵥ (fun i => algebraMap k K (v i)) = F (1 ⊗ₜ[k] e.symm v) := by
+    rw [LinearMap.toMatrix'_mulVec]
+    change F (e.symm.baseChange k K _ _ (Q.symm (fun i => algebraMap k K (v i)))) = _
+    rw [scalarCoordinates_symm_base, LinearEquiv.baseChange_tmul]
+  have hCeq (t : k) : C * (LinearMap.toMatrix' (τ (unipotent k t))).map (algebraMap k K) =
+      polynomialMatrixEval P (algebraMap k K t / x^2) * C := by
+    apply Matrix.ext_of_mulVec_single
+    intro j
+    rw [← Matrix.mulVec_mulVec, ← Matrix.mulVec_mulVec]
+    have hsingle : (Pi.single j 1 : ι → K) = fun i => algebraMap k K ((Pi.single j 1 : ι → k) i) := by
+      funext i
+      simp [Pi.single_apply]
+    have hmap (B : Matrix ι ι k) (v : ι → k) :
+        B.map (algebraMap k K) *ᵥ (fun i => algebraMap k K (v i)) =
+          fun i => algebraMap k K ((B *ᵥ v) i) := by
+      funext i
+      exact (RingHom.map_mulVec (algebraMap k K) B v i).symm
+    rw [hsingle, hmap, hCv, hCv, LinearMap.toMatrix'_mulVec]
+    have heq : e.symm (τ (unipotent k t) (Pi.single j 1)) =
+        ρ (unipotent k t) (e.symm (Pi.single j 1)) := by
+      apply e.injective
+      rw [e.apply_symm_apply, coordinateRepresentation_equiv, e.apply_symm_apply]
+    rw [heq]
+    exact hF t _
+  obtain ⟨D,hD,heD⟩ := matrix_formal_comparison τ hτ P x hx C hC hCeq
+  let E₀ := Matrix.toLinearEquiv (Pi.basisFun k ι) D (isUnit_iff_ne_zero.mpr hD)
+  have hE₀ (v : ι → k) : E₀ v = D *ᵥ v := by
+    rw [Matrix.toLinearEquiv_apply]
+    rfl
+  refine ⟨e.trans E₀, fun t v => ?_⟩
+  simp only [LinearEquiv.trans_apply, hE₀, coordinateRepresentation_equiv]
+  rw [← LinearMap.toMatrix'_mulVec (τ (unipotent k t)), Matrix.mulVec_mulVec,
+    ← heD, ← Matrix.mulVec_mulVec]
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LocalFreeness.lean

@@ -1,139 +1,139 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedLattices
-
-namespace OAI
-
-/-! Weak regularity and local freeness of associated sections. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-open scoped Pointwise TensorProduct
-open RingTheory.Sequence
-
-section
-variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
-
-lemma weaklyRegular_pair_iff (x y : R) :
-    IsWeaklyRegular M [x,y] ↔
-      Function.Injective (fun m : M => x • m) ∧
-        ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w := by
-  rw [isWeaklyRegular_cons_iff, isWeaklyRegular_singleton_iff]
-  change IsSMulRegular M x ∧ IsSMulRegular (M ⧸ (x • (⊤ : Submodule R M))) y ↔ _
-  rw [isSMulRegular_on_quot_iff_lsmul_comap_le]
-  constructor
-  · rintro ⟨hx,hy⟩
-    refine ⟨hx, fun v n hn => ?_⟩
-    have hv : v ∈ x • (⊤ : Submodule R M) := hy (by
-      change y • v ∈ x • (⊤ : Submodule R M)
-      rw [hn]
-      exact Submodule.smul_mem_pointwise_smul n x ⊤ (by trivial))
-    obtain ⟨w,_,hw⟩ := (Submodule.mem_smul_pointwise_iff_exists _ _ _).mp hv
-    exact ⟨w,hw.symm⟩
-  · rintro ⟨hx,hy⟩
-    refine ⟨hx, ?_⟩
-    intro v hv
-    obtain ⟨n,_,hn⟩ := (Submodule.mem_smul_pointwise_iff_exists _ _ _).mp hv
-    obtain ⟨w,hw⟩ := hy v n hn.symm
-    rw [hw]
-    exact Submodule.smul_mem_pointwise_smul w x ⊤ (by trivial)
-
-end
-
- 
-
-theorem flat_baseChange_free {R S M : Type*}
-    [CommRing R] [CommRing S] [Algebra R S] [Module.Flat R S]
-    [IsLocalRing S] [IsNoetherianRing S]
-    [AddCommGroup M] [Module R M] [Module.Finite R M]
-    (x y : R) (hm : IsLocalRing.maximalIdeal S =
-      Ideal.span {algebraMap R S x, algebraMap R S y})
-    (hx : Function.Injective (fun m : M => x • m))
-    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) :
-    Module.Free S (S ⊗[R] M) := by
-  have hr := (weaklyRegular_pair_iff x y).mpr ⟨hx,hy⟩
-  have hS := hr.isWeaklyRegular_lTensor (M₂ := S)
-  obtain ⟨hxS,hyS⟩ := (weaklyRegular_pair_iff (M := S ⊗[R] M) x y).mp hS
-  let : Module.FinitePresentation S (S ⊗[R] M) := Module.finitePresentation_of_finite S _
-  apply free_of_two_generators (algebraMap R S x) (algebraMap R S y) hm
-  · simpa only [algebraMap_smul] using hxS
-  · simpa only [algebraMap_smul] using hyS
-end
-
-open scoped TensorProduct
-
-lemma gluedLattice_regular {R K ι : Type*} [CommRing R] [Field K]
-    [Algebra R K] [FaithfulSMul R K] (x y : R) (hx : x ≠ 0) (hy : y ≠ 0)
-    (P : (ι → K) ≃ₗ[K] (ι → K)) :
-    Function.Injective (fun m : gluedLattice x y P => x • m) ∧
-      ∀ v n : gluedLattice x y P, y • v = x • n →
-        ∃ w : gluedLattice x y P, v = x • w := by
-  have hinj := FaithfulSMul.algebraMap_injective R K
-  have hxK : algebraMap R K x ≠ 0 := fun h => hx (hinj (h.trans (map_zero _).symm))
-  have hyK : algebraMap R K y ≠ 0 := fun h => hy (hinj (h.trans (map_zero _).symm))
-  have hB : ∀ z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R),
-      (algebraMap R K y)⁻¹ • z ∈
-        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
-    rintro z ⟨v,hv,rfl⟩
-    refine ⟨(algebraMap R K y)⁻¹ • v, powerLocalization_div y _ hyK hv, ?_⟩
-    exact P.map_smul _ _
-  exact intersection_regular _ _ x y hxK hyK
-    (fun _ hv => powerLocalization_div x _ hxK hv) hB
-
-lemma regular_pair_equiv {R M N : Type*} [CommRing R]
-    [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N]
-    (e : M ≃ₗ[R] N) (x y : R)
-    (hx : Function.Injective (fun n : N => x • n))
-    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w) :
-    Function.Injective (fun m : M => x • m) ∧
-      ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w := by
-  constructor
-  · intro a b hab
-    apply e.injective
-    apply hx
-    simpa using congrArg e hab
-  · intro v n hn
-    obtain ⟨w,hw⟩ := hy (e v) (e n) (by simpa using congrArg e hn)
-    refine ⟨e.symm w, e.injective ?_⟩
-    simpa using hw
-
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-variable (P : Matrix ι ι (Polynomial k))
-variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-
-include hP in
- 
-theorem associatedSections_regular :
-    Function.Injective (fun m : associatedSectionsSubmodule k ι ρ =>
-      (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) • m) ∧
-    ∀ v n : associatedSectionsSubmodule k ι ρ,
-      (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
-        ∃ w : associatedSectionsSubmodule k ι ρ, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w := by
-  obtain ⟨hx,hy⟩ := gluedLattice_regular
-    (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)
-    (MvPolynomial.X_ne_zero 0) (MvPolynomial.X_ne_zero 1)
-    (planeGlobalTransition k P (associatedPolynomial_zero k ι ρ P hP)
-      (associatedPolynomial_add k ι ρ P hP))
-  exact regular_pair_equiv (associatedLatticeEquiv k ι ρ P hP) _ _ hx hy
-
-include hP in
- 
-
-theorem associatedStalk_free (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    Module.Free (planeOriginRing k)
-      ((planeOriginRing k) ⊗[MvPolynomial (Fin 2) k] (associatedSectionsSubmodule k ι ρ)) := by
-  let : Module.Finite (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
-    associatedSections_finite k ι ρ P hP d hd
-  obtain ⟨hx,hy⟩ := associatedSections_regular k ι ρ P hP
-  exact flat_baseChange_free (MvPolynomial.X 0) (MvPolynomial.X 1)
-    (planeOrigin_maximalIdeal k) hx hy
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedLattices
+
+namespace OAI
+
+/-! Weak regularity and local freeness of associated sections. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+open scoped Pointwise TensorProduct
+open RingTheory.Sequence
+
+section
+variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
+
+lemma weaklyRegular_pair_iff (x y : R) :
+    IsWeaklyRegular M [x,y] ↔
+      Function.Injective (fun m : M => x • m) ∧
+        ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w := by
+  rw [isWeaklyRegular_cons_iff, isWeaklyRegular_singleton_iff]
+  change IsSMulRegular M x ∧ IsSMulRegular (M ⧸ (x • (⊤ : Submodule R M))) y ↔ _
+  rw [isSMulRegular_on_quot_iff_lsmul_comap_le]
+  constructor
+  · rintro ⟨hx,hy⟩
+    refine ⟨hx, fun v n hn => ?_⟩
+    have hv : v ∈ x • (⊤ : Submodule R M) := hy (by
+      change y • v ∈ x • (⊤ : Submodule R M)
+      rw [hn]
+      exact Submodule.smul_mem_pointwise_smul n x ⊤ (by trivial))
+    obtain ⟨w,_,hw⟩ := (Submodule.mem_smul_pointwise_iff_exists _ _ _).mp hv
+    exact ⟨w,hw.symm⟩
+  · rintro ⟨hx,hy⟩
+    refine ⟨hx, ?_⟩
+    intro v hv
+    obtain ⟨n,_,hn⟩ := (Submodule.mem_smul_pointwise_iff_exists _ _ _).mp hv
+    obtain ⟨w,hw⟩ := hy v n hn.symm
+    rw [hw]
+    exact Submodule.smul_mem_pointwise_smul w x ⊤ (by trivial)
+
+end
+
+ 
+
+theorem flat_baseChange_free {R S M : Type*}
+    [CommRing R] [CommRing S] [Algebra R S] [Module.Flat R S]
+    [IsLocalRing S] [IsNoetherianRing S]
+    [AddCommGroup M] [Module R M] [Module.Finite R M]
+    (x y : R) (hm : IsLocalRing.maximalIdeal S =
+      Ideal.span {algebraMap R S x, algebraMap R S y})
+    (hx : Function.Injective (fun m : M => x • m))
+    (hy : ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w) :
+    Module.Free S (S ⊗[R] M) := by
+  have hr := (weaklyRegular_pair_iff x y).mpr ⟨hx,hy⟩
+  have hS := hr.isWeaklyRegular_lTensor (M₂ := S)
+  obtain ⟨hxS,hyS⟩ := (weaklyRegular_pair_iff (M := S ⊗[R] M) x y).mp hS
+  let : Module.FinitePresentation S (S ⊗[R] M) := Module.finitePresentation_of_finite S _
+  apply free_of_two_generators (algebraMap R S x) (algebraMap R S y) hm
+  · simpa only [algebraMap_smul] using hxS
+  · simpa only [algebraMap_smul] using hyS
+end
+
+open scoped TensorProduct
+
+lemma gluedLattice_regular {R K ι : Type*} [CommRing R] [Field K]
+    [Algebra R K] [FaithfulSMul R K] (x y : R) (hx : x ≠ 0) (hy : y ≠ 0)
+    (P : (ι → K) ≃ₗ[K] (ι → K)) :
+    Function.Injective (fun m : gluedLattice x y P => x • m) ∧
+      ∀ v n : gluedLattice x y P, y • v = x • n →
+        ∃ w : gluedLattice x y P, v = x • w := by
+  have hinj := FaithfulSMul.algebraMap_injective R K
+  have hxK : algebraMap R K x ≠ 0 := fun h => hx (hinj (h.trans (map_zero _).symm))
+  have hyK : algebraMap R K y ≠ 0 := fun h => hy (hinj (h.trans (map_zero _).symm))
+  have hB : ∀ z ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R),
+      (algebraMap R K y)⁻¹ • z ∈
+        (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
+    rintro z ⟨v,hv,rfl⟩
+    refine ⟨(algebraMap R K y)⁻¹ • v, powerLocalization_div y _ hyK hv, ?_⟩
+    exact P.map_smul _ _
+  exact intersection_regular _ _ x y hxK hyK
+    (fun _ hv => powerLocalization_div x _ hxK hv) hB
+
+lemma regular_pair_equiv {R M N : Type*} [CommRing R]
+    [AddCommGroup M] [Module R M] [AddCommGroup N] [Module R N]
+    (e : M ≃ₗ[R] N) (x y : R)
+    (hx : Function.Injective (fun n : N => x • n))
+    (hy : ∀ v n : N, y • v = x • n → ∃ w : N, v = x • w) :
+    Function.Injective (fun m : M => x • m) ∧
+      ∀ v n : M, y • v = x • n → ∃ w : M, v = x • w := by
+  constructor
+  · intro a b hab
+    apply e.injective
+    apply hx
+    simpa using congrArg e hab
+  · intro v n hn
+    obtain ⟨w,hw⟩ := hy (e v) (e n) (by simpa using congrArg e hn)
+    refine ⟨e.symm w, e.injective ?_⟩
+    simpa using hw
+
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+variable (P : Matrix ι ι (Polynomial k))
+variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+
+include hP in
+ 
+theorem associatedSections_regular :
+    Function.Injective (fun m : associatedSectionsSubmodule k ι ρ =>
+      (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) • m) ∧
+    ∀ v n : associatedSectionsSubmodule k ι ρ,
+      (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
+        ∃ w : associatedSectionsSubmodule k ι ρ, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w := by
+  obtain ⟨hx,hy⟩ := gluedLattice_regular
+    (MvPolynomial.X (0 : Fin 2) : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)
+    (MvPolynomial.X_ne_zero 0) (MvPolynomial.X_ne_zero 1)
+    (planeGlobalTransition k P (associatedPolynomial_zero k ι ρ P hP)
+      (associatedPolynomial_add k ι ρ P hP))
+  exact regular_pair_equiv (associatedLatticeEquiv k ι ρ P hP) _ _ hx hy
+
+include hP in
+ 
+
+theorem associatedStalk_free (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    Module.Free (planeOriginRing k)
+      ((planeOriginRing k) ⊗[MvPolynomial (Fin 2) k] (associatedSectionsSubmodule k ι ρ)) := by
+  let : Module.Finite (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
+    associatedSections_finite k ι ρ P hP d hd
+  obtain ⟨hx,hy⟩ := associatedSections_regular k ι ρ P hP
+  exact flat_baseChange_free (MvPolynomial.X 0) (MvPolynomial.X 1)
+    (planeOrigin_maximalIdeal k) hx hy
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/LowDegreeTrace.lean

@@ -1,49 +1,49 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators
-universe u v
-variable {k : Type u} [Field k] {E : Type v} [AddGroup E] [Fintype E] [DecidableEq E]
-
- 
-
-lemma additive_lagrange_denominator (l : E →+ k) (a : E) :
-    (∏ b ∈ Finset.univ.erase a, (l a - l b)) =
-      ∏ b ∈ Finset.univ.erase 0, l b := by
-  classical
-  apply Finset.prod_equiv (Equiv.subLeft a)
-  · intro b
-    simp [Equiv.subLeft_apply, sub_eq_zero, eq_comm]
-  · intro b _
-    simp
-
- 
-
-theorem finite_additive_polynomial_sum_zero (l : E →+ k) (hl : Function.Injective l)
-    (P : Polynomial k) (hP : P.natDegree < Fintype.card E - 1) :
-    ∑ a : E, P.eval (l a) = 0 := by
-  classical
-  let c : k := ∏ b ∈ Finset.univ.erase (0 : E), l b
-  have hc : c ≠ 0 := by
-    apply Finset.prod_ne_zero_iff.mpr
-    intro a ha hz
-    have h := hl (show l a = l 0 by simpa using hz)
-    exact (Finset.mem_erase.mp ha).1 h
-  have hd : P.degree < (Finset.univ : Finset E).card := by
-    apply lt_of_le_of_lt Polynomial.degree_le_natDegree
-    exact_mod_cast (show P.natDegree < Fintype.card E by omega)
-  have he := Lagrange.coeff_eq_sum (s := Finset.univ) (v := l) hl.injOn hd
-  have hcoe : P.coeff ((Finset.univ : Finset E).card - 1) = 0 :=
-    Polynomial.coeff_eq_zero_of_natDegree_lt (by simpa using hP)
-  rw [hcoe] at he
-  simp only [additive_lagrange_denominator, ← Finset.sum_div] at he
-  exact (div_eq_zero_iff.mp he.symm).resolve_right hc
-
-lemma finite_additive_power_sum_zero (l : E →+ k) (hl : Function.Injective l)
-    (n : ℕ) (hn : n < Fintype.card E - 1) : ∑ a : E, l a ^ n = 0 := by
-  simpa using finite_additive_polynomial_sum_zero l hl (Polynomial.X ^ n) (by simpa using hn)
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators
+universe u v
+variable {k : Type u} [Field k] {E : Type v} [AddGroup E] [Fintype E] [DecidableEq E]
+
+ 
+
+lemma additive_lagrange_denominator (l : E →+ k) (a : E) :
+    (∏ b ∈ Finset.univ.erase a, (l a - l b)) =
+      ∏ b ∈ Finset.univ.erase 0, l b := by
+  classical
+  apply Finset.prod_equiv (Equiv.subLeft a)
+  · intro b
+    simp [Equiv.subLeft_apply, sub_eq_zero, eq_comm]
+  · intro b _
+    simp
+
+ 
+
+theorem finite_additive_polynomial_sum_zero (l : E →+ k) (hl : Function.Injective l)
+    (P : Polynomial k) (hP : P.natDegree < Fintype.card E - 1) :
+    ∑ a : E, P.eval (l a) = 0 := by
+  classical
+  let c : k := ∏ b ∈ Finset.univ.erase (0 : E), l b
+  have hc : c ≠ 0 := by
+    apply Finset.prod_ne_zero_iff.mpr
+    intro a ha hz
+    have h := hl (show l a = l 0 by simpa using hz)
+    exact (Finset.mem_erase.mp ha).1 h
+  have hd : P.degree < (Finset.univ : Finset E).card := by
+    apply lt_of_le_of_lt Polynomial.degree_le_natDegree
+    exact_mod_cast (show P.natDegree < Fintype.card E by omega)
+  have he := Lagrange.coeff_eq_sum (s := Finset.univ) (v := l) hl.injOn hd
+  have hcoe : P.coeff ((Finset.univ : Finset E).card - 1) = 0 :=
+    Polynomial.coeff_eq_zero_of_natDegree_lt (by simpa using hP)
+  rw [hcoe] at he
+  simp only [additive_lagrange_denominator, ← Finset.sum_div] at he
+  exact (div_eq_zero_iff.mp he.symm).resolve_right hc
+
+lemma finite_additive_power_sum_zero (l : E →+ k) (hl : Function.Injective l)
+    (n : ℕ) (hn : n < Fintype.card E - 1) : ∑ a : E, l a ^ n = 0 := by
+  simpa using finite_additive_polynomial_sum_zero l hl (Polynomial.X ^ n) (by simpa using hn)
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/Main.lean

@@ -1,89 +1,89 @@
-import OAI.RepresentationTheory.RestrictedTilting.AdicJets
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedBundle
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedFibre
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedNumerator
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedPlaneJet
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedProjective
-import OAI.RepresentationTheory.RestrictedTilting.BaseChangeProjective
-import OAI.RepresentationTheory.RestrictedTilting.BoundedOrigin
-import OAI.RepresentationTheory.RestrictedTilting.BoundedOriginTarget
-import OAI.RepresentationTheory.RestrictedTilting.BoundedStableFaithfulness
-import OAI.RepresentationTheory.RestrictedTilting.BoundedUnipotentTilting
-import OAI.RepresentationTheory.RestrictedTilting.BoundedWeightsFactors
-import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
-import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
-import OAI.RepresentationTheory.RestrictedTilting.CompletedCoordinates
-import OAI.RepresentationTheory.RestrictedTilting.CompletionCoefficients
-import OAI.RepresentationTheory.RestrictedTilting.CompletionTriviality
-import OAI.RepresentationTheory.RestrictedTilting.CoordinateTensor
-import OAI.RepresentationTheory.RestrictedTilting.FaithfulTarget
-import OAI.RepresentationTheory.RestrictedTilting.FiniteFreeTrace
-import OAI.RepresentationTheory.RestrictedTilting.FiniteGenerator
-import OAI.RepresentationTheory.RestrictedTilting.FiniteJetMaps
-import OAI.RepresentationTheory.RestrictedTilting.FiniteSubgroupLift
-import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedAction
-import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedIso
-import OAI.RepresentationTheory.RestrictedTilting.FormalLine
-import OAI.RepresentationTheory.RestrictedTilting.FormalLineContinuity
-import OAI.RepresentationTheory.RestrictedTilting.FormalSectionAction
-import OAI.RepresentationTheory.RestrictedTilting.FormalSections
-import OAI.RepresentationTheory.RestrictedTilting.GeneratedStableKernel
-import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
-import OAI.RepresentationTheory.RestrictedTilting.GoodKernelExtension
-import OAI.RepresentationTheory.RestrictedTilting.IntertwinerDescent
-import OAI.RepresentationTheory.RestrictedTilting.JetTriviality
-import OAI.RepresentationTheory.RestrictedTilting.LatticeLocalProjectivity
-import OAI.RepresentationTheory.RestrictedTilting.LatticeNumerator
-import OAI.RepresentationTheory.RestrictedTilting.LatticeSwap
-import OAI.RepresentationTheory.RestrictedTilting.LaurentPolynomialSeparation
-import OAI.RepresentationTheory.RestrictedTilting.LinearFormalComparison
-import OAI.RepresentationTheory.RestrictedTilting.LowDegreeTrace
-import OAI.RepresentationTheory.RestrictedTilting.Basic
-import OAI.RepresentationTheory.RestrictedTilting.MatrixFormalComparison
-import OAI.RepresentationTheory.RestrictedTilting.NormConverse
-import OAI.RepresentationTheory.RestrictedTilting.NormDefinitions
-import OAI.RepresentationTheory.RestrictedTilting.NormFree
-import OAI.RepresentationTheory.RestrictedTilting.NormMaps
-import OAI.RepresentationTheory.RestrictedTilting.NormProjectivity
-import OAI.RepresentationTheory.RestrictedTilting.NumeratorAction
-import OAI.RepresentationTheory.RestrictedTilting.PGroupInvariants
-import OAI.RepresentationTheory.RestrictedTilting.PiPlaneOrigin
-import OAI.RepresentationTheory.RestrictedTilting.PlaneFibre
-import OAI.RepresentationTheory.RestrictedTilting.PlaneMatrixTensor
-import OAI.RepresentationTheory.RestrictedTilting.PolynomialCovers
-import OAI.RepresentationTheory.RestrictedTilting.PolynomialIntertwiner
-import OAI.RepresentationTheory.RestrictedTilting.PolynomialJets
-import OAI.RepresentationTheory.RestrictedTilting.ProjectiveFactor
-import OAI.RepresentationTheory.RestrictedTilting.ProjectiveRegular
-import OAI.RepresentationTheory.RestrictedTilting.RationalHomWeights
-import OAI.RepresentationTheory.RestrictedTilting.RationalMatrices
-import OAI.RepresentationTheory.RestrictedTilting.RegularSplitting
-import OAI.RepresentationTheory.RestrictedTilting.RelativeTrace
-import OAI.RepresentationTheory.RestrictedTilting.RepProducts
-import OAI.RepresentationTheory.RestrictedTilting.RestrictedLift
-import OAI.RepresentationTheory.RestrictedTilting.RestrictedTarget
-import OAI.RepresentationTheory.RestrictedTilting.RestrictedTilting
-import OAI.RepresentationTheory.RestrictedTilting.SmallGroupTrace
-import OAI.RepresentationTheory.RestrictedTilting.SpecializeCompletion
-import OAI.RepresentationTheory.RestrictedTilting.SplitRepresentation
-import OAI.RepresentationTheory.RestrictedTilting.StableKernel
-import OAI.RepresentationTheory.RestrictedTilting.StableRestriction
-import OAI.RepresentationTheory.RestrictedTilting.SteinbergRegular
-import OAI.RepresentationTheory.RestrictedTilting.SteinbergSpan
-import OAI.RepresentationTheory.RestrictedTilting.TensorAssociatedAction
-import OAI.RepresentationTheory.RestrictedTilting.TensorAssociatedIso
-import OAI.RepresentationTheory.RestrictedTilting.TensorCoordinates
-import OAI.RepresentationTheory.RestrictedTilting.TensorExactness
-import OAI.RepresentationTheory.RestrictedTilting.TensorFormalComparison
-import OAI.RepresentationTheory.RestrictedTilting.TensorNumerator
-import OAI.RepresentationTheory.RestrictedTilting.TensorPlaneTilting
-import OAI.RepresentationTheory.RestrictedTilting.TensorWeights
-import OAI.RepresentationTheory.RestrictedTilting.ThetaTarget
-import OAI.RepresentationTheory.RestrictedTilting.TiltingCovers
-import OAI.RepresentationTheory.RestrictedTilting.TorusExtension
-import OAI.RepresentationTheory.RestrictedTilting.TorusRelations
-import OAI.RepresentationTheory.RestrictedTilting.TorusWeightProjection
-import OAI.RepresentationTheory.RestrictedTilting.TraceFactor
-import OAI.RepresentationTheory.RestrictedTilting.UnitAnnihilator
-import OAI.RepresentationTheory.RestrictedTilting.UnitSimple
-import OAI.RepresentationTheory.RestrictedTilting.XChartLineEval
+import OAI.RepresentationTheory.RestrictedTilting.AdicJets
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedBundle
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedFibre
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedNumerator
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedPlaneJet
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedProjective
+import OAI.RepresentationTheory.RestrictedTilting.BaseChangeProjective
+import OAI.RepresentationTheory.RestrictedTilting.BoundedOrigin
+import OAI.RepresentationTheory.RestrictedTilting.BoundedOriginTarget
+import OAI.RepresentationTheory.RestrictedTilting.BoundedStableFaithfulness
+import OAI.RepresentationTheory.RestrictedTilting.BoundedUnipotentTilting
+import OAI.RepresentationTheory.RestrictedTilting.BoundedWeightsFactors
+import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
+import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
+import OAI.RepresentationTheory.RestrictedTilting.CompletedCoordinates
+import OAI.RepresentationTheory.RestrictedTilting.CompletionCoefficients
+import OAI.RepresentationTheory.RestrictedTilting.CompletionTriviality
+import OAI.RepresentationTheory.RestrictedTilting.CoordinateTensor
+import OAI.RepresentationTheory.RestrictedTilting.FaithfulTarget
+import OAI.RepresentationTheory.RestrictedTilting.FiniteFreeTrace
+import OAI.RepresentationTheory.RestrictedTilting.FiniteGenerator
+import OAI.RepresentationTheory.RestrictedTilting.FiniteJetMaps
+import OAI.RepresentationTheory.RestrictedTilting.FiniteSubgroupLift
+import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedAction
+import OAI.RepresentationTheory.RestrictedTilting.FormalAssociatedIso
+import OAI.RepresentationTheory.RestrictedTilting.FormalLine
+import OAI.RepresentationTheory.RestrictedTilting.FormalLineContinuity
+import OAI.RepresentationTheory.RestrictedTilting.FormalSectionAction
+import OAI.RepresentationTheory.RestrictedTilting.FormalSections
+import OAI.RepresentationTheory.RestrictedTilting.GeneratedStableKernel
+import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
+import OAI.RepresentationTheory.RestrictedTilting.GoodKernelExtension
+import OAI.RepresentationTheory.RestrictedTilting.IntertwinerDescent
+import OAI.RepresentationTheory.RestrictedTilting.JetTriviality
+import OAI.RepresentationTheory.RestrictedTilting.LatticeLocalProjectivity
+import OAI.RepresentationTheory.RestrictedTilting.LatticeNumerator
+import OAI.RepresentationTheory.RestrictedTilting.LatticeSwap
+import OAI.RepresentationTheory.RestrictedTilting.LaurentPolynomialSeparation
+import OAI.RepresentationTheory.RestrictedTilting.LinearFormalComparison
+import OAI.RepresentationTheory.RestrictedTilting.LowDegreeTrace
+import OAI.RepresentationTheory.RestrictedTilting.Basic
+import OAI.RepresentationTheory.RestrictedTilting.MatrixFormalComparison
+import OAI.RepresentationTheory.RestrictedTilting.NormConverse
+import OAI.RepresentationTheory.RestrictedTilting.NormDefinitions
+import OAI.RepresentationTheory.RestrictedTilting.NormFree
+import OAI.RepresentationTheory.RestrictedTilting.NormMaps
+import OAI.RepresentationTheory.RestrictedTilting.NormProjectivity
+import OAI.RepresentationTheory.RestrictedTilting.NumeratorAction
+import OAI.RepresentationTheory.RestrictedTilting.PGroupInvariants
+import OAI.RepresentationTheory.RestrictedTilting.PiPlaneOrigin
+import OAI.RepresentationTheory.RestrictedTilting.PlaneFibre
+import OAI.RepresentationTheory.RestrictedTilting.PlaneMatrixTensor
+import OAI.RepresentationTheory.RestrictedTilting.PolynomialCovers
+import OAI.RepresentationTheory.RestrictedTilting.PolynomialIntertwiner
+import OAI.RepresentationTheory.RestrictedTilting.PolynomialJets
+import OAI.RepresentationTheory.RestrictedTilting.ProjectiveFactor
+import OAI.RepresentationTheory.RestrictedTilting.ProjectiveRegular
+import OAI.RepresentationTheory.RestrictedTilting.RationalHomWeights
+import OAI.RepresentationTheory.RestrictedTilting.RationalMatrices
+import OAI.RepresentationTheory.RestrictedTilting.RegularSplitting
+import OAI.RepresentationTheory.RestrictedTilting.RelativeTrace
+import OAI.RepresentationTheory.RestrictedTilting.RepProducts
+import OAI.RepresentationTheory.RestrictedTilting.RestrictedLift
+import OAI.RepresentationTheory.RestrictedTilting.RestrictedTarget
+import OAI.RepresentationTheory.RestrictedTilting.RestrictedTilting
+import OAI.RepresentationTheory.RestrictedTilting.SmallGroupTrace
+import OAI.RepresentationTheory.RestrictedTilting.SpecializeCompletion
+import OAI.RepresentationTheory.RestrictedTilting.SplitRepresentation
+import OAI.RepresentationTheory.RestrictedTilting.StableKernel
+import OAI.RepresentationTheory.RestrictedTilting.StableRestriction
+import OAI.RepresentationTheory.RestrictedTilting.SteinbergRegular
+import OAI.RepresentationTheory.RestrictedTilting.SteinbergSpan
+import OAI.RepresentationTheory.RestrictedTilting.TensorAssociatedAction
+import OAI.RepresentationTheory.RestrictedTilting.TensorAssociatedIso
+import OAI.RepresentationTheory.RestrictedTilting.TensorCoordinates
+import OAI.RepresentationTheory.RestrictedTilting.TensorExactness
+import OAI.RepresentationTheory.RestrictedTilting.TensorFormalComparison
+import OAI.RepresentationTheory.RestrictedTilting.TensorNumerator
+import OAI.RepresentationTheory.RestrictedTilting.TensorPlaneTilting
+import OAI.RepresentationTheory.RestrictedTilting.TensorWeights
+import OAI.RepresentationTheory.RestrictedTilting.ThetaTarget
+import OAI.RepresentationTheory.RestrictedTilting.TiltingCovers
+import OAI.RepresentationTheory.RestrictedTilting.TorusExtension
+import OAI.RepresentationTheory.RestrictedTilting.TorusRelations
+import OAI.RepresentationTheory.RestrictedTilting.TorusWeightProjection
+import OAI.RepresentationTheory.RestrictedTilting.TraceFactor
+import OAI.RepresentationTheory.RestrictedTilting.UnitAnnihilator
+import OAI.RepresentationTheory.RestrictedTilting.UnitSimple
+import OAI.RepresentationTheory.RestrictedTilting.XChartLineEval

lean/OAI/RepresentationTheory/RestrictedTilting/MatrixFormalComparison.lean

@@ -1,50 +1,50 @@
-import OAI.RepresentationTheory.RestrictedTilting.TorusExtension
-import OAI.RepresentationTheory.RestrictedTilting.PolynomialIntertwiner
-import OAI.RepresentationTheory.RestrictedTilting.IntertwinerDescent
-
-namespace OAI
-
-namespace FiberFunctorProof
-universe u v
-variable {k : Type u} [Field k] [Infinite k]
-variable {K : Type v} [Field K] [Algebra k K]
-variable {ι : Type u} [Fintype ι] [DecidableEq ι]
-
- 
-
-theorem matrix_formal_comparison
-    (ρ : Representation k (SL2 k) (ι → k)) (hρ : IsRational k ρ)
-    (P : Matrix ι ι (Polynomial k)) (x : K) (hx : x ≠ 0)
-    (C : Matrix ι ι K) (hC : C.det ≠ 0)
-    (h : ∀ t : k, C * (LinearMap.toMatrix' (ρ (unipotent k t))).map (algebraMap k K) =
-      polynomialMatrixEval P (algebraMap k K t / x^2) * C) :
-    ∃ D : Matrix ι ι k, D.det ≠ 0 ∧ ∀ t : k,
-      polynomialMatrixEval P t * D = D * LinearMap.toMatrix' (ρ (unipotent k t)) := by
-  let B := rationalUnipotentMatrix k ρ hρ
-  have hext : ∀ t : K, C * polynomialMatrixEval B t = polynomialMatrixEval P (t*(x^2)⁻¹)*C := by
-    apply polynomial_intertwiner_extension P B C ((x^2)⁻¹)
-    intro t
-    rw [polynomialMatrixEval_base]
-    have hB : polynomialMatrixEval B t = LinearMap.toMatrix' (ρ (unipotent k t)) :=
-      eval_rationalUnipotentMatrix k ρ hρ t
-    rw [hB]
-    simpa only [div_eq_mul_inv] using h t
-  let xU : Kˣ := Units.mk0 x hx
-  let Q := torusMatrixAt ρ hρ xU
-  have hQ : Q.det ≠ 0 := torusMatrixAt_det_ne_zero ρ hρ xU
-  apply intertwiner_descent (fun t : k => polynomialMatrixEval P t)
-    (fun t : k => LinearMap.toMatrix' (ρ (unipotent k t))) (C*Q)
-    (by rw [Matrix.det_mul]; exact mul_ne_zero hC hQ)
-  intro t
-  have hh := hext (x^2 * algebraMap k K t)
-  have hp : (x^2 * algebraMap k K t) * (x^2)⁻¹ = algebraMap k K t := by
-    field_simp
-  rw [hp] at hh
-  rw [← polynomialMatrixEval_base, ← Matrix.mul_assoc, ← hh, Matrix.mul_assoc]
-  have hQt := torusMatrixAt_unipotent ρ hρ xU t
-  change Q * _ = polynomialMatrixEval B (x^2 * algebraMap k K t) * Q at hQt
-  rw [← hQt, Matrix.mul_assoc]
-
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.TorusExtension
+import OAI.RepresentationTheory.RestrictedTilting.PolynomialIntertwiner
+import OAI.RepresentationTheory.RestrictedTilting.IntertwinerDescent
+
+namespace OAI
+
+namespace FiberFunctorProof
+universe u v
+variable {k : Type u} [Field k] [Infinite k]
+variable {K : Type v} [Field K] [Algebra k K]
+variable {ι : Type u} [Fintype ι] [DecidableEq ι]
+
+ 
+
+theorem matrix_formal_comparison
+    (ρ : Representation k (SL2 k) (ι → k)) (hρ : IsRational k ρ)
+    (P : Matrix ι ι (Polynomial k)) (x : K) (hx : x ≠ 0)
+    (C : Matrix ι ι K) (hC : C.det ≠ 0)
+    (h : ∀ t : k, C * (LinearMap.toMatrix' (ρ (unipotent k t))).map (algebraMap k K) =
+      polynomialMatrixEval P (algebraMap k K t / x^2) * C) :
+    ∃ D : Matrix ι ι k, D.det ≠ 0 ∧ ∀ t : k,
+      polynomialMatrixEval P t * D = D * LinearMap.toMatrix' (ρ (unipotent k t)) := by
+  let B := rationalUnipotentMatrix k ρ hρ
+  have hext : ∀ t : K, C * polynomialMatrixEval B t = polynomialMatrixEval P (t*(x^2)⁻¹)*C := by
+    apply polynomial_intertwiner_extension P B C ((x^2)⁻¹)
+    intro t
+    rw [polynomialMatrixEval_base]
+    have hB : polynomialMatrixEval B t = LinearMap.toMatrix' (ρ (unipotent k t)) :=
+      eval_rationalUnipotentMatrix k ρ hρ t
+    rw [hB]
+    simpa only [div_eq_mul_inv] using h t
+  let xU : Kˣ := Units.mk0 x hx
+  let Q := torusMatrixAt ρ hρ xU
+  have hQ : Q.det ≠ 0 := torusMatrixAt_det_ne_zero ρ hρ xU
+  apply intertwiner_descent (fun t : k => polynomialMatrixEval P t)
+    (fun t : k => LinearMap.toMatrix' (ρ (unipotent k t))) (C*Q)
+    (by rw [Matrix.det_mul]; exact mul_ne_zero hC hQ)
+  intro t
+  have hh := hext (x^2 * algebraMap k K t)
+  have hp : (x^2 * algebraMap k K t) * (x^2)⁻¹ = algebraMap k K t := by
+    field_simp
+  rw [hp] at hh
+  rw [← polynomialMatrixEval_base, ← Matrix.mul_assoc, ← hh, Matrix.mul_assoc]
+  have hQt := torusMatrixAt_unipotent ρ hρ xU t
+  change Q * _ = polynomialMatrixEval B (x^2 * algebraMap k K t) * Q at hQt
+  rw [← hQt, Matrix.mul_assoc]
+
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NormConverse.lean

@@ -1,96 +1,96 @@
-import OAI.RepresentationTheory.RestrictedTilting.NormMaps
-import OAI.RepresentationTheory.RestrictedTilting.PGroupInvariants
-import OAI.RepresentationTheory.RestrictedTilting.ProjectiveRegular
-import OAI.RepresentationTheory.RestrictedTilting.SplitRepresentation
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory Representation
-universe u
-variable {k : Type u} [Field k] {p : ℕ} [Fact p.Prime] [CharP k p]
-variable {G : Type u} [Group G] [Fintype G]
-variable {V : Type u} [AddCommGroup V] [Module k V]
-
- 
-
-lemma regular_map_injective (hG : IsPGroup p G) (ρ : Representation k G V)
-    (f : (Representation.leftRegular k G).IntertwiningMap ρ)
-    (hN : f ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)) ≠ 0) :
-    Function.Injective f := by
-  apply LinearMap.ker_eq_bot.mp
-  apply le_antisymm _ bot_le
-  intro x hx
-  change x = 0
-  by_contra hx0
-  have hxk : (⟨x,hx⟩ : f.ker.toSubmodule) ≠ 0 := fun h => hx0 (congrArg Subtype.val h)
-  obtain ⟨z,hz,hfix⟩ := pgroup_exists_invariant hG f.ker.toRepresentation ⟨x,hx⟩ hxk
-  have hval : (z : MonoidAlgebra k G) ≠ 0 := fun h => hz (Subtype.ext h)
-  have hzN := regular_invariant_eq (z : MonoidAlgebra k G)
-    (fun g => congrArg Subtype.val (hfix g))
-  have hz0 : f (z : MonoidAlgebra k G) = 0 := z.property
-  have hc : (z : MonoidAlgebra k G).coeff 1 = 0 := by
-    rw [hzN, map_smul] at hz0
-    exact (smul_eq_zero.mp hz0).resolve_right hN
-  apply hval
-  rw [hzN, hc, zero_smul]
-
- 
-
-theorem projective_of_normSurjective (hG : IsPGroup p G)
-    [FiniteDimensional k V] (ρ : Representation k G V) (hρ : NormSurjective ρ) :
-    Projective (Rep.of ρ) := by
-  suffices H : ∀ n : ℕ, ∀ (M : Type u) [AddCommGroup M] [Module k M]
-      [FiniteDimensional k M], Module.finrank k M = n →
-      ∀ τ : Representation k G M, NormSurjective τ → Projective (Rep.of τ) by
-    exact H _ V rfl ρ hρ
-  intro n
-  induction n using Nat.strong_induction_on with
-  | h n ih =>
-    intro M _ _ _ hdim τ hτ
-    cases subsingleton_or_nontrivial M with
-    | inl hs =>
-      let := hs
-      constructor
-      intro E X f e he
-      refine ⟨0, ?_⟩
-      rw [Limits.zero_comp]
-      apply Rep.hom_ext
-      apply IntertwiningMap.ext
-      ext m
-      rw [Subsingleton.elim m 0]
-      simp
-    | inr hnt =>
-      let := hnt
-      obtain ⟨v,hv⟩ := exists_ne (0 : M)
-      obtain ⟨w,hw,hfix⟩ := pgroup_exists_invariant hG τ v hv
-      obtain ⟨m,hm⟩ := hτ w hfix
-      let f : (Representation.leftRegular k G).IntertwiningMap τ :=
-        (Rep.leftRegularHom (Rep.of τ) m).hom
-      have hfm : f (MonoidAlgebra.single 1 1) = m := by simp [f]
-      have hfn : f ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)) ≠ 0 := by
-        rw [intertwining_norm f, hfm, hm]
-        exact hw
-      have hf := regular_map_injective hG τ f hfn
-      obtain ⟨s,hs⟩ := regular_split_of_injective τ f hf
-      let κ := s.ker.toRepresentation
-      have hκ : NormSurjective κ :=
-        normSurjective_of_retract (kernelInclusion s)
-          (splitKernelProjection f s hs) (splitKernelProjection_inclusion f s hs) hτ
-      have hker : s.toLinearMap.ker ≠ ⊤ := by
-        intro htop
-        have hzero : s (f (MonoidAlgebra.single 1 1)) = 0 := by
-          exact (show f (MonoidAlgebra.single 1 1) ∈ s.toLinearMap.ker by rw [htop]; trivial)
-        have hsf : s (f (MonoidAlgebra.single 1 1)) = MonoidAlgebra.single 1 1 :=
-          congr($(hs) (MonoidAlgebra.single 1 1))
-        rw [hsf] at hzero
-        have hh := congrArg (fun v : MonoidAlgebra k G => v.coeff 1) hzero
-        simp at hh
-      have hlt : Module.finrank k s.ker.toSubmodule < n := by
-        rw [← hdim]
-        exact Submodule.finrank_lt hker
-      have hK : Projective (Rep.of κ) := ih _ hlt _ rfl κ hκ
-      exact projective_of_split_kernel f s hs (rep_leftRegular_projective k G) hK
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.NormMaps
+import OAI.RepresentationTheory.RestrictedTilting.PGroupInvariants
+import OAI.RepresentationTheory.RestrictedTilting.ProjectiveRegular
+import OAI.RepresentationTheory.RestrictedTilting.SplitRepresentation
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory Representation
+universe u
+variable {k : Type u} [Field k] {p : ℕ} [Fact p.Prime] [CharP k p]
+variable {G : Type u} [Group G] [Fintype G]
+variable {V : Type u} [AddCommGroup V] [Module k V]
+
+ 
+
+lemma regular_map_injective (hG : IsPGroup p G) (ρ : Representation k G V)
+    (f : (Representation.leftRegular k G).IntertwiningMap ρ)
+    (hN : f ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)) ≠ 0) :
+    Function.Injective f := by
+  apply LinearMap.ker_eq_bot.mp
+  apply le_antisymm _ bot_le
+  intro x hx
+  change x = 0
+  by_contra hx0
+  have hxk : (⟨x,hx⟩ : f.ker.toSubmodule) ≠ 0 := fun h => hx0 (congrArg Subtype.val h)
+  obtain ⟨z,hz,hfix⟩ := pgroup_exists_invariant hG f.ker.toRepresentation ⟨x,hx⟩ hxk
+  have hval : (z : MonoidAlgebra k G) ≠ 0 := fun h => hz (Subtype.ext h)
+  have hzN := regular_invariant_eq (z : MonoidAlgebra k G)
+    (fun g => congrArg Subtype.val (hfix g))
+  have hz0 : f (z : MonoidAlgebra k G) = 0 := z.property
+  have hc : (z : MonoidAlgebra k G).coeff 1 = 0 := by
+    rw [hzN, map_smul] at hz0
+    exact (smul_eq_zero.mp hz0).resolve_right hN
+  apply hval
+  rw [hzN, hc, zero_smul]
+
+ 
+
+theorem projective_of_normSurjective (hG : IsPGroup p G)
+    [FiniteDimensional k V] (ρ : Representation k G V) (hρ : NormSurjective ρ) :
+    Projective (Rep.of ρ) := by
+  suffices H : ∀ n : ℕ, ∀ (M : Type u) [AddCommGroup M] [Module k M]
+      [FiniteDimensional k M], Module.finrank k M = n →
+      ∀ τ : Representation k G M, NormSurjective τ → Projective (Rep.of τ) by
+    exact H _ V rfl ρ hρ
+  intro n
+  induction n using Nat.strong_induction_on with
+  | h n ih =>
+    intro M _ _ _ hdim τ hτ
+    cases subsingleton_or_nontrivial M with
+    | inl hs =>
+      let := hs
+      constructor
+      intro E X f e he
+      refine ⟨0, ?_⟩
+      rw [Limits.zero_comp]
+      apply Rep.hom_ext
+      apply IntertwiningMap.ext
+      ext m
+      rw [Subsingleton.elim m 0]
+      simp
+    | inr hnt =>
+      let := hnt
+      obtain ⟨v,hv⟩ := exists_ne (0 : M)
+      obtain ⟨w,hw,hfix⟩ := pgroup_exists_invariant hG τ v hv
+      obtain ⟨m,hm⟩ := hτ w hfix
+      let f : (Representation.leftRegular k G).IntertwiningMap τ :=
+        (Rep.leftRegularHom (Rep.of τ) m).hom
+      have hfm : f (MonoidAlgebra.single 1 1) = m := by simp [f]
+      have hfn : f ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)) ≠ 0 := by
+        rw [intertwining_norm f, hfm, hm]
+        exact hw
+      have hf := regular_map_injective hG τ f hfn
+      obtain ⟨s,hs⟩ := regular_split_of_injective τ f hf
+      let κ := s.ker.toRepresentation
+      have hκ : NormSurjective κ :=
+        normSurjective_of_retract (kernelInclusion s)
+          (splitKernelProjection f s hs) (splitKernelProjection_inclusion f s hs) hτ
+      have hker : s.toLinearMap.ker ≠ ⊤ := by
+        intro htop
+        have hzero : s (f (MonoidAlgebra.single 1 1)) = 0 := by
+          exact (show f (MonoidAlgebra.single 1 1) ∈ s.toLinearMap.ker by rw [htop]; trivial)
+        have hsf : s (f (MonoidAlgebra.single 1 1)) = MonoidAlgebra.single 1 1 :=
+          congr($(hs) (MonoidAlgebra.single 1 1))
+        rw [hsf] at hzero
+        have hh := congrArg (fun v : MonoidAlgebra k G => v.coeff 1) hzero
+        simp at hh
+      have hlt : Module.finrank k s.ker.toSubmodule < n := by
+        rw [← hdim]
+        exact Submodule.finrank_lt hker
+      have hK : Projective (Rep.of κ) := ih _ hlt _ rfl κ hκ
+      exact projective_of_split_kernel f s hs (rep_leftRegular_projective k G) hK
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NormDefinitions.lean

@@ -1,39 +1,39 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory Representation
-universe u v
-variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
-variable {V : Type u} [AddCommGroup V] [Module k V]
-
- 
-noncomputable def normToInvariants (ρ : Representation k G V) : V →ₗ[k] ρ.invariants :=
-  ρ.norm.codRestrict _ (fun v g => ρ.self_norm_apply g v)
-
- 
-noncomputable def coinvariantNorm (ρ : Representation k G V) :
-    Coinvariants ρ →ₗ[k] ρ.invariants :=
-  Coinvariants.lift ρ (normToInvariants ρ) (fun g => by
-    ext v
-    exact ρ.norm_self_apply g v)
-
-@[simp] theorem coinvariantNorm_mk (ρ : Representation k G V) (v : V) :
-    (coinvariantNorm ρ (Coinvariants.mk ρ v) : V) = ρ.norm v := rfl
-
- 
-
-def NormProjectivityTheorem : Prop :=
-  ∀ (k : Type u) [Field k] [IsAlgClosed k] (p : ℕ) [Fact p.Prime] [CharP k p],
-    (∀ (H : Type u) [Group H] [Fintype H], IsPGroup p H →
-      ∀ (M : Type u) [AddCommGroup M] [Module k M] [FiniteDimensional k M]
-      (ρ : Representation k H M),
-      Projective (Rep.of ρ) ↔ Function.Bijective (coinvariantNorm ρ)) ∧
-    (∀ (G : Type u) [Group G] [Fintype G]
-      (M : Type u) [AddCommGroup M] [Module k M] [FiniteDimensional k M]
-      (ρ : Representation k G M),
-      Projective (Rep.of ρ) → Function.Bijective (coinvariantNorm ρ))
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory Representation
+universe u v
+variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
+variable {V : Type u} [AddCommGroup V] [Module k V]
+
+ 
+noncomputable def normToInvariants (ρ : Representation k G V) : V →ₗ[k] ρ.invariants :=
+  ρ.norm.codRestrict _ (fun v g => ρ.self_norm_apply g v)
+
+ 
+noncomputable def coinvariantNorm (ρ : Representation k G V) :
+    Coinvariants ρ →ₗ[k] ρ.invariants :=
+  Coinvariants.lift ρ (normToInvariants ρ) (fun g => by
+    ext v
+    exact ρ.norm_self_apply g v)
+
+@[simp] theorem coinvariantNorm_mk (ρ : Representation k G V) (v : V) :
+    (coinvariantNorm ρ (Coinvariants.mk ρ v) : V) = ρ.norm v := rfl
+
+ 
+
+def NormProjectivityTheorem : Prop :=
+  ∀ (k : Type u) [Field k] [IsAlgClosed k] (p : ℕ) [Fact p.Prime] [CharP k p],
+    (∀ (H : Type u) [Group H] [Fintype H], IsPGroup p H →
+      ∀ (M : Type u) [AddCommGroup M] [Module k M] [FiniteDimensional k M]
+      (ρ : Representation k H M),
+      Projective (Rep.of ρ) ↔ Function.Bijective (coinvariantNorm ρ)) ∧
+    (∀ (G : Type u) [Group G] [Fintype G]
+      (M : Type u) [AddCommGroup M] [Module k M] [FiniteDimensional k M]
+      (ρ : Representation k G M),
+      Projective (Rep.of ρ) → Function.Bijective (coinvariantNorm ρ))
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NormFree.lean

@@ -1,100 +1,100 @@
-import OAI.RepresentationTheory.RestrictedTilting.NormMaps
-
-namespace OAI
-
-namespace FiberFunctorProof
-open Representation
-universe u
-variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
-variable (I : Type u)
-
- 
-
-noncomputable def freeNormRepresentative :
-    (I →₀ MonoidAlgebra k G) →ₗ[k] (I →₀ MonoidAlgebra k G) :=
-  Finsupp.mapRange.linearMap
-    ((MonoidAlgebra.lsingle 1).comp
-      ((Finsupp.lapply 1).comp (MonoidAlgebra.coeffLinearEquiv k).toLinearMap))
-
-omit [Fintype G] in
-@[simp] lemma freeNormRepresentative_apply (x : I →₀ MonoidAlgebra k G) (i : I) :
-    freeNormRepresentative I x i = MonoidAlgebra.single 1 ((x i).coeff 1) := rfl
-
-omit [Fintype G] in
-lemma free_action_apply (g : G) (x : I →₀ MonoidAlgebra k G) (i : I) :
-    Representation.free k G I g x i = Representation.leftRegular k G g (x i) := by
-  classical
-  have H : (Finsupp.lapply i).comp (Representation.free k G I g) =
-      (Representation.leftRegular k G g).comp (Finsupp.lapply i) := by
-    apply Finsupp.lhom_ext
-    intro j v
-    simp only [LinearMap.comp_apply, Representation.finsupp_single, Finsupp.lapply_apply]
-    by_cases h : j = i
-    · subst j; simp
-    · simp [Ne.symm h]
-  exact congr($(H) x)
-
-lemma free_norm_apply (x : I →₀ MonoidAlgebra k G) (i : I) :
-    (Representation.free k G I).norm x i = (Representation.leftRegular k G).norm (x i) := by
-  classical
-  simp only [Representation.norm, LinearMap.sum_apply, Finsupp.finsetSum_apply, free_action_apply]
-
-lemma free_normRepresentative_invariant (x : I →₀ MonoidAlgebra k G)
-    (hx : ∀ g, Representation.free k G I g x = x) :
-    (Representation.free k G I).norm (freeNormRepresentative I x) = x := by
-  apply Finsupp.ext
-  intro i
-  rw [free_norm_apply, freeNormRepresentative_apply]
-  have hxi (g : G) : Representation.leftRegular k G g (x i) = x i := by
-    have hi := congrArg (fun v : I →₀ MonoidAlgebra k G => v i) (hx g)
-    simpa only [free_action_apply] using hi
-  have heq : MonoidAlgebra.single (1:G) ((x i).coeff 1) =
-      (x i).coeff 1 • MonoidAlgebra.single 1 (1 : k) := by simp
-  rw [heq, map_smul]
-  exact (regular_invariant_eq (x i) hxi).symm
-
-lemma free_normRepresentative_coinvariant :
-    (Coinvariants.mk (Representation.free k G I)).comp
-      ((freeNormRepresentative I).comp (Representation.free k G I).norm) =
-      Coinvariants.mk (Representation.free k G I) := by
-  classical
-  ext i g
-  have hn : (Representation.free k G I).norm (Finsupp.single i (MonoidAlgebra.single g (1:k))) =
-      Finsupp.single i ((Representation.leftRegular k G).norm (MonoidAlgebra.single g 1)) := by
-    simp only [Representation.norm, LinearMap.sum_apply, Representation.finsupp_single]
-    exact (map_sum (Finsupp.lsingle i : MonoidAlgebra k G →ₗ[k] (I →₀ MonoidAlgebra k G))
-      (fun h => Representation.leftRegular k G h (MonoidAlgebra.single g 1)) Finset.univ).symm
-  have hone : ((Representation.leftRegular k G).norm (MonoidAlgebra.single g (1:k))).coeff 1 = 1 := by
-    rw [Representation.leftRegular_norm_apply]
-    simp [regular_norm_single_coeff]
-  have hrep : freeNormRepresentative I
-      (Finsupp.single i ((Representation.leftRegular k G).norm (MonoidAlgebra.single g (1:k)))) =
-      Finsupp.single i (MonoidAlgebra.single 1 1) := by
-    simp [freeNormRepresentative, hone]
-  change Coinvariants.mk _ (freeNormRepresentative I ((Representation.free k G I).norm
-      (Finsupp.single i (MonoidAlgebra.single g 1)))) = _
-  rw [hn, hrep]
-  simpa [Representation.free_single_single] using
-    (Coinvariants.mk_self_apply (Representation.free k G I) g
-      (Finsupp.single i (MonoidAlgebra.single 1 (1:k)))).symm
-
- 
-
-theorem free_norm_bijective : Function.Bijective
-    (coinvariantNorm (Representation.free k G I)) := by
-  constructor
-  · intro a b hab
-    obtain ⟨x,rfl⟩ := Coinvariants.mk_surjective _ a
-    obtain ⟨y,rfl⟩ := Coinvariants.mk_surjective _ b
-    have hn := congrArg Subtype.val hab
-    have hx := congr($(free_normRepresentative_coinvariant (k:=k) (G:=G) I) x)
-    have hy := congr($(free_normRepresentative_coinvariant (k:=k) (G:=G) I) y)
-    dsimp only [LinearMap.comp_apply] at hx hy
-    rw [← hx, ← hy]
-    exact congrArg (fun z => Coinvariants.mk _ (freeNormRepresentative I z)) hn
-  · apply (coinvariantNorm_surjective_iff _).2
-    intro x hx
-    exact ⟨freeNormRepresentative I x, free_normRepresentative_invariant I x hx⟩
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.NormMaps
+
+namespace OAI
+
+namespace FiberFunctorProof
+open Representation
+universe u
+variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
+variable (I : Type u)
+
+ 
+
+noncomputable def freeNormRepresentative :
+    (I →₀ MonoidAlgebra k G) →ₗ[k] (I →₀ MonoidAlgebra k G) :=
+  Finsupp.mapRange.linearMap
+    ((MonoidAlgebra.lsingle 1).comp
+      ((Finsupp.lapply 1).comp (MonoidAlgebra.coeffLinearEquiv k).toLinearMap))
+
+omit [Fintype G] in
+@[simp] lemma freeNormRepresentative_apply (x : I →₀ MonoidAlgebra k G) (i : I) :
+    freeNormRepresentative I x i = MonoidAlgebra.single 1 ((x i).coeff 1) := rfl
+
+omit [Fintype G] in
+lemma free_action_apply (g : G) (x : I →₀ MonoidAlgebra k G) (i : I) :
+    Representation.free k G I g x i = Representation.leftRegular k G g (x i) := by
+  classical
+  have H : (Finsupp.lapply i).comp (Representation.free k G I g) =
+      (Representation.leftRegular k G g).comp (Finsupp.lapply i) := by
+    apply Finsupp.lhom_ext
+    intro j v
+    simp only [LinearMap.comp_apply, Representation.finsupp_single, Finsupp.lapply_apply]
+    by_cases h : j = i
+    · subst j; simp
+    · simp [Ne.symm h]
+  exact congr($(H) x)
+
+lemma free_norm_apply (x : I →₀ MonoidAlgebra k G) (i : I) :
+    (Representation.free k G I).norm x i = (Representation.leftRegular k G).norm (x i) := by
+  classical
+  simp only [Representation.norm, LinearMap.sum_apply, Finsupp.finsetSum_apply, free_action_apply]
+
+lemma free_normRepresentative_invariant (x : I →₀ MonoidAlgebra k G)
+    (hx : ∀ g, Representation.free k G I g x = x) :
+    (Representation.free k G I).norm (freeNormRepresentative I x) = x := by
+  apply Finsupp.ext
+  intro i
+  rw [free_norm_apply, freeNormRepresentative_apply]
+  have hxi (g : G) : Representation.leftRegular k G g (x i) = x i := by
+    have hi := congrArg (fun v : I →₀ MonoidAlgebra k G => v i) (hx g)
+    simpa only [free_action_apply] using hi
+  have heq : MonoidAlgebra.single (1:G) ((x i).coeff 1) =
+      (x i).coeff 1 • MonoidAlgebra.single 1 (1 : k) := by simp
+  rw [heq, map_smul]
+  exact (regular_invariant_eq (x i) hxi).symm
+
+lemma free_normRepresentative_coinvariant :
+    (Coinvariants.mk (Representation.free k G I)).comp
+      ((freeNormRepresentative I).comp (Representation.free k G I).norm) =
+      Coinvariants.mk (Representation.free k G I) := by
+  classical
+  ext i g
+  have hn : (Representation.free k G I).norm (Finsupp.single i (MonoidAlgebra.single g (1:k))) =
+      Finsupp.single i ((Representation.leftRegular k G).norm (MonoidAlgebra.single g 1)) := by
+    simp only [Representation.norm, LinearMap.sum_apply, Representation.finsupp_single]
+    exact (map_sum (Finsupp.lsingle i : MonoidAlgebra k G →ₗ[k] (I →₀ MonoidAlgebra k G))
+      (fun h => Representation.leftRegular k G h (MonoidAlgebra.single g 1)) Finset.univ).symm
+  have hone : ((Representation.leftRegular k G).norm (MonoidAlgebra.single g (1:k))).coeff 1 = 1 := by
+    rw [Representation.leftRegular_norm_apply]
+    simp [regular_norm_single_coeff]
+  have hrep : freeNormRepresentative I
+      (Finsupp.single i ((Representation.leftRegular k G).norm (MonoidAlgebra.single g (1:k)))) =
+      Finsupp.single i (MonoidAlgebra.single 1 1) := by
+    simp [freeNormRepresentative, hone]
+  change Coinvariants.mk _ (freeNormRepresentative I ((Representation.free k G I).norm
+      (Finsupp.single i (MonoidAlgebra.single g 1)))) = _
+  rw [hn, hrep]
+  simpa [Representation.free_single_single] using
+    (Coinvariants.mk_self_apply (Representation.free k G I) g
+      (Finsupp.single i (MonoidAlgebra.single 1 (1:k)))).symm
+
+ 
+
+theorem free_norm_bijective : Function.Bijective
+    (coinvariantNorm (Representation.free k G I)) := by
+  constructor
+  · intro a b hab
+    obtain ⟨x,rfl⟩ := Coinvariants.mk_surjective _ a
+    obtain ⟨y,rfl⟩ := Coinvariants.mk_surjective _ b
+    have hn := congrArg Subtype.val hab
+    have hx := congr($(free_normRepresentative_coinvariant (k:=k) (G:=G) I) x)
+    have hy := congr($(free_normRepresentative_coinvariant (k:=k) (G:=G) I) y)
+    dsimp only [LinearMap.comp_apply] at hx hy
+    rw [← hx, ← hy]
+    exact congrArg (fun z => Coinvariants.mk _ (freeNormRepresentative I z)) hn
+  · apply (coinvariantNorm_surjective_iff _).2
+    intro x hx
+    exact ⟨freeNormRepresentative I x, free_normRepresentative_invariant I x hx⟩
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NormMaps.lean

@@ -1,58 +1,58 @@
-import OAI.RepresentationTheory.RestrictedTilting.NormDefinitions
-import OAI.RepresentationTheory.RestrictedTilting.RegularSplitting
-
-namespace OAI
-
-namespace FiberFunctorProof
-open Representation
-universe u
-variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
-variable {V W : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
-
- 
-def NormSurjective (ρ : Representation k G V) : Prop :=
-  ∀ w : V, (∀ g, ρ g w = w) → ∃ v, ρ.norm v = w
-
-lemma coinvariantNorm_surjective_iff (ρ : Representation k G V) :
-    Function.Surjective (coinvariantNorm ρ) ↔ NormSurjective ρ := by
-  constructor
-  · intro h w hw
-    obtain ⟨c,hc⟩ := h ⟨w,hw⟩
-    obtain ⟨v,rfl⟩ := Coinvariants.mk_surjective ρ c
-    exact ⟨v,congrArg Subtype.val hc⟩
-  · intro h w
-    obtain ⟨v,hv⟩ := h w w.property
-    exact ⟨Coinvariants.mk ρ v, Subtype.ext hv⟩
-
-lemma normSurjective_of_retract {ρ : Representation k G V} {σ : Representation k G W}
-    (f : ρ.IntertwiningMap σ) (s : σ.IntertwiningMap ρ)
-    (h : s.comp f = IntertwiningMap.id ρ) (hσ : NormSurjective σ) : NormSurjective ρ := by
-  have hsf (v : V) : s (f v) = v := congr($(h) v)
-  intro w hw
-  obtain ⟨v,hv⟩ := hσ (f w) (fun g => by rw [← f.isIntertwining, hw g])
-  exact ⟨s v, by rw [← intertwining_norm s, hv, hsf]⟩
-
-lemma norm_bijective_of_retract {ρ : Representation k G V} {σ : Representation k G W}
-    (f : ρ.IntertwiningMap σ) (s : σ.IntertwiningMap ρ)
-    (h : s.comp f = IntertwiningMap.id ρ)
-    (hσ : Function.Bijective (coinvariantNorm σ)) :
-    Function.Bijective (coinvariantNorm ρ) := by
-  classical
-  have hsf (v : V) : s (f v) = v := congr($(h) v)
-  constructor
-  · intro a b hab
-    obtain ⟨v,rfl⟩ := Coinvariants.mk_surjective ρ a
-    obtain ⟨w,rfl⟩ := Coinvariants.mk_surjective ρ b
-    have hvw : ρ.norm v = ρ.norm w := congrArg Subtype.val hab
-    have hn : coinvariantNorm σ (Coinvariants.mk σ (f v)) =
-        coinvariantNorm σ (Coinvariants.mk σ (f w)) := by
-      apply Subtype.ext
-      change σ.norm (f v) = σ.norm (f w)
-      rw [← intertwining_norm f, ← intertwining_norm f, hvw]
-    have hc := congrArg (Coinvariants.map σ ρ s) (hσ.1 hn)
-    simpa only [Coinvariants.map_mk, hsf] using hc
-  · exact (coinvariantNorm_surjective_iff ρ).2 (normSurjective_of_retract f s h
-      ((coinvariantNorm_surjective_iff σ).1 hσ.2))
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.NormDefinitions
+import OAI.RepresentationTheory.RestrictedTilting.RegularSplitting
+
+namespace OAI
+
+namespace FiberFunctorProof
+open Representation
+universe u
+variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
+variable {V W : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+
+ 
+def NormSurjective (ρ : Representation k G V) : Prop :=
+  ∀ w : V, (∀ g, ρ g w = w) → ∃ v, ρ.norm v = w
+
+lemma coinvariantNorm_surjective_iff (ρ : Representation k G V) :
+    Function.Surjective (coinvariantNorm ρ) ↔ NormSurjective ρ := by
+  constructor
+  · intro h w hw
+    obtain ⟨c,hc⟩ := h ⟨w,hw⟩
+    obtain ⟨v,rfl⟩ := Coinvariants.mk_surjective ρ c
+    exact ⟨v,congrArg Subtype.val hc⟩
+  · intro h w
+    obtain ⟨v,hv⟩ := h w w.property
+    exact ⟨Coinvariants.mk ρ v, Subtype.ext hv⟩
+
+lemma normSurjective_of_retract {ρ : Representation k G V} {σ : Representation k G W}
+    (f : ρ.IntertwiningMap σ) (s : σ.IntertwiningMap ρ)
+    (h : s.comp f = IntertwiningMap.id ρ) (hσ : NormSurjective σ) : NormSurjective ρ := by
+  have hsf (v : V) : s (f v) = v := congr($(h) v)
+  intro w hw
+  obtain ⟨v,hv⟩ := hσ (f w) (fun g => by rw [← f.isIntertwining, hw g])
+  exact ⟨s v, by rw [← intertwining_norm s, hv, hsf]⟩
+
+lemma norm_bijective_of_retract {ρ : Representation k G V} {σ : Representation k G W}
+    (f : ρ.IntertwiningMap σ) (s : σ.IntertwiningMap ρ)
+    (h : s.comp f = IntertwiningMap.id ρ)
+    (hσ : Function.Bijective (coinvariantNorm σ)) :
+    Function.Bijective (coinvariantNorm ρ) := by
+  classical
+  have hsf (v : V) : s (f v) = v := congr($(h) v)
+  constructor
+  · intro a b hab
+    obtain ⟨v,rfl⟩ := Coinvariants.mk_surjective ρ a
+    obtain ⟨w,rfl⟩ := Coinvariants.mk_surjective ρ b
+    have hvw : ρ.norm v = ρ.norm w := congrArg Subtype.val hab
+    have hn : coinvariantNorm σ (Coinvariants.mk σ (f v)) =
+        coinvariantNorm σ (Coinvariants.mk σ (f w)) := by
+      apply Subtype.ext
+      change σ.norm (f v) = σ.norm (f w)
+      rw [← intertwining_norm f, ← intertwining_norm f, hvw]
+    have hc := congrArg (Coinvariants.map σ ρ s) (hσ.1 hn)
+    simpa only [Coinvariants.map_mk, hsf] using hc
+  · exact (coinvariantNorm_surjective_iff ρ).2 (normSurjective_of_retract f s h
+      ((coinvariantNorm_surjective_iff σ).1 hσ.2))
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NormProjectivity.lean

@@ -1,41 +1,41 @@
-import OAI.RepresentationTheory.RestrictedTilting.NormConverse
-import OAI.RepresentationTheory.RestrictedTilting.NormFree
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory Representation
-universe u
-variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
-variable {V : Type u} [AddCommGroup V] [Module k V]
-
- 
-
-theorem norm_bijective_of_projective (ρ : Representation k G V)
-    (hρ : Projective (Rep.of ρ)) : Function.Bijective (coinvariantNorm ρ) := by
-  let e : Rep.free k G V ⟶ Rep.of ρ := Rep.ofHom (Representation.freeLift ρ id)
-  have he : Function.Surjective e.hom := by
-    intro v
-    refine ⟨Finsupp.single v (MonoidAlgebra.single 1 1), ?_⟩
-    simp [e]
-  let : Epi e := (Rep.epi_iff_surjective e).2 he
-  obtain ⟨s,hs⟩ := hρ.factors (𝟙 (Rep.of ρ)) e
-  apply norm_bijective_of_retract s.hom e.hom
-  · exact congrArg Rep.Hom.hom hs
-  · exact free_norm_bijective V
-
- 
-
-theorem norm_projectivity : NormProjectivityTheorem.{u} := by
-  intro k _ _ p _ _
-  constructor
-  · intro G _ _ hG V _ _ _ ρ
-    constructor
-    · exact norm_bijective_of_projective ρ
-    · intro h
-      exact projective_of_normSurjective hG ρ ((coinvariantNorm_surjective_iff ρ).1 h.2)
-  · intro G _ _ V _ _ _ ρ
-    exact norm_bijective_of_projective ρ
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.NormConverse
+import OAI.RepresentationTheory.RestrictedTilting.NormFree
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory Representation
+universe u
+variable {k : Type u} [Field k] {G : Type u} [Group G] [Fintype G]
+variable {V : Type u} [AddCommGroup V] [Module k V]
+
+ 
+
+theorem norm_bijective_of_projective (ρ : Representation k G V)
+    (hρ : Projective (Rep.of ρ)) : Function.Bijective (coinvariantNorm ρ) := by
+  let e : Rep.free k G V ⟶ Rep.of ρ := Rep.ofHom (Representation.freeLift ρ id)
+  have he : Function.Surjective e.hom := by
+    intro v
+    refine ⟨Finsupp.single v (MonoidAlgebra.single 1 1), ?_⟩
+    simp [e]
+  let : Epi e := (Rep.epi_iff_surjective e).2 he
+  obtain ⟨s,hs⟩ := hρ.factors (𝟙 (Rep.of ρ)) e
+  apply norm_bijective_of_retract s.hom e.hom
+  · exact congrArg Rep.Hom.hom hs
+  · exact free_norm_bijective V
+
+ 
+
+theorem norm_projectivity : NormProjectivityTheorem.{u} := by
+  intro k _ _ p _ _
+  constructor
+  · intro G _ _ hG V _ _ _ ρ
+    constructor
+    · exact norm_bijective_of_projective ρ
+    · intro h
+      exact projective_of_normSurjective hG ρ ((coinvariantNorm_surjective_iff ρ).1 h.2)
+  · intro G _ _ V _ _ _ ρ
+    exact norm_bijective_of_projective ρ
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/NumeratorAction.lean

@@ -1,54 +1,54 @@
-import OAI.RepresentationTheory.RestrictedTilting.AssociatedNumerator
-import OAI.RepresentationTheory.RestrictedTilting.XChartLineEval
-import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-variable (P : Matrix ι ι (Polynomial k))
-variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
-local notation "N" => associatedSectionsSubmodule k ι ρ
-local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
-
-lemma associatedNumerator_line_eval (a : kˣ) (f : N) (i : ι) :
-    (linePolynomial k (W f i)).eval (a : k) = (a : k)^d *
-      regularVectorEvaluation k ι (diagonalTorus k a) f.val i := by
-  rw [linePolynomial_eval]
-  change planeLineEval k a (W f i) = _
-  have h := congrArg (chartLineEval k a) (associatedNumeratorLinear_spec k ι ρ P hP d hd f i)
-  rw [chartLineEval_algebraMap, map_mul, map_pow, chartLineEval_coordinate] at h
-  simpa only [ite_true, congrFun (associatedXChart_line k ι ρ a f) i] using h
-
- 
-
-lemma associatedNumerator_line_unipotent (t : k) (f : N) (i : ι) :
-    Polynomial.X^(2*d) * linePolynomial k
-      (W (associatedSectionsRepresentation k ι ρ (unipotent k t) f) i) =
-      ∑ j, clearedLineAction k (P i j) t d * linePolynomial k (W f j) := by
-  apply Polynomial.eq_of_infinite_eval_eq
-  apply (Set.finite_singleton (0 : k)).infinite_compl.mono
-  intro a ha
-  have ha0 : a ≠ 0 := ha
-  let u : kˣ := Units.mk0 a ha0
-  change Polynomial.eval (u : k) _ = Polynomial.eval (u : k) _
-  simp only [Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X,
-    Polynomial.eval_finsetSum]
-  rw [associatedNumerator_line_eval k ι ρ P hP d hd,
-    associatedSections_line_unipotent k ι ρ u t f]
-  simp_rw [clearedLineAction_eval k _ t (u : k) d (hd i _) u.ne_zero,
-    associatedNumerator_line_eval k ι ρ P hP d hd u f]
-  rw [← LinearMap.toMatrix'_mulVec, ← hP]
-  simp only [polynomialMatrixEval, Matrix.mulVec, dotProduct,
-    Polynomial.aeval_def, Algebra.algebraMap_self, Polynomial.eval₂_id, Finset.mul_sum]
-  apply Finset.sum_congr rfl
-  intro j _
-  ring
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.AssociatedNumerator
+import OAI.RepresentationTheory.RestrictedTilting.XChartLineEval
+import OAI.RepresentationTheory.RestrictedTilting.ClearedPolynomial
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+variable (P : Matrix ι ι (Polynomial k))
+variable (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+variable (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d)
+local notation "N" => associatedSectionsSubmodule k ι ρ
+local notation "W" => associatedNumeratorLinear k ι ρ P hP d hd
+
+lemma associatedNumerator_line_eval (a : kˣ) (f : N) (i : ι) :
+    (linePolynomial k (W f i)).eval (a : k) = (a : k)^d *
+      regularVectorEvaluation k ι (diagonalTorus k a) f.val i := by
+  rw [linePolynomial_eval]
+  change planeLineEval k a (W f i) = _
+  have h := congrArg (chartLineEval k a) (associatedNumeratorLinear_spec k ι ρ P hP d hd f i)
+  rw [chartLineEval_algebraMap, map_mul, map_pow, chartLineEval_coordinate] at h
+  simpa only [ite_true, congrFun (associatedXChart_line k ι ρ a f) i] using h
+
+ 
+
+lemma associatedNumerator_line_unipotent (t : k) (f : N) (i : ι) :
+    Polynomial.X^(2*d) * linePolynomial k
+      (W (associatedSectionsRepresentation k ι ρ (unipotent k t) f) i) =
+      ∑ j, clearedLineAction k (P i j) t d * linePolynomial k (W f j) := by
+  apply Polynomial.eq_of_infinite_eval_eq
+  apply (Set.finite_singleton (0 : k)).infinite_compl.mono
+  intro a ha
+  have ha0 : a ≠ 0 := ha
+  let u : kˣ := Units.mk0 a ha0
+  change Polynomial.eval (u : k) _ = Polynomial.eval (u : k) _
+  simp only [Polynomial.eval_mul, Polynomial.eval_pow, Polynomial.eval_X,
+    Polynomial.eval_finsetSum]
+  rw [associatedNumerator_line_eval k ι ρ P hP d hd,
+    associatedSections_line_unipotent k ι ρ u t f]
+  simp_rw [clearedLineAction_eval k _ t (u : k) d (hd i _) u.ne_zero,
+    associatedNumerator_line_eval k ι ρ P hP d hd u f]
+  rw [← LinearMap.toMatrix'_mulVec, ← hP]
+  simp only [polynomialMatrixEval, Matrix.mulVec, dotProduct,
+    Polynomial.aeval_def, Algebra.algebraMap_self, Polynomial.eval₂_id, Finset.mul_sum]
+  apply Finset.sum_congr rfl
+  intro j _
+  ring
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/OriginCoordinates.lean

@@ -1,346 +1,346 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.ActionDenominators
-
-namespace OAI
-
-/-! Plane-origin coordinate rings, stalk lattices and overlap evaluation. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-
-variable (k : Type*) [Field k]
-
-abbrev planeCoordinateRing := MvPolynomial (Fin 2) k
-
-def planeOriginIdeal : Ideal (planeCoordinateRing k) :=
-  RingHom.ker MvPolynomial.constantCoeff
-
-instance planeOriginIdeal_isMaximal : (planeOriginIdeal k).IsMaximal :=
-  RingHom.ker_isMaximal_of_surjective MvPolynomial.constantCoeff
-    (fun a => ⟨MvPolynomial.C a, MvPolynomial.constantCoeff_C (Fin 2) a⟩)
-
-lemma planeOriginIdeal_eq_span : planeOriginIdeal k =
-    Ideal.span {MvPolynomial.X (0 : Fin 2), MvPolynomial.X (1 : Fin 2)} := by
-  have hvars : planeOriginIdeal k = MvPolynomial.idealOfVars (Fin 2) k := by
-    ext f
-    change f.coeff 0 = 0 ↔ f ∈ MvPolynomial.idealOfVars (Fin 2) k
-    have he := MvPolynomial.mem_pow_idealOfVars_iff' (R := k) (σ := Fin 2) 1 f
-    simpa only [pow_one, Nat.lt_one_iff, Finsupp.degree_eq_zero_iff,
-      forall_eq] using he.symm
-  rw [hvars, MvPolynomial.idealOfVars]
-  congr 1
-  ext p
-  constructor
-  · rintro ⟨i,rfl⟩
-    fin_cases i <;> simp
-  · rintro (rfl | rfl)
-    · exact ⟨0,rfl⟩
-    · exact ⟨1,rfl⟩
-
-abbrev planeOriginRing := Localization.AtPrime (planeOriginIdeal k)
-
-abbrev planeOriginCoordinate (i : Fin 2) : planeOriginRing k :=
-  algebraMap (planeCoordinateRing k) (planeOriginRing k) (MvPolynomial.X i)
-
-lemma planeOriginCoordinate_ne_zero (i : Fin 2) : planeOriginCoordinate k i ≠ 0 := by
-  exact fun h => MvPolynomial.X_ne_zero i
-    ((IsLocalization.injective (planeOriginRing k)
-      (planeOriginIdeal k).primeCompl_le_nonZeroDivisors) (h.trans (map_zero _).symm))
-
-lemma planeOrigin_maximalIdeal : IsLocalRing.maximalIdeal (planeOriginRing k) =
-    Ideal.span {planeOriginCoordinate k 0, planeOriginCoordinate k 1} := by
-  rw [← IsLocalization.AtPrime.map_eq_maximalIdeal (planeOriginIdeal k) (planeOriginRing k)]
-  calc
-    _ = Ideal.map (algebraMap (planeCoordinateRing k) (planeOriginRing k))
-        (Ideal.span {MvPolynomial.X (0 : Fin 2), MvPolynomial.X (1 : Fin 2)}) :=
-      congrArg (Ideal.map (algebraMap (planeCoordinateRing k) (planeOriginRing k)))
-        (planeOriginIdeal_eq_span k)
-    _ = _ := by
-      rw [Ideal.map_span]
-      simp only [Set.image_insert_eq, Set.image_singleton, planeOriginCoordinate]
-
-lemma planeOriginCoordinate_prime (i : Fin 2) : Prime (planeOriginCoordinate k i) := by
-  apply (IsLocalization.toLocalizationMap (planeOriginIdeal k).primeCompl
-    (planeOriginRing k)).map_prime (MvPolynomial.X_prime (i := i)) (planeOriginCoordinate_ne_zero k i)
-  change ¬ IsUnit (planeOriginCoordinate k i)
-  rw [IsLocalization.AtPrime.isUnit_to_map_iff (planeOriginRing k) (planeOriginIdeal k)]
-  change ¬ (MvPolynomial.X i : planeCoordinateRing k) ∉ planeOriginIdeal k
-  simp [planeOriginIdeal, RingHom.mem_ker]
-
-lemma planeOriginCoordinates_relPrime :
-    IsRelPrime (planeOriginCoordinate k 0) (planeOriginCoordinate k 1) := by
-  apply (planeOriginCoordinate_prime k 0).irreducible.isRelPrime_iff_not_dvd.mpr
-  intro h
-  obtain ⟨s,hs,hd⟩ :=
-    (IsLocalization.toLocalizationMap (planeOriginIdeal k).primeCompl
-      (planeOriginRing k)).map_dvd_map.mp h
-  rcases (MvPolynomial.X_prime (R := k) (i := (0 : Fin 2))).dvd_or_dvd hd with ha | hb
-  · have hx : (MvPolynomial.X (0 : Fin 2) : planeCoordinateRing k) ∈ planeOriginIdeal k := by
-      simp [planeOriginIdeal, RingHom.mem_ker]
-    obtain ⟨a,rfl⟩ := ha
-    exact hs ((planeOriginIdeal k).mul_mem_right a hx)
-  · exact (by decide : (0 : Fin 2) ≠ 1) (MvPolynomial.X_dvd_X.mp hb)
-
-noncomputable instance planeOriginRing_gcd : GCDMonoid (planeOriginRing k) :=
-  UniqueFactorizationMonoid.toGCDMonoid _
-
-example : IsNoetherianRing (planeOriginRing k) := inferInstance
-example : IsLocalRing (planeOriginRing k) := inferInstance
-
-end
-
-section PowerCharts
-variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
-
-lemma linearEquiv_map_base_smul (P : (ι → K) ≃ₗ[K] (ι → K)) (a : R) (v : ι → K) :
-    P (a • v) = a • P v :=
-  (P.restrictScalars R).map_smul a v
-
-lemma powerLocalization_idem (x : R) (L : Submodule R (ι → K)) :
-    powerLocalization x (powerLocalization x L) = powerLocalization x L := by
-  apply le_antisymm
-  · rintro v ⟨n,m,h⟩
-    exact ⟨m+n, by simpa only [pow_add, mul_smul] using h⟩
-  · exact le_powerLocalization _ _
-
-lemma powerLocalization_equiv_map (x : R) (L : Submodule R (ι → K))
-    (P : (ι → K) ≃ₗ[K] (ι → K)) :
-    powerLocalization x (L.map (P.toLinearMap.restrictScalars R)) =
-      (powerLocalization x L).map (P.toLinearMap.restrictScalars R) := by
-  apply le_antisymm
-  · rintro v ⟨n,w,hw,he⟩
-    refine ⟨P.symm v, ⟨n, ?_⟩, P.apply_symm_apply v⟩
-    have h : w = x^n • P.symm v := by
-      apply P.injective
-      change P w = x^n • v at he
-      simpa only [linearEquiv_map_base_smul, P.apply_symm_apply] using he
-    exact h ▸ hw
-  · rintro v ⟨w,⟨n,hn⟩,rfl⟩
-    refine ⟨n,x^n • w,hn,?_⟩
-    exact (P.restrictScalars R).map_smul _ _
-
-end PowerCharts
-
-section
-variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
-
- 
-theorem gluedLattice_xChart (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
-    (d : ℕ) (hP : ∀ v ∈ coordinateLattice (R := R),
-      (x*y)^d • P.symm v ∈ coordinateLattice (R := R)) :
-    powerLocalization x (gluedLattice x y P) = powerLocalization x coordinateLattice := by
-  apply le_antisymm
-  · exact (powerLocalization_mono x inf_le_left).trans (le_of_eq (powerLocalization_idem x _))
-  · rintro v hv
-    obtain ⟨n,hn⟩ := hv
-    refine ⟨d+n, ?_⟩
-    change x^(d+n) • v ∈ powerLocalization x coordinateLattice ∧
-      x^(d+n) • v ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
-    constructor
-    · exact ⟨0, by simpa only [pow_zero, one_smul, pow_add, mul_smul] using
-        (coordinateLattice (R := R)).smul_mem (x^d) hn⟩
-    · refine ⟨x^(d+n) • P.symm v, ⟨d, ?_⟩, ?_⟩
-      · have h := hP (x^n • v) hn
-        rw [linearEquiv_map_base_smul, mul_pow, mul_smul,
-          smul_comm (y^d), ← mul_smul, ← pow_add] at h
-        simpa only [smul_comm (y^d)] using h
-      · change P (x^(d+n) • P.symm v) = x^(d+n) • v
-        rw [linearEquiv_map_base_smul, P.apply_symm_apply]
-
- 
-theorem gluedLattice_yChart (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
-    (d : ℕ) (hP : ∀ v ∈ coordinateLattice (R := R),
-      (x*y)^d • P v ∈ coordinateLattice (R := R)) :
-    powerLocalization y (gluedLattice x y P) =
-      (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
-  apply le_antisymm
-  · refine (powerLocalization_mono y inf_le_right).trans ?_
-    rw [powerLocalization_equiv_map, powerLocalization_idem]
-  · rintro v ⟨w,⟨n,hn⟩,rfl⟩
-    refine ⟨d+n, ?_⟩
-    change y^(d+n) • P w ∈ powerLocalization x coordinateLattice ∧
-      y^(d+n) • P w ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
-    constructor
-    · refine ⟨d, ?_⟩
-      have h := hP (y^n • w) hn
-      rw [linearEquiv_map_base_smul, mul_pow, mul_smul,
-        ← mul_smul (y^d), ← pow_add] at h
-      exact h
-    · refine ⟨y^(d+n) • w, ⟨0, ?_⟩, ?_⟩
-      · simpa only [pow_zero, one_smul, pow_add, mul_smul] using
-          (coordinateLattice (R := R)).smul_mem (y^d) hn
-      · exact (P.restrictScalars R).map_smul _ _
-
-end
-
-section
-
-variable {k ι : Type*} [Field k] [Infinite k] [Fintype ι] [DecidableEq ι]
-variable (P : Matrix ι ι (Polynomial k))
-    (h0 : polynomialMatrixEval P (0 : k) = 1)
-    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
-      polynomialMatrixEval P s * polynomialMatrixEval P t)
-
-abbrev planeOriginFractionField := FractionRing (planeCoordinateRing k)
-
-instance planeOriginFraction_tower :
-    IsScalarTower k (planeOriginRing k) (planeOriginFractionField (k := k)) :=
-  IsScalarTower.to₁₃₄ k (planeCoordinateRing k) (planeOriginRing k)
-    (planeOriginFractionField (k := k))
-
-instance planeOriginFraction_isFractionRing :
-    IsFractionRing (planeOriginRing k) (planeOriginFractionField (k := k)) :=
-  IsFractionRing.isFractionRing_of_isLocalization (planeOriginIdeal k).primeCompl
-    (planeOriginRing k) (planeOriginFractionField (k := k))
-    (planeOriginIdeal k).primeCompl_le_nonZeroDivisors
-
-noncomputable def planeStalkTransition :
-    (ι → planeOriginFractionField (k := k)) ≃ₗ[planeOriginFractionField (k := k)]
-      (ι → planeOriginFractionField (k := k)) :=
-  polynomialActionEquiv P h0 hadd
-    (-(algebraMap (planeOriginRing k) (planeOriginFractionField (k := k))
-      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1))⁻¹)
-
- 
-
-noncomputable def planeAssociatedLattice :
-    Submodule (planeOriginRing k) (ι → planeOriginFractionField (k := k)) :=
-  gluedLattice (planeOriginCoordinate k 0) (planeOriginCoordinate k 1)
-    (planeStalkTransition P h0 hadd)
-
-omit [Infinite k] in
-lemma planeOrigin_product_ne_zero :
-    algebraMap (planeOriginRing k) (planeOriginFractionField (k := k))
-      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1) ≠ 0 := by
-  have h := FaithfulSMul.algebraMap_injective (planeOriginRing k)
-    (planeOriginFractionField (k := k))
-  exact fun hz => (mul_ne_zero (planeOriginCoordinate_ne_zero k 0)
-    (planeOriginCoordinate_ne_zero k 1)) (h (hz.trans (map_zero _).symm))
-
-lemma planeStalkTransition_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    ∀ v ∈ coordinateLattice (R := planeOriginRing k),
-      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1)^d •
-        planeStalkTransition P h0 hadd v ∈ coordinateLattice (R := planeOriginRing k) :=
-  polynomialAction_denominator P h0 hadd _ planeOrigin_product_ne_zero d hd
-
-lemma planeStalkTransition_symm_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    ∀ v ∈ coordinateLattice (R := planeOriginRing k),
-      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1)^d •
-        (planeStalkTransition P h0 hadd).symm v ∈ coordinateLattice (R := planeOriginRing k) := by
-  have h := polynomialAction_fraction_denominator (R := planeOriginRing k)
-    (K := planeOriginFractionField (k := k)) P h0 hadd 1 _ planeOrigin_product_ne_zero d hd
-  simpa only [planeStalkTransition, polynomialActionEquiv_symm, neg_neg,
-    map_one, one_mul] using h
-
- 
-
-theorem planeAssociatedLattice_finite_free (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    Module.Finite (planeOriginRing k) (planeAssociatedLattice P h0 hadd) ∧
-      Module.Free (planeOriginRing k) (planeAssociatedLattice P h0 hadd) := by
-  constructor
-  · exact gluedLattice_finite _ _ (planeOriginCoordinate_ne_zero k 0)
-      (planeOriginCoordinates_relPrime k) _ d (planeStalkTransition_denominator P h0 hadd d hd)
-  · exact gluedLattice_free _ _ (planeOriginCoordinate_ne_zero k 0)
-      (planeOriginCoordinate_ne_zero k 1) (planeOriginCoordinates_relPrime k)
-      (planeOrigin_maximalIdeal k) _ d (planeStalkTransition_denominator P h0 hadd d hd)
-
-theorem planeAssociatedLattice_xChart (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    powerLocalization (planeOriginCoordinate k 0) (planeAssociatedLattice P h0 hadd) =
-      powerLocalization (planeOriginCoordinate k 0) coordinateLattice :=
-  gluedLattice_xChart _ _ _ d (planeStalkTransition_symm_denominator P h0 hadd d hd)
-
-theorem planeAssociatedLattice_yChart (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
-    powerLocalization (planeOriginCoordinate k 1) (planeAssociatedLattice P h0 hadd) =
-      (powerLocalization (planeOriginCoordinate k 1) coordinateLattice).map
-        ((planeStalkTransition P h0 hadd).toLinearMap.restrictScalars (planeOriginRing k)) :=
-  gluedLattice_yChart _ _ _ d (planeStalkTransition_denominator P h0 hadd d hd)
-
-end
-
-variable (k : Type*) [Field k] [Infinite k]
-
-abbrev planeOverlapRing := Localization.Away
-  ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)
-
-omit [Infinite k] in
-lemma planeTorusEvaluation_product_isUnit :
-    IsUnit (planeTorusEvaluation k
-      ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)) := by
-  rw [map_mul]
-  exact (planeTorusEvaluation_X_isUnit k 0).mul (planeTorusEvaluation_X_isUnit k 1)
-
-noncomputable def planeOverlapEvaluation :
-    planeOverlapRing k →ₐ[k] (planeTorusPoints k → k) :=
-  IsLocalization.Away.liftAlgHom _ (planeTorusEvaluation_product_isUnit k)
-
-omit [Infinite k] in
-lemma planeOverlapEvaluation_algebraMap (P : MvPolynomial (Fin 2) k) :
-    planeOverlapEvaluation k (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P) =
-      planeTorusEvaluation k P :=
-  IsLocalization.Away.lift_eq _ (planeTorusEvaluation_product_isUnit k) _
-
-theorem planeOverlapEvaluation_injective :
-    Function.Injective (planeOverlapEvaluation k) := by
-  apply (IsLocalization.injective_iff_map_algebraMap_eq
-    (R := MvPolynomial (Fin 2) k) (S := planeOverlapRing k)
-    (Submonoid.powers (MvPolynomial.X 0 * MvPolynomial.X 1))
-    (planeOverlapEvaluation k).toRingHom).mpr
-  intro P Q
-  constructor
-  · exact congrArg (planeOverlapEvaluation k)
-  · intro h
-    have h' : planeTorusEvaluation k P = planeTorusEvaluation k Q := by
-      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
-        planeOverlapEvaluation_algebraMap] using h
-    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k))
-      (planeTorusEvaluation_injective k h')
-
-omit [Infinite k] in
-lemma planeOverlapCoordinate_isUnit (i : Fin 2) :
-    IsUnit (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) (MvPolynomial.X i)) := by
-  apply IsLocalization.Away.isUnit_of_dvd
-    (x := (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)
-  fin_cases i
-  · exact dvd_mul_right _ _
-  · exact dvd_mul_left _ _
-
-noncomputable def planeChartToOverlap (i : Fin 2) :
-    planeCoordinateChart k i →ₐ[k] planeOverlapRing k :=
-  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeOverlapRing k))
-    (planeOverlapCoordinate_isUnit k i)
-
-omit [Infinite k] in
-lemma planeChartToOverlap_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
-    planeChartToOverlap k i
-      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
-      algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P :=
-  IsLocalization.Away.lift_eq _ (planeOverlapCoordinate_isUnit k i) _
-
-omit [Infinite k] in
-lemma planeChartToOverlap_evaluation (i : Fin 2) (f : planeCoordinateChart k i) :
-    planeOverlapEvaluation k (planeChartToOverlap k i f) = planeChartEvaluation k i f := by
-  have h : (planeOverlapEvaluation k).toRingHom.comp (planeChartToOverlap k i).toRingHom =
-      (planeChartEvaluation k i).toRingHom := by
-    apply IsLocalization.ringHom_ext
-      (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
-    apply RingHom.ext
-    intro P
-    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
-      planeChartToOverlap_algebraMap, planeOverlapEvaluation_algebraMap,
-      planeChartEvaluation_algebraMap]
-  exact RingHom.congr_fun h f
-
-lemma planeChartToOverlap_injective (i : Fin 2) : Function.Injective (planeChartToOverlap k i) := by
-  intro f h he
-  apply planeChartEvaluation_injective k i
-  rw [← planeChartToOverlap_evaluation, ← planeChartToOverlap_evaluation, he]
-
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.ActionDenominators
+
+namespace OAI
+
+/-! Plane-origin coordinate rings, stalk lattices and overlap evaluation. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+
+variable (k : Type*) [Field k]
+
+abbrev planeCoordinateRing := MvPolynomial (Fin 2) k
+
+def planeOriginIdeal : Ideal (planeCoordinateRing k) :=
+  RingHom.ker MvPolynomial.constantCoeff
+
+instance planeOriginIdeal_isMaximal : (planeOriginIdeal k).IsMaximal :=
+  RingHom.ker_isMaximal_of_surjective MvPolynomial.constantCoeff
+    (fun a => ⟨MvPolynomial.C a, MvPolynomial.constantCoeff_C (Fin 2) a⟩)
+
+lemma planeOriginIdeal_eq_span : planeOriginIdeal k =
+    Ideal.span {MvPolynomial.X (0 : Fin 2), MvPolynomial.X (1 : Fin 2)} := by
+  have hvars : planeOriginIdeal k = MvPolynomial.idealOfVars (Fin 2) k := by
+    ext f
+    change f.coeff 0 = 0 ↔ f ∈ MvPolynomial.idealOfVars (Fin 2) k
+    have he := MvPolynomial.mem_pow_idealOfVars_iff' (R := k) (σ := Fin 2) 1 f
+    simpa only [pow_one, Nat.lt_one_iff, Finsupp.degree_eq_zero_iff,
+      forall_eq] using he.symm
+  rw [hvars, MvPolynomial.idealOfVars]
+  congr 1
+  ext p
+  constructor
+  · rintro ⟨i,rfl⟩
+    fin_cases i <;> simp
+  · rintro (rfl | rfl)
+    · exact ⟨0,rfl⟩
+    · exact ⟨1,rfl⟩
+
+abbrev planeOriginRing := Localization.AtPrime (planeOriginIdeal k)
+
+abbrev planeOriginCoordinate (i : Fin 2) : planeOriginRing k :=
+  algebraMap (planeCoordinateRing k) (planeOriginRing k) (MvPolynomial.X i)
+
+lemma planeOriginCoordinate_ne_zero (i : Fin 2) : planeOriginCoordinate k i ≠ 0 := by
+  exact fun h => MvPolynomial.X_ne_zero i
+    ((IsLocalization.injective (planeOriginRing k)
+      (planeOriginIdeal k).primeCompl_le_nonZeroDivisors) (h.trans (map_zero _).symm))
+
+lemma planeOrigin_maximalIdeal : IsLocalRing.maximalIdeal (planeOriginRing k) =
+    Ideal.span {planeOriginCoordinate k 0, planeOriginCoordinate k 1} := by
+  rw [← IsLocalization.AtPrime.map_eq_maximalIdeal (planeOriginIdeal k) (planeOriginRing k)]
+  calc
+    _ = Ideal.map (algebraMap (planeCoordinateRing k) (planeOriginRing k))
+        (Ideal.span {MvPolynomial.X (0 : Fin 2), MvPolynomial.X (1 : Fin 2)}) :=
+      congrArg (Ideal.map (algebraMap (planeCoordinateRing k) (planeOriginRing k)))
+        (planeOriginIdeal_eq_span k)
+    _ = _ := by
+      rw [Ideal.map_span]
+      simp only [Set.image_insert_eq, Set.image_singleton, planeOriginCoordinate]
+
+lemma planeOriginCoordinate_prime (i : Fin 2) : Prime (planeOriginCoordinate k i) := by
+  apply (IsLocalization.toLocalizationMap (planeOriginIdeal k).primeCompl
+    (planeOriginRing k)).map_prime (MvPolynomial.X_prime (i := i)) (planeOriginCoordinate_ne_zero k i)
+  change ¬ IsUnit (planeOriginCoordinate k i)
+  rw [IsLocalization.AtPrime.isUnit_to_map_iff (planeOriginRing k) (planeOriginIdeal k)]
+  change ¬ (MvPolynomial.X i : planeCoordinateRing k) ∉ planeOriginIdeal k
+  simp [planeOriginIdeal, RingHom.mem_ker]
+
+lemma planeOriginCoordinates_relPrime :
+    IsRelPrime (planeOriginCoordinate k 0) (planeOriginCoordinate k 1) := by
+  apply (planeOriginCoordinate_prime k 0).irreducible.isRelPrime_iff_not_dvd.mpr
+  intro h
+  obtain ⟨s,hs,hd⟩ :=
+    (IsLocalization.toLocalizationMap (planeOriginIdeal k).primeCompl
+      (planeOriginRing k)).map_dvd_map.mp h
+  rcases (MvPolynomial.X_prime (R := k) (i := (0 : Fin 2))).dvd_or_dvd hd with ha | hb
+  · have hx : (MvPolynomial.X (0 : Fin 2) : planeCoordinateRing k) ∈ planeOriginIdeal k := by
+      simp [planeOriginIdeal, RingHom.mem_ker]
+    obtain ⟨a,rfl⟩ := ha
+    exact hs ((planeOriginIdeal k).mul_mem_right a hx)
+  · exact (by decide : (0 : Fin 2) ≠ 1) (MvPolynomial.X_dvd_X.mp hb)
+
+noncomputable instance planeOriginRing_gcd : GCDMonoid (planeOriginRing k) :=
+  UniqueFactorizationMonoid.toGCDMonoid _
+
+example : IsNoetherianRing (planeOriginRing k) := inferInstance
+example : IsLocalRing (planeOriginRing k) := inferInstance
+
+end
+
+section PowerCharts
+variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
+
+lemma linearEquiv_map_base_smul (P : (ι → K) ≃ₗ[K] (ι → K)) (a : R) (v : ι → K) :
+    P (a • v) = a • P v :=
+  (P.restrictScalars R).map_smul a v
+
+lemma powerLocalization_idem (x : R) (L : Submodule R (ι → K)) :
+    powerLocalization x (powerLocalization x L) = powerLocalization x L := by
+  apply le_antisymm
+  · rintro v ⟨n,m,h⟩
+    exact ⟨m+n, by simpa only [pow_add, mul_smul] using h⟩
+  · exact le_powerLocalization _ _
+
+lemma powerLocalization_equiv_map (x : R) (L : Submodule R (ι → K))
+    (P : (ι → K) ≃ₗ[K] (ι → K)) :
+    powerLocalization x (L.map (P.toLinearMap.restrictScalars R)) =
+      (powerLocalization x L).map (P.toLinearMap.restrictScalars R) := by
+  apply le_antisymm
+  · rintro v ⟨n,w,hw,he⟩
+    refine ⟨P.symm v, ⟨n, ?_⟩, P.apply_symm_apply v⟩
+    have h : w = x^n • P.symm v := by
+      apply P.injective
+      change P w = x^n • v at he
+      simpa only [linearEquiv_map_base_smul, P.apply_symm_apply] using he
+    exact h ▸ hw
+  · rintro v ⟨w,⟨n,hn⟩,rfl⟩
+    refine ⟨n,x^n • w,hn,?_⟩
+    exact (P.restrictScalars R).map_smul _ _
+
+end PowerCharts
+
+section
+variable {R K ι : Type*} [CommRing R] [Field K] [Algebra R K]
+
+ 
+theorem gluedLattice_xChart (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
+    (d : ℕ) (hP : ∀ v ∈ coordinateLattice (R := R),
+      (x*y)^d • P.symm v ∈ coordinateLattice (R := R)) :
+    powerLocalization x (gluedLattice x y P) = powerLocalization x coordinateLattice := by
+  apply le_antisymm
+  · exact (powerLocalization_mono x inf_le_left).trans (le_of_eq (powerLocalization_idem x _))
+  · rintro v hv
+    obtain ⟨n,hn⟩ := hv
+    refine ⟨d+n, ?_⟩
+    change x^(d+n) • v ∈ powerLocalization x coordinateLattice ∧
+      x^(d+n) • v ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
+    constructor
+    · exact ⟨0, by simpa only [pow_zero, one_smul, pow_add, mul_smul] using
+        (coordinateLattice (R := R)).smul_mem (x^d) hn⟩
+    · refine ⟨x^(d+n) • P.symm v, ⟨d, ?_⟩, ?_⟩
+      · have h := hP (x^n • v) hn
+        rw [linearEquiv_map_base_smul, mul_pow, mul_smul,
+          smul_comm (y^d), ← mul_smul, ← pow_add] at h
+        simpa only [smul_comm (y^d)] using h
+      · change P (x^(d+n) • P.symm v) = x^(d+n) • v
+        rw [linearEquiv_map_base_smul, P.apply_symm_apply]
+
+ 
+theorem gluedLattice_yChart (x y : R) (P : (ι → K) ≃ₗ[K] (ι → K))
+    (d : ℕ) (hP : ∀ v ∈ coordinateLattice (R := R),
+      (x*y)^d • P v ∈ coordinateLattice (R := R)) :
+    powerLocalization y (gluedLattice x y P) =
+      (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R) := by
+  apply le_antisymm
+  · refine (powerLocalization_mono y inf_le_right).trans ?_
+    rw [powerLocalization_equiv_map, powerLocalization_idem]
+  · rintro v ⟨w,⟨n,hn⟩,rfl⟩
+    refine ⟨d+n, ?_⟩
+    change y^(d+n) • P w ∈ powerLocalization x coordinateLattice ∧
+      y^(d+n) • P w ∈ (powerLocalization y coordinateLattice).map (P.toLinearMap.restrictScalars R)
+    constructor
+    · refine ⟨d, ?_⟩
+      have h := hP (y^n • w) hn
+      rw [linearEquiv_map_base_smul, mul_pow, mul_smul,
+        ← mul_smul (y^d), ← pow_add] at h
+      exact h
+    · refine ⟨y^(d+n) • w, ⟨0, ?_⟩, ?_⟩
+      · simpa only [pow_zero, one_smul, pow_add, mul_smul] using
+          (coordinateLattice (R := R)).smul_mem (y^d) hn
+      · exact (P.restrictScalars R).map_smul _ _
+
+end
+
+section
+
+variable {k ι : Type*} [Field k] [Infinite k] [Fintype ι] [DecidableEq ι]
+variable (P : Matrix ι ι (Polynomial k))
+    (h0 : polynomialMatrixEval P (0 : k) = 1)
+    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
+      polynomialMatrixEval P s * polynomialMatrixEval P t)
+
+abbrev planeOriginFractionField := FractionRing (planeCoordinateRing k)
+
+instance planeOriginFraction_tower :
+    IsScalarTower k (planeOriginRing k) (planeOriginFractionField (k := k)) :=
+  IsScalarTower.to₁₃₄ k (planeCoordinateRing k) (planeOriginRing k)
+    (planeOriginFractionField (k := k))
+
+instance planeOriginFraction_isFractionRing :
+    IsFractionRing (planeOriginRing k) (planeOriginFractionField (k := k)) :=
+  IsFractionRing.isFractionRing_of_isLocalization (planeOriginIdeal k).primeCompl
+    (planeOriginRing k) (planeOriginFractionField (k := k))
+    (planeOriginIdeal k).primeCompl_le_nonZeroDivisors
+
+noncomputable def planeStalkTransition :
+    (ι → planeOriginFractionField (k := k)) ≃ₗ[planeOriginFractionField (k := k)]
+      (ι → planeOriginFractionField (k := k)) :=
+  polynomialActionEquiv P h0 hadd
+    (-(algebraMap (planeOriginRing k) (planeOriginFractionField (k := k))
+      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1))⁻¹)
+
+ 
+
+noncomputable def planeAssociatedLattice :
+    Submodule (planeOriginRing k) (ι → planeOriginFractionField (k := k)) :=
+  gluedLattice (planeOriginCoordinate k 0) (planeOriginCoordinate k 1)
+    (planeStalkTransition P h0 hadd)
+
+omit [Infinite k] in
+lemma planeOrigin_product_ne_zero :
+    algebraMap (planeOriginRing k) (planeOriginFractionField (k := k))
+      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1) ≠ 0 := by
+  have h := FaithfulSMul.algebraMap_injective (planeOriginRing k)
+    (planeOriginFractionField (k := k))
+  exact fun hz => (mul_ne_zero (planeOriginCoordinate_ne_zero k 0)
+    (planeOriginCoordinate_ne_zero k 1)) (h (hz.trans (map_zero _).symm))
+
+lemma planeStalkTransition_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    ∀ v ∈ coordinateLattice (R := planeOriginRing k),
+      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1)^d •
+        planeStalkTransition P h0 hadd v ∈ coordinateLattice (R := planeOriginRing k) :=
+  polynomialAction_denominator P h0 hadd _ planeOrigin_product_ne_zero d hd
+
+lemma planeStalkTransition_symm_denominator (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    ∀ v ∈ coordinateLattice (R := planeOriginRing k),
+      (planeOriginCoordinate k 0 * planeOriginCoordinate k 1)^d •
+        (planeStalkTransition P h0 hadd).symm v ∈ coordinateLattice (R := planeOriginRing k) := by
+  have h := polynomialAction_fraction_denominator (R := planeOriginRing k)
+    (K := planeOriginFractionField (k := k)) P h0 hadd 1 _ planeOrigin_product_ne_zero d hd
+  simpa only [planeStalkTransition, polynomialActionEquiv_symm, neg_neg,
+    map_one, one_mul] using h
+
+ 
+
+theorem planeAssociatedLattice_finite_free (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    Module.Finite (planeOriginRing k) (planeAssociatedLattice P h0 hadd) ∧
+      Module.Free (planeOriginRing k) (planeAssociatedLattice P h0 hadd) := by
+  constructor
+  · exact gluedLattice_finite _ _ (planeOriginCoordinate_ne_zero k 0)
+      (planeOriginCoordinates_relPrime k) _ d (planeStalkTransition_denominator P h0 hadd d hd)
+  · exact gluedLattice_free _ _ (planeOriginCoordinate_ne_zero k 0)
+      (planeOriginCoordinate_ne_zero k 1) (planeOriginCoordinates_relPrime k)
+      (planeOrigin_maximalIdeal k) _ d (planeStalkTransition_denominator P h0 hadd d hd)
+
+theorem planeAssociatedLattice_xChart (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    powerLocalization (planeOriginCoordinate k 0) (planeAssociatedLattice P h0 hadd) =
+      powerLocalization (planeOriginCoordinate k 0) coordinateLattice :=
+  gluedLattice_xChart _ _ _ d (planeStalkTransition_symm_denominator P h0 hadd d hd)
+
+theorem planeAssociatedLattice_yChart (d : ℕ) (hd : ∀ i j, (P i j).natDegree ≤ d) :
+    powerLocalization (planeOriginCoordinate k 1) (planeAssociatedLattice P h0 hadd) =
+      (powerLocalization (planeOriginCoordinate k 1) coordinateLattice).map
+        ((planeStalkTransition P h0 hadd).toLinearMap.restrictScalars (planeOriginRing k)) :=
+  gluedLattice_yChart _ _ _ d (planeStalkTransition_denominator P h0 hadd d hd)
+
+end
+
+variable (k : Type*) [Field k] [Infinite k]
+
+abbrev planeOverlapRing := Localization.Away
+  ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)
+
+omit [Infinite k] in
+lemma planeTorusEvaluation_product_isUnit :
+    IsUnit (planeTorusEvaluation k
+      ((MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)) := by
+  rw [map_mul]
+  exact (planeTorusEvaluation_X_isUnit k 0).mul (planeTorusEvaluation_X_isUnit k 1)
+
+noncomputable def planeOverlapEvaluation :
+    planeOverlapRing k →ₐ[k] (planeTorusPoints k → k) :=
+  IsLocalization.Away.liftAlgHom _ (planeTorusEvaluation_product_isUnit k)
+
+omit [Infinite k] in
+lemma planeOverlapEvaluation_algebraMap (P : MvPolynomial (Fin 2) k) :
+    planeOverlapEvaluation k (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P) =
+      planeTorusEvaluation k P :=
+  IsLocalization.Away.lift_eq _ (planeTorusEvaluation_product_isUnit k) _
+
+theorem planeOverlapEvaluation_injective :
+    Function.Injective (planeOverlapEvaluation k) := by
+  apply (IsLocalization.injective_iff_map_algebraMap_eq
+    (R := MvPolynomial (Fin 2) k) (S := planeOverlapRing k)
+    (Submonoid.powers (MvPolynomial.X 0 * MvPolynomial.X 1))
+    (planeOverlapEvaluation k).toRingHom).mpr
+  intro P Q
+  constructor
+  · exact congrArg (planeOverlapEvaluation k)
+  · intro h
+    have h' : planeTorusEvaluation k P = planeTorusEvaluation k Q := by
+      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+        planeOverlapEvaluation_algebraMap] using h
+    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k))
+      (planeTorusEvaluation_injective k h')
+
+omit [Infinite k] in
+lemma planeOverlapCoordinate_isUnit (i : Fin 2) :
+    IsUnit (algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) (MvPolynomial.X i)) := by
+  apply IsLocalization.Away.isUnit_of_dvd
+    (x := (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) * MvPolynomial.X 1)
+  fin_cases i
+  · exact dvd_mul_right _ _
+  · exact dvd_mul_left _ _
+
+noncomputable def planeChartToOverlap (i : Fin 2) :
+    planeCoordinateChart k i →ₐ[k] planeOverlapRing k :=
+  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+    (f := IsScalarTower.toAlgHom k (MvPolynomial (Fin 2) k) (planeOverlapRing k))
+    (planeOverlapCoordinate_isUnit k i)
+
+omit [Infinite k] in
+lemma planeChartToOverlap_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
+    planeChartToOverlap k i
+      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
+      algebraMap (MvPolynomial (Fin 2) k) (planeOverlapRing k) P :=
+  IsLocalization.Away.lift_eq _ (planeOverlapCoordinate_isUnit k i) _
+
+omit [Infinite k] in
+lemma planeChartToOverlap_evaluation (i : Fin 2) (f : planeCoordinateChart k i) :
+    planeOverlapEvaluation k (planeChartToOverlap k i f) = planeChartEvaluation k i f := by
+  have h : (planeOverlapEvaluation k).toRingHom.comp (planeChartToOverlap k i).toRingHom =
+      (planeChartEvaluation k i).toRingHom := by
+    apply IsLocalization.ringHom_ext
+      (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
+    apply RingHom.ext
+    intro P
+    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+      planeChartToOverlap_algebraMap, planeOverlapEvaluation_algebraMap,
+      planeChartEvaluation_algebraMap]
+  exact RingHom.congr_fun h f
+
+lemma planeChartToOverlap_injective (i : Fin 2) : Function.Injective (planeChartToOverlap k i) := by
+  intro f h he
+  apply planeChartEvaluation_injective k i
+  rw [← planeChartToOverlap_evaluation, ← planeChartToOverlap_evaluation, he]
+
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PGroupInvariants.lean

@@ -1,58 +1,58 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open Representation
-universe u v
-variable {k : Type u} [Field k] {p : ℕ} [Fact p.Prime] [CharP k p]
-variable {G : Type v} [Group G] [Finite G]
-variable {V : Type u} [AddCommGroup V] [Module k V]
-
- 
-
-theorem pgroup_exists_invariant (hG : IsPGroup p G) (ρ : Representation k G V)
-    (v : V) (hv : v ≠ 0) : ∃ w : V, w ≠ 0 ∧ ∀ g, ρ g w = w := by
-  classical
-  let : Algebra (ZMod p) k := ZMod.algebra k p
-  let : Module (ZMod p) V := Module.compHom V (algebraMap (ZMod p) k)
-  let : IsScalarTower (ZMod p) k V := IsScalarTower.of_algebraMap_smul fun _ _ => rfl
-  let W : Submodule (ZMod p) V := Submodule.span (ZMod p) (Set.range fun g : G => ρ g v)
-  have hvW : v ∈ W := by
-    apply Submodule.subset_span
-    exact ⟨1, by simp⟩
-  have hstable (g : G) : W ≤ W.comap ((ρ g).restrictScalars (ZMod p)) := by
-    apply Submodule.span_le.mpr
-    rintro _ ⟨h,rfl⟩
-    change ρ g (ρ h v) ∈ W
-    change (ρ g * ρ h) v ∈ W
-    rw [← map_mul]
-    exact Submodule.subset_span ⟨g*h,rfl⟩
-  let σ : Representation (ZMod p) G W :=
-    { toFun := fun g => ((ρ g).restrictScalars (ZMod p)).restrict (hstable g)
-      map_one' := by ext w; simp
-      map_mul' := by intro g h; ext w; simp [map_mul] }
-  let : Module.Finite (ZMod p) W :=
-    Module.Finite.of_fg (Submodule.fg_span (Set.finite_range _))
-  let : Finite W := Module.finite_of_finite (ZMod p)
-  have hnt : Nontrivial W := ⟨⟨⟨v,hvW⟩,0,fun h => hv (congrArg Subtype.val h)⟩⟩
-  let := hnt
-  let : MulAction G W := {
-    smul g w := σ g w
-    one_smul := by intro w; change σ 1 w = w; simp
-    mul_smul := by intro g h w; change σ (g*h) w = σ g (σ h w); simp [map_mul] }
-  have hpW : p ∣ Nat.card W := by
-    let := Fintype.ofFinite W
-    rw [Nat.card_eq_fintype_card, Module.card_eq_pow_finrank (K := ZMod p), ZMod.card]
-    exact dvd_pow_self p (ne_of_gt (Module.finrank_pos (R := ZMod p) (M := W)))
-  obtain ⟨w,hw,hne⟩ := hG.exists_fixed_point_of_prime_dvd_card_of_fixed_point W hpW
-    (a := 0) (by intro g; change σ g 0 = 0; simp)
-  refine ⟨w,?_,?_⟩
-  · intro h
-    apply hne
-    exact Subtype.ext h.symm
-  · intro g
-    exact congrArg Subtype.val (hw g)
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open Representation
+universe u v
+variable {k : Type u} [Field k] {p : ℕ} [Fact p.Prime] [CharP k p]
+variable {G : Type v} [Group G] [Finite G]
+variable {V : Type u} [AddCommGroup V] [Module k V]
+
+ 
+
+theorem pgroup_exists_invariant (hG : IsPGroup p G) (ρ : Representation k G V)
+    (v : V) (hv : v ≠ 0) : ∃ w : V, w ≠ 0 ∧ ∀ g, ρ g w = w := by
+  classical
+  let : Algebra (ZMod p) k := ZMod.algebra k p
+  let : Module (ZMod p) V := Module.compHom V (algebraMap (ZMod p) k)
+  let : IsScalarTower (ZMod p) k V := IsScalarTower.of_algebraMap_smul fun _ _ => rfl
+  let W : Submodule (ZMod p) V := Submodule.span (ZMod p) (Set.range fun g : G => ρ g v)
+  have hvW : v ∈ W := by
+    apply Submodule.subset_span
+    exact ⟨1, by simp⟩
+  have hstable (g : G) : W ≤ W.comap ((ρ g).restrictScalars (ZMod p)) := by
+    apply Submodule.span_le.mpr
+    rintro _ ⟨h,rfl⟩
+    change ρ g (ρ h v) ∈ W
+    change (ρ g * ρ h) v ∈ W
+    rw [← map_mul]
+    exact Submodule.subset_span ⟨g*h,rfl⟩
+  let σ : Representation (ZMod p) G W :=
+    { toFun := fun g => ((ρ g).restrictScalars (ZMod p)).restrict (hstable g)
+      map_one' := by ext w; simp
+      map_mul' := by intro g h; ext w; simp [map_mul] }
+  let : Module.Finite (ZMod p) W :=
+    Module.Finite.of_fg (Submodule.fg_span (Set.finite_range _))
+  let : Finite W := Module.finite_of_finite (ZMod p)
+  have hnt : Nontrivial W := ⟨⟨⟨v,hvW⟩,0,fun h => hv (congrArg Subtype.val h)⟩⟩
+  let := hnt
+  let : MulAction G W := {
+    smul g w := σ g w
+    one_smul := by intro w; change σ 1 w = w; simp
+    mul_smul := by intro g h w; change σ (g*h) w = σ g (σ h w); simp [map_mul] }
+  have hpW : p ∣ Nat.card W := by
+    let := Fintype.ofFinite W
+    rw [Nat.card_eq_fintype_card, Module.card_eq_pow_finrank (K := ZMod p), ZMod.card]
+    exact dvd_pow_self p (ne_of_gt (Module.finrank_pos (R := ZMod p) (M := W)))
+  obtain ⟨w,hw,hne⟩ := hG.exists_fixed_point_of_prime_dvd_card_of_fixed_point W hpW
+    (a := 0) (by intro g; change σ g 0 = 0; simp)
+  refine ⟨w,?_,?_⟩
+  · intro h
+    apply hne
+    exact Subtype.ext h.symm
+  · intro g
+    exact congrArg Subtype.val (hw g)
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PiPlaneOrigin.lean

@@ -1,82 +1,82 @@
-import OAI.RepresentationTheory.RestrictedTilting.PlaneMatrixTensor
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory
-open scoped BigOperators TensorProduct
-universe u
-variable (k : Type u) [Field k]
-variable {β : Type u} [Fintype β] [DecidableEq β]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
-local notation "A" => MvPolynomial (Fin 2) k
-local notation "pM" => planeJetRelation (M := M) k 1
-local notation "pPi" => planeJetRelation (M := β → M) k 1
-
-noncomputable def piPlaneOriginMap : (β → M) →ₗ[k] (β → M ⧸ pM) :=
-  LinearMap.pi fun i => (pM).mkQ.comp (LinearMap.proj i)
-
-omit [Fintype β] [DecidableEq β] in
-lemma piPlaneOriginMap_apply (v : β → M) (i : β) :
-    piPlaneOriginMap k v i = (pM).mkQ (v i) := rfl
-
-omit [Fintype β] [DecidableEq β] in
-lemma piPlaneOriginMap_surjective : Function.Surjective (piPlaneOriginMap (β := β) (M := M) k) := by
-  intro v
-  choose w hw using fun i => (pM).mkQ_surjective (v i)
-  exact ⟨w, funext hw⟩
-
-lemma planeOrigin_mem_iff (v : M) : v ∈ pM ↔
-    ∃ a b : M, v = (MvPolynomial.X 0 : A) • a + (MvPolynomial.X 1 : A) • b := by
-  change v ∈ jetRelation (MvPolynomial.X 0 : A) (MvPolynomial.X 1) 1 ↔ _
-  rw [jetRelation_one, mem_pairRelation]
-
-omit [Fintype β] [DecidableEq β] in
-lemma piPlaneOriginMap_ker : (piPlaneOriginMap (β := β) (M := M) k).ker = pPi := by
-  ext v
-  change piPlaneOriginMap k v = 0 ↔ v ∈ pPi
-  rw [planeOrigin_mem_iff]
-  constructor
-  · intro h
-    have hi (i : β) : v i ∈ pM := by
-      exact (Submodule.Quotient.mk_eq_zero pM).mp (congrFun h i)
-    choose a b hab using fun i => (planeOrigin_mem_iff k (v i)).mp (hi i)
-    exact ⟨a,b,funext hab⟩
-  · rintro ⟨a,b,rfl⟩
-    funext i
-    exact (Submodule.Quotient.mk_eq_zero pM).mpr
-      ((planeOrigin_mem_iff k _).mpr ⟨a i,b i,rfl⟩)
-
-noncomputable def piPlaneOriginEquiv : ((β → M) ⧸ pPi) ≃ₗ[k] (β → M ⧸ pM) := by
-  let f : (β → M) →ₗ[k] (β → M ⧸ pM) := piPlaneOriginMap (β := β) (M := M) k
-  let e : ((β → M) ⧸ f.ker) ≃ₗ[k] (β → M ⧸ pM) :=
-    f.quotKerEquivOfSurjective (piPlaneOriginMap_surjective (β := β) (M := M) k)
-  exact (Submodule.quotEquivOfEq pPi f.ker (piPlaneOriginMap_ker (β := β) (M := M) k).symm).trans e
-
-omit [Fintype β] [DecidableEq β] in
-lemma piPlaneOriginEquiv_mk (v : β → M) :
-    piPlaneOriginEquiv k ((pPi).mkQ v) = fun i => (pM).mkQ (v i) := rfl
-
-omit [DecidableEq β] in
-lemma piPlaneOrigin_finite [Module.Finite k (M ⧸ pM)] :
-    Module.Finite k ((β → M) ⧸ pPi) :=
-  Module.Finite.of_surjective (piPlaneOriginEquiv (β := β) (M := M) k).symm.toLinearMap
-    (piPlaneOriginEquiv k).symm.surjective
-
-variable (τ : Representation k (SL2 k) (β → k)) (σ : Representation k (SL2 k) M)
-  (hσ : PlaneCompatible k σ)
-
-lemma piPlaneOriginEquiv_intertwines (g : SL2 k) (v : (β → M) ⧸ pPi) :
-    piPlaneOriginEquiv k
-      (planeJetRep k (matrixTensorRepresentation τ σ) (matrixTensor_planeCompatible k τ σ hσ) 1 g v) =
-    matrixTensorRepresentation τ (planeJetRep k σ hσ 1) g (piPlaneOriginEquiv k v) := by
-  obtain ⟨v,rfl⟩ := (pPi).mkQ_surjective v
-  change piPlaneOriginEquiv k ((pPi).mkQ (matrixTensorRepresentation τ σ g v)) = _
-  rw [piPlaneOriginEquiv_mk, piPlaneOriginEquiv_mk]
-  funext i
-  simp only [matrixTensorRepresentation_apply, map_sum, map_smul]
-  rfl
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.PlaneMatrixTensor
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory
+open scoped BigOperators TensorProduct
+universe u
+variable (k : Type u) [Field k]
+variable {β : Type u} [Fintype β] [DecidableEq β]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+  [Module (MvPolynomial (Fin 2) k) M] [IsScalarTower k (MvPolynomial (Fin 2) k) M]
+local notation "A" => MvPolynomial (Fin 2) k
+local notation "pM" => planeJetRelation (M := M) k 1
+local notation "pPi" => planeJetRelation (M := β → M) k 1
+
+noncomputable def piPlaneOriginMap : (β → M) →ₗ[k] (β → M ⧸ pM) :=
+  LinearMap.pi fun i => (pM).mkQ.comp (LinearMap.proj i)
+
+omit [Fintype β] [DecidableEq β] in
+lemma piPlaneOriginMap_apply (v : β → M) (i : β) :
+    piPlaneOriginMap k v i = (pM).mkQ (v i) := rfl
+
+omit [Fintype β] [DecidableEq β] in
+lemma piPlaneOriginMap_surjective : Function.Surjective (piPlaneOriginMap (β := β) (M := M) k) := by
+  intro v
+  choose w hw using fun i => (pM).mkQ_surjective (v i)
+  exact ⟨w, funext hw⟩
+
+lemma planeOrigin_mem_iff (v : M) : v ∈ pM ↔
+    ∃ a b : M, v = (MvPolynomial.X 0 : A) • a + (MvPolynomial.X 1 : A) • b := by
+  change v ∈ jetRelation (MvPolynomial.X 0 : A) (MvPolynomial.X 1) 1 ↔ _
+  rw [jetRelation_one, mem_pairRelation]
+
+omit [Fintype ��] [DecidableEq β] in
+lemma piPlaneOriginMap_ker : (piPlaneOriginMap (β := β) (M := M) k).ker = pPi := by
+  ext v
+  change piPlaneOriginMap k v = 0 ↔ v ∈ pPi
+  rw [planeOrigin_mem_iff]
+  constructor
+  · intro h
+    have hi (i : β) : v i ∈ pM := by
+      exact (Submodule.Quotient.mk_eq_zero pM).mp (congrFun h i)
+    choose a b hab using fun i => (planeOrigin_mem_iff k (v i)).mp (hi i)
+    exact ⟨a,b,funext hab⟩
+  · rintro ⟨a,b,rfl⟩
+    funext i
+    exact (Submodule.Quotient.mk_eq_zero pM).mpr
+      ((planeOrigin_mem_iff k _).mpr ⟨a i,b i,rfl⟩)
+
+noncomputable def piPlaneOriginEquiv : ((β → M) ⧸ pPi) ≃ₗ[k] (β → M ⧸ pM) := by
+  let f : (β → M) →ₗ[k] (β → M ⧸ pM) := piPlaneOriginMap (β := β) (M := M) k
+  let e : ((β → M) ⧸ f.ker) ≃ₗ[k] (β → M ⧸ pM) :=
+    f.quotKerEquivOfSurjective (piPlaneOriginMap_surjective (β := β) (M := M) k)
+  exact (Submodule.quotEquivOfEq pPi f.ker (piPlaneOriginMap_ker (β := β) (M := M) k).symm).trans e
+
+omit [Fintype β] [DecidableEq β] in
+lemma piPlaneOriginEquiv_mk (v : β → M) :
+    piPlaneOriginEquiv k ((pPi).mkQ v) = fun i => (pM).mkQ (v i) := rfl
+
+omit [DecidableEq β] in
+lemma piPlaneOrigin_finite [Module.Finite k (M ⧸ pM)] :
+    Module.Finite k ((β → M) ⧸ pPi) :=
+  Module.Finite.of_surjective (piPlaneOriginEquiv (β := β) (M := M) k).symm.toLinearMap
+    (piPlaneOriginEquiv k).symm.surjective
+
+variable (τ : Representation k (SL2 k) (β → k)) (σ : Representation k (SL2 k) M)
+  (hσ : PlaneCompatible k σ)
+
+lemma piPlaneOriginEquiv_intertwines (g : SL2 k) (v : (β → M) ⧸ pPi) :
+    piPlaneOriginEquiv k
+      (planeJetRep k (matrixTensorRepresentation τ σ) (matrixTensor_planeCompatible k τ σ hσ) 1 g v) =
+    matrixTensorRepresentation τ (planeJetRep k σ hσ 1) g (piPlaneOriginEquiv k v) := by
+  obtain ⟨v,rfl⟩ := (pPi).mkQ_surjective v
+  change piPlaneOriginEquiv k ((pPi).mkQ (matrixTensorRepresentation τ σ g v)) = _
+  rw [piPlaneOriginEquiv_mk, piPlaneOriginEquiv_mk]
+  funext i
+  simp only [matrixTensorRepresentation_apply, map_sum, map_smul]
+  rfl
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PlaneCharts.lean

@@ -1,270 +1,270 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.RegularTorus
-
-namespace OAI
-
-/-! Two plane sections, transition matrices and associated charts. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-
-noncomputable def planeXSection (x : planeTorusPoints k) : SL2 k :=
-  ⟨!![x.val 0, 0; x.val 1, (x.val 0)⁻¹], by
-    simp [Matrix.det_fin_two, x.property 0]⟩
-
-noncomputable def planeYSection (x : planeTorusPoints k) : SL2 k :=
-  ⟨!![x.val 0, -(x.val 1)⁻¹; x.val 1, 0], by
-    simp [Matrix.det_fin_two, x.property 1]⟩
-
-noncomputable def planeChartCoordinate (i j : Fin 2) : planeCoordinateChart k i :=
-  algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) (MvPolynomial.X j)
-
-noncomputable def planeChartInverse (i : Fin 2) : planeCoordinateChart k i :=
-  IsLocalization.Away.invSelf (S := planeCoordinateChart k i) (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-
-omit [Infinite k] in
-lemma planeChartEvaluation_coordinate (i j : Fin 2) (x : planeTorusPoints k) :
-    planeChartEvaluation k i (planeChartCoordinate k i j) x = x.val j := by
-  rw [planeChartCoordinate, planeChartEvaluation_algebraMap,
-    planeTorusEvaluation_apply, MvPolynomial.eval_X]
-
-omit [Infinite k] in
-lemma planeChartEvaluation_inverse (i : Fin 2) (x : planeTorusPoints k) :
-    planeChartEvaluation k i (planeChartInverse k i) x = (x.val i)⁻¹ := by
-  have hmul : planeChartCoordinate k i i * planeChartInverse k i = 1 :=
-    IsLocalization.Away.mul_invSelf (S := planeCoordinateChart k i) (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-  have h := congrFun (congrArg (planeChartEvaluation k i) hmul) x
-  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
-    planeChartEvaluation_coordinate] at h
-  exact mul_left_cancel₀ (x.property i) (h.trans (mul_inv_cancel₀ (x.property i)).symm)
-
-noncomputable def planeXPolynomialChart :
-    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] planeCoordinateChart k 0 :=
-  MvPolynomial.aeval (fun ij =>
-    (!![planeChartCoordinate k 0 0, 0;
-      planeChartCoordinate k 0 1, planeChartInverse k 0]) ij.1 ij.2)
-
-noncomputable def planeYPolynomialChart :
-    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] planeCoordinateChart k 1 :=
-  MvPolynomial.aeval (fun ij =>
-    (!![planeChartCoordinate k 1 0, -planeChartInverse k 1;
-      planeChartCoordinate k 1 1, 0]) ij.1 ij.2)
-
-omit [Infinite k] in
-lemma planeXPolynomialChart_evaluation (P : MvPolynomial (Fin 2 × Fin 2) k)
-    (x : planeTorusPoints k) :
-    planeChartEvaluation k 0 (planeXPolynomialChart k P) x =
-      coordinateEvaluation k P (planeXSection k x) := by
-  induction P using MvPolynomial.induction_on with
-  | C c => simp [planeXPolynomialChart, coordinateEvaluation]
-  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
-  | mul_X P i hp =>
-    simp only [map_mul, Pi.mul_apply, hp]
-    congr 1
-    rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
-    rcases i with ⟨i,j⟩
-    fin_cases i <;> fin_cases j <;>
-      simp [planeXPolynomialChart, planeXSection,
-        planeChartEvaluation_coordinate, planeChartEvaluation_inverse]
-
-omit [Infinite k] in
-lemma planeYPolynomialChart_evaluation (P : MvPolynomial (Fin 2 × Fin 2) k)
-    (x : planeTorusPoints k) :
-    planeChartEvaluation k 1 (planeYPolynomialChart k P) x =
-      coordinateEvaluation k P (planeYSection k x) := by
-  induction P using MvPolynomial.induction_on with
-  | C c => simp [planeYPolynomialChart, coordinateEvaluation]
-  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
-  | mul_X P i hp =>
-    simp only [map_mul, Pi.mul_apply, hp]
-    congr 1
-    rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
-    rcases i with ⟨i,j⟩
-    fin_cases i <;> fin_cases j <;>
-      simp [planeYPolynomialChart, planeYSection,
-        planeChartEvaluation_coordinate, planeChartEvaluation_inverse]
-
-noncomputable def regularXChartValue (f : regularSL2Functions k) : planeCoordinateChart k 0 :=
-  planeXPolynomialChart k f.property.choose
-
-omit [Infinite k] in
-lemma regularXChartValue_evaluation (f : regularSL2Functions k) (x : planeTorusPoints k) :
-    planeChartEvaluation k 0 (regularXChartValue k f) x = f.val (planeXSection k x) := by
-  rw [regularXChartValue, planeXPolynomialChart_evaluation]
-  exact congrFun f.property.choose_spec _
-
-noncomputable def regularXChart : regularSL2Functions k →ₐ[k] planeCoordinateChart k 0 where
-  toFun := regularXChartValue k
-  map_zero' := by
-    apply planeChartEvaluation_injective k 0
-    ext x
-    rw [regularXChartValue_evaluation, map_zero]
-    rfl
-  map_one' := by
-    apply planeChartEvaluation_injective k 0
-    ext x
-    rw [regularXChartValue_evaluation, map_one]
-    rfl
-  map_add' f h := by
-    apply planeChartEvaluation_injective k 0
-    ext x
-    rw [map_add, Pi.add_apply, regularXChartValue_evaluation,
-      regularXChartValue_evaluation, regularXChartValue_evaluation]
-    rfl
-  map_mul' f h := by
-    apply planeChartEvaluation_injective k 0
-    ext x
-    rw [map_mul, Pi.mul_apply, regularXChartValue_evaluation,
-      regularXChartValue_evaluation, regularXChartValue_evaluation]
-    rfl
-  commutes' a := by
-    apply planeChartEvaluation_injective k 0
-    ext x
-    rw [regularXChartValue_evaluation, AlgHom.commutes]
-    rfl
-
-noncomputable def regularYChartValue (f : regularSL2Functions k) : planeCoordinateChart k 1 :=
-  planeYPolynomialChart k f.property.choose
-
-omit [Infinite k] in
-lemma regularYChartValue_evaluation (f : regularSL2Functions k) (x : planeTorusPoints k) :
-    planeChartEvaluation k 1 (regularYChartValue k f) x = f.val (planeYSection k x) := by
-  rw [regularYChartValue, planeYPolynomialChart_evaluation]
-  exact congrFun f.property.choose_spec _
-
-noncomputable def regularYChart : regularSL2Functions k →ₐ[k] planeCoordinateChart k 1 where
-  toFun := regularYChartValue k
-  map_zero' := by
-    apply planeChartEvaluation_injective k 1
-    ext x
-    rw [regularYChartValue_evaluation, map_zero]
-    rfl
-  map_one' := by
-    apply planeChartEvaluation_injective k 1
-    ext x
-    rw [regularYChartValue_evaluation, map_one]
-    rfl
-  map_add' f h := by
-    apply planeChartEvaluation_injective k 1
-    ext x
-    rw [map_add, Pi.add_apply, regularYChartValue_evaluation,
-      regularYChartValue_evaluation, regularYChartValue_evaluation]
-    rfl
-  map_mul' f h := by
-    apply planeChartEvaluation_injective k 1
-    ext x
-    rw [map_mul, Pi.mul_apply, regularYChartValue_evaluation,
-      regularYChartValue_evaluation, regularYChartValue_evaluation]
-    rfl
-  commutes' a := by
-    apply planeChartEvaluation_injective k 1
-    ext x
-    rw [regularYChartValue_evaluation, AlgHom.commutes]
-    rfl
-
-end
-
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma planeSections_transition (x : planeTorusPoints k) :
-    planeYSection k x = planeXSection k x * unipotent k (-(x.val 0 * x.val 1)⁻¹) := by
-  apply Subtype.ext
-  ext i j
-  change _ = ((planeXSection k x : Matrix (Fin 2) (Fin 2) k) *
-    (unipotent k (-(x.val 0 * x.val 1)⁻¹) : Matrix (Fin 2) (Fin 2) k)) i j
-  fin_cases i <;> fin_cases j <;>
-    simp [planeXSection, planeYSection, unipotent, Matrix.mul_apply,
-      Fin.sum_univ_two, x.property]
-  field_simp [x.property 0, x.property 1]
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma sl2_xSection_decomposition (g : SL2 k) (ha : g 0 0 ≠ 0) (hc : g 1 0 ≠ 0) :
-    g = planeXSection k ⟨fun i => g i 0, by intro i; fin_cases i; exact ha; exact hc⟩ *
-      unipotent k (g 0 1 / g 0 0) := by
-  have hd : g 0 0 * g 1 1 - g 0 1 * g 1 0 = 1 := by
-    simpa only [Matrix.det_fin_two] using g.property
-  apply Subtype.ext
-  ext i j
-  change (g : Matrix (Fin 2) (Fin 2) k) i j =
-    ((planeXSection k _ : Matrix (Fin 2) (Fin 2) k) *
-    (unipotent k (g 0 1 / g 0 0) : Matrix (Fin 2) (Fin 2) k)) i j
-  fin_cases i <;> fin_cases j <;>
-    simp [planeXSection, unipotent, Matrix.mul_apply, Fin.sum_univ_two]
-  · field_simp
-  · apply (mul_left_cancel₀ ha)
-    field_simp
-    linear_combination hd
-
-noncomputable def associatedXChart :
-    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (ι → planeCoordinateChart k 0) where
-  toFun f i := regularXChart k (f.val i)
-  map_add' := by intro f h; funext i; exact map_add _ _ _
-  map_smul' := by intro a f; funext i; exact (regularXChart k).toLinearMap.map_smul a (f.val i)
-
-noncomputable def associatedYChart :
-    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (ι → planeCoordinateChart k 1) where
-  toFun f i := regularYChart k (f.val i)
-  map_add' := by intro f h; funext i; exact map_add _ _ _
-  map_smul' := by intro a f; funext i; exact (regularYChart k).toLinearMap.map_smul a (f.val i)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedXChart_evaluation (f : associatedSectionsSubmodule k ι ρ)
-    (x : planeTorusPoints k) :
-    (fun i => planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x) =
-      regularVectorEvaluation k ι (planeXSection k x) f.val := by
-  funext i
-  exact regularXChartValue_evaluation k (f.val i) x
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedYChart_evaluation (f : associatedSectionsSubmodule k ι ρ)
-    (x : planeTorusPoints k) :
-    (fun i => planeChartEvaluation k 1 (associatedYChart k ι ρ f i) x) =
-      regularVectorEvaluation k ι (planeYSection k x) f.val := by
-  funext i
-  exact regularYChartValue_evaluation k (f.val i) x
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedCharts_transition (f : associatedSectionsSubmodule k ι ρ)
-    (x : planeTorusPoints k) :
-    (fun i => planeChartEvaluation k 1 (associatedYChart k ι ρ f i) x) =
-      ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
-        (fun i => planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x) := by
-  rw [associatedYChart_evaluation, associatedXChart_evaluation, planeSections_transition]
-  simpa only [neg_neg] using f.property (planeXSection k x) (-(x.val 0 * x.val 1)⁻¹)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedXChart_injective : Function.Injective (associatedXChart k ι ρ) := by
-  intro f h he
-  apply Subtype.ext
-  funext i
-  apply sub_eq_zero.mp
-  apply regularSL2_torus_dense k
-  intro g ha hc
-  let x : planeTorusPoints k := ⟨fun j => g j 0, by intro j; fin_cases j; exact ha; exact hc⟩
-  have hf' : regularVectorEvaluation k ι (planeXSection k x) f.val =
-      regularVectorEvaluation k ι (planeXSection k x) h.val := by
-    rw [← associatedXChart_evaluation, ← associatedXChart_evaluation, he]
-  have heq := f.property (planeXSection k x) (g 0 1 / g 0 0)
-  have heq' := h.property (planeXSection k x) (g 0 1 / g 0 0)
-  rw [← sl2_xSection_decomposition k g ha hc, hf'] at heq
-  rw [← sl2_xSection_decomposition k g ha hc] at heq'
-  exact sub_eq_zero.mpr (congrFun (heq.trans heq'.symm) i)
-
-end FiberFunctorProof
-
- 
-
-open scoped BigOperators
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.RegularTorus
+
+namespace OAI
+
+/-! Two plane sections, transition matrices and associated charts. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+
+noncomputable def planeXSection (x : planeTorusPoints k) : SL2 k :=
+  ⟨!![x.val 0, 0; x.val 1, (x.val 0)⁻¹], by
+    simp [Matrix.det_fin_two, x.property 0]⟩
+
+noncomputable def planeYSection (x : planeTorusPoints k) : SL2 k :=
+  ⟨!![x.val 0, -(x.val 1)⁻¹; x.val 1, 0], by
+    simp [Matrix.det_fin_two, x.property 1]⟩
+
+noncomputable def planeChartCoordinate (i j : Fin 2) : planeCoordinateChart k i :=
+  algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) (MvPolynomial.X j)
+
+noncomputable def planeChartInverse (i : Fin 2) : planeCoordinateChart k i :=
+  IsLocalization.Away.invSelf (S := planeCoordinateChart k i) (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+
+omit [Infinite k] in
+lemma planeChartEvaluation_coordinate (i j : Fin 2) (x : planeTorusPoints k) :
+    planeChartEvaluation k i (planeChartCoordinate k i j) x = x.val j := by
+  rw [planeChartCoordinate, planeChartEvaluation_algebraMap,
+    planeTorusEvaluation_apply, MvPolynomial.eval_X]
+
+omit [Infinite k] in
+lemma planeChartEvaluation_inverse (i : Fin 2) (x : planeTorusPoints k) :
+    planeChartEvaluation k i (planeChartInverse k i) x = (x.val i)⁻¹ := by
+  have hmul : planeChartCoordinate k i i * planeChartInverse k i = 1 :=
+    IsLocalization.Away.mul_invSelf (S := planeCoordinateChart k i) (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+  have h := congrFun (congrArg (planeChartEvaluation k i) hmul) x
+  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
+    planeChartEvaluation_coordinate] at h
+  exact mul_left_cancel₀ (x.property i) (h.trans (mul_inv_cancel₀ (x.property i)).symm)
+
+noncomputable def planeXPolynomialChart :
+    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] planeCoordinateChart k 0 :=
+  MvPolynomial.aeval (fun ij =>
+    (!![planeChartCoordinate k 0 0, 0;
+      planeChartCoordinate k 0 1, planeChartInverse k 0]) ij.1 ij.2)
+
+noncomputable def planeYPolynomialChart :
+    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] planeCoordinateChart k 1 :=
+  MvPolynomial.aeval (fun ij =>
+    (!![planeChartCoordinate k 1 0, -planeChartInverse k 1;
+      planeChartCoordinate k 1 1, 0]) ij.1 ij.2)
+
+omit [Infinite k] in
+lemma planeXPolynomialChart_evaluation (P : MvPolynomial (Fin 2 × Fin 2) k)
+    (x : planeTorusPoints k) :
+    planeChartEvaluation k 0 (planeXPolynomialChart k P) x =
+      coordinateEvaluation k P (planeXSection k x) := by
+  induction P using MvPolynomial.induction_on with
+  | C c => simp [planeXPolynomialChart, coordinateEvaluation]
+  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
+  | mul_X P i hp =>
+    simp only [map_mul, Pi.mul_apply, hp]
+    congr 1
+    rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
+    rcases i with ⟨i,j⟩
+    fin_cases i <;> fin_cases j <;>
+      simp [planeXPolynomialChart, planeXSection,
+        planeChartEvaluation_coordinate, planeChartEvaluation_inverse]
+
+omit [Infinite k] in
+lemma planeYPolynomialChart_evaluation (P : MvPolynomial (Fin 2 × Fin 2) k)
+    (x : planeTorusPoints k) :
+    planeChartEvaluation k 1 (planeYPolynomialChart k P) x =
+      coordinateEvaluation k P (planeYSection k x) := by
+  induction P using MvPolynomial.induction_on with
+  | C c => simp [planeYPolynomialChart, coordinateEvaluation]
+  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
+  | mul_X P i hp =>
+    simp only [map_mul, Pi.mul_apply, hp]
+    congr 1
+    rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
+    rcases i with ⟨i,j⟩
+    fin_cases i <;> fin_cases j <;>
+      simp [planeYPolynomialChart, planeYSection,
+        planeChartEvaluation_coordinate, planeChartEvaluation_inverse]
+
+noncomputable def regularXChartValue (f : regularSL2Functions k) : planeCoordinateChart k 0 :=
+  planeXPolynomialChart k f.property.choose
+
+omit [Infinite k] in
+lemma regularXChartValue_evaluation (f : regularSL2Functions k) (x : planeTorusPoints k) :
+    planeChartEvaluation k 0 (regularXChartValue k f) x = f.val (planeXSection k x) := by
+  rw [regularXChartValue, planeXPolynomialChart_evaluation]
+  exact congrFun f.property.choose_spec _
+
+noncomputable def regularXChart : regularSL2Functions k →ₐ[k] planeCoordinateChart k 0 where
+  toFun := regularXChartValue k
+  map_zero' := by
+    apply planeChartEvaluation_injective k 0
+    ext x
+    rw [regularXChartValue_evaluation, map_zero]
+    rfl
+  map_one' := by
+    apply planeChartEvaluation_injective k 0
+    ext x
+    rw [regularXChartValue_evaluation, map_one]
+    rfl
+  map_add' f h := by
+    apply planeChartEvaluation_injective k 0
+    ext x
+    rw [map_add, Pi.add_apply, regularXChartValue_evaluation,
+      regularXChartValue_evaluation, regularXChartValue_evaluation]
+    rfl
+  map_mul' f h := by
+    apply planeChartEvaluation_injective k 0
+    ext x
+    rw [map_mul, Pi.mul_apply, regularXChartValue_evaluation,
+      regularXChartValue_evaluation, regularXChartValue_evaluation]
+    rfl
+  commutes' a := by
+    apply planeChartEvaluation_injective k 0
+    ext x
+    rw [regularXChartValue_evaluation, AlgHom.commutes]
+    rfl
+
+noncomputable def regularYChartValue (f : regularSL2Functions k) : planeCoordinateChart k 1 :=
+  planeYPolynomialChart k f.property.choose
+
+omit [Infinite k] in
+lemma regularYChartValue_evaluation (f : regularSL2Functions k) (x : planeTorusPoints k) :
+    planeChartEvaluation k 1 (regularYChartValue k f) x = f.val (planeYSection k x) := by
+  rw [regularYChartValue, planeYPolynomialChart_evaluation]
+  exact congrFun f.property.choose_spec _
+
+noncomputable def regularYChart : regularSL2Functions k →ₐ[k] planeCoordinateChart k 1 where
+  toFun := regularYChartValue k
+  map_zero' := by
+    apply planeChartEvaluation_injective k 1
+    ext x
+    rw [regularYChartValue_evaluation, map_zero]
+    rfl
+  map_one' := by
+    apply planeChartEvaluation_injective k 1
+    ext x
+    rw [regularYChartValue_evaluation, map_one]
+    rfl
+  map_add' f h := by
+    apply planeChartEvaluation_injective k 1
+    ext x
+    rw [map_add, Pi.add_apply, regularYChartValue_evaluation,
+      regularYChartValue_evaluation, regularYChartValue_evaluation]
+    rfl
+  map_mul' f h := by
+    apply planeChartEvaluation_injective k 1
+    ext x
+    rw [map_mul, Pi.mul_apply, regularYChartValue_evaluation,
+      regularYChartValue_evaluation, regularYChartValue_evaluation]
+    rfl
+  commutes' a := by
+    apply planeChartEvaluation_injective k 1
+    ext x
+    rw [regularYChartValue_evaluation, AlgHom.commutes]
+    rfl
+
+end
+
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma planeSections_transition (x : planeTorusPoints k) :
+    planeYSection k x = planeXSection k x * unipotent k (-(x.val 0 * x.val 1)⁻¹) := by
+  apply Subtype.ext
+  ext i j
+  change _ = ((planeXSection k x : Matrix (Fin 2) (Fin 2) k) *
+    (unipotent k (-(x.val 0 * x.val 1)⁻¹) : Matrix (Fin 2) (Fin 2) k)) i j
+  fin_cases i <;> fin_cases j <;>
+    simp [planeXSection, planeYSection, unipotent, Matrix.mul_apply,
+      Fin.sum_univ_two, x.property]
+  field_simp [x.property 0, x.property 1]
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma sl2_xSection_decomposition (g : SL2 k) (ha : g 0 0 ≠ 0) (hc : g 1 0 ≠ 0) :
+    g = planeXSection k ⟨fun i => g i 0, by intro i; fin_cases i; exact ha; exact hc⟩ *
+      unipotent k (g 0 1 / g 0 0) := by
+  have hd : g 0 0 * g 1 1 - g 0 1 * g 1 0 = 1 := by
+    simpa only [Matrix.det_fin_two] using g.property
+  apply Subtype.ext
+  ext i j
+  change (g : Matrix (Fin 2) (Fin 2) k) i j =
+    ((planeXSection k _ : Matrix (Fin 2) (Fin 2) k) *
+    (unipotent k (g 0 1 / g 0 0) : Matrix (Fin 2) (Fin 2) k)) i j
+  fin_cases i <;> fin_cases j <;>
+    simp [planeXSection, unipotent, Matrix.mul_apply, Fin.sum_univ_two]
+  · field_simp
+  · apply (mul_left_cancel₀ ha)
+    field_simp
+    linear_combination hd
+
+noncomputable def associatedXChart :
+    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (ι → planeCoordinateChart k 0) where
+  toFun f i := regularXChart k (f.val i)
+  map_add' := by intro f h; funext i; exact map_add _ _ _
+  map_smul' := by intro a f; funext i; exact (regularXChart k).toLinearMap.map_smul a (f.val i)
+
+noncomputable def associatedYChart :
+    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (ι → planeCoordinateChart k 1) where
+  toFun f i := regularYChart k (f.val i)
+  map_add' := by intro f h; funext i; exact map_add _ _ _
+  map_smul' := by intro a f; funext i; exact (regularYChart k).toLinearMap.map_smul a (f.val i)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedXChart_evaluation (f : associatedSectionsSubmodule k ι ρ)
+    (x : planeTorusPoints k) :
+    (fun i => planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x) =
+      regularVectorEvaluation k ι (planeXSection k x) f.val := by
+  funext i
+  exact regularXChartValue_evaluation k (f.val i) x
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedYChart_evaluation (f : associatedSectionsSubmodule k ι ρ)
+    (x : planeTorusPoints k) :
+    (fun i => planeChartEvaluation k 1 (associatedYChart k ι ρ f i) x) =
+      regularVectorEvaluation k ι (planeYSection k x) f.val := by
+  funext i
+  exact regularYChartValue_evaluation k (f.val i) x
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedCharts_transition (f : associatedSectionsSubmodule k ι ρ)
+    (x : planeTorusPoints k) :
+    (fun i => planeChartEvaluation k 1 (associatedYChart k ι ρ f i) x) =
+      ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
+        (fun i => planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x) := by
+  rw [associatedYChart_evaluation, associatedXChart_evaluation, planeSections_transition]
+  simpa only [neg_neg] using f.property (planeXSection k x) (-(x.val 0 * x.val 1)⁻¹)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedXChart_injective : Function.Injective (associatedXChart k ι ρ) := by
+  intro f h he
+  apply Subtype.ext
+  funext i
+  apply sub_eq_zero.mp
+  apply regularSL2_torus_dense k
+  intro g ha hc
+  let x : planeTorusPoints k := ⟨fun j => g j 0, by intro j; fin_cases j; exact ha; exact hc⟩
+  have hf' : regularVectorEvaluation k ι (planeXSection k x) f.val =
+      regularVectorEvaluation k ι (planeXSection k x) h.val := by
+    rw [← associatedXChart_evaluation, ← associatedXChart_evaluation, he]
+  have heq := f.property (planeXSection k x) (g 0 1 / g 0 0)
+  have heq' := h.property (planeXSection k x) (g 0 1 / g 0 0)
+  rw [← sl2_xSection_decomposition k g ha hc, hf'] at heq
+  rw [← sl2_xSection_decomposition k g ha hc] at heq'
+  exact sub_eq_zero.mpr (congrFun (heq.trans heq'.symm) i)
+
+end FiberFunctorProof
+
+ 
+
+open scoped BigOperators
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PlaneFibre.lean

@@ -1,122 +1,122 @@
-import OAI.RepresentationTheory.RestrictedTilting.BoundedOriginTarget
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped Pointwise
-universe u
-noncomputable section
-variable {k : Type u} [Field k]
-local notation "A" => MvPolynomial (Fin 2) k
-variable (M N : Type u) [AddCommGroup M] [Module k M] [Module (MvPolynomial (Fin 2) k) M]
-  [IsScalarTower k (MvPolynomial (Fin 2) k) M] [AddCommGroup N] [Module k N] [Module (MvPolynomial (Fin 2) k) N] [IsScalarTower k (MvPolynomial (Fin 2) k) N]
-
-abbrev planeFibreRelations (a : Fin 2 → k) : Submodule k M :=
-  ((planePointIdeal a • (⊤ : Submodule A M))).restrictScalars k
-
-lemma planeFibre_mk_smul (a : Fin 2 → k) (P : A) (m : M) :
-    (planeFibreRelations M a).mkQ (P • m) =
-      MvPolynomial.eval a P • (planeFibreRelations M a).mkQ m := by
-  rw [← map_smul]
-  apply (Submodule.Quotient.eq _).mpr
-  change P • m - MvPolynomial.eval a P • m ∈ planePointIdeal a • (⊤ : Submodule A M)
-  have h : P - MvPolynomial.C (MvPolynomial.eval a P) ∈ planePointIdeal a := by
-    simp [planePointIdeal, RingHom.mem_ker]
-  convert Submodule.smul_mem_smul h (show m ∈ (⊤ : Submodule A M) from trivial) using 1
-  simp only [sub_smul, MvPolynomial.C_eq_algebraMap, algebraMap_smul]
-
-lemma planeFibre_map_mem (a : Fin 2 → k) (f : M →ₗ[A] N) :
-    planeFibreRelations M a ≤ (planeFibreRelations N a).comap (f.restrictScalars k) := by
-  intro m hm
-  change f m ∈ planePointIdeal a • (⊤ : Submodule A N)
-  have hf : (planePointIdeal a • (⊤ : Submodule A M)).map f ≤
-      planePointIdeal a • (⊤ : Submodule A N) := by
-    rw [Submodule.map_smul'']
-    exact smul_mono_right (planePointIdeal a) le_top
-  exact hf (Submodule.mem_map_of_mem hm)
-
-def planeFibreMap (a : Fin 2 → k) (f : M →ₗ[A] N) :
-    (M ⧸ planeFibreRelations M a) →ₗ[k] (N ⧸ planeFibreRelations N a) :=
-  (planeFibreRelations M a).mapQ (planeFibreRelations N a) (f.restrictScalars k)
-    (planeFibre_map_mem M N a f)
-
-@[simp] lemma planeFibreMap_mk (a : Fin 2 → k) (f : M →ₗ[A] N) (m : M) :
-    planeFibreMap M N a f ((planeFibreRelations M a).mkQ m) =
-      (planeFibreRelations N a).mkQ (f m) := rfl
-
- 
-
-def planeFibreEquivOfSplit (a : Fin 2 → k) (f : M →ₗ[A] N) (g : N →ₗ[A] M)
-    (s : A) (hs : MvPolynomial.eval a s = 1)
-    (hgf : ∀ m, g (f m) = s • m) (hfg : ∀ n, f (g n) = s • n) :
-    (M ⧸ planeFibreRelations M a) ≃ₗ[k] (N ⧸ planeFibreRelations N a) :=
-  LinearEquiv.ofLinearMap (planeFibreMap M N a f) (planeFibreMap N M a g)
-    (by apply LinearMap.ext; intro n; obtain ⟨n,rfl⟩ := (planeFibreRelations N a).mkQ_surjective n
-        change (planeFibreRelations N a).mkQ (f (g n)) = (planeFibreRelations N a).mkQ n
-        rw [hfg, planeFibre_mk_smul, hs, one_smul])
-    (by apply LinearMap.ext; intro m; obtain ⟨m,rfl⟩ := (planeFibreRelations M a).mkQ_surjective m
-        change (planeFibreRelations M a).mkQ (g (f m)) = (planeFibreRelations M a).mkQ m
-        rw [hgf, planeFibre_mk_smul, hs, one_smul])
-
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-
-def planeVectorEval (a : Fin 2 → k) : (ι → A) →ₗ[k] (ι → k) where
-  toFun v i := MvPolynomial.eval a (v i)
-  map_add' v w := by ext i; simp
-  map_smul' c v := by ext i; simp
-
-def planeVectorConstant : (ι → k) →ₗ[k] (ι → A) where
-  toFun v i := MvPolynomial.C (v i)
-  map_add' v w := by ext i; simp
-  map_smul' c v := by ext i; simp [MvPolynomial.C_mul, Algebra.smul_def]
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma planeVectorEval_relations (a : Fin 2 → k) :
-    planeFibreRelations (ι → A) a ≤ (planeVectorEval ι a).ker := by
-  intro v hv
-  change v ∈ planePointIdeal a • (⊤ : Submodule A (ι → A)) at hv
-  change planeVectorEval ι a v = 0
-  refine Submodule.smul_induction_on hv ?_ ?_
-  · intro r hr n hn
-    ext i
-    change MvPolynomial.eval a (r * n i) = 0
-    have hr0 : MvPolynomial.eval a r = 0 := hr
-    simp [hr0]
-  · intro x y hx hy
-    simp only [map_add, hx, hy, add_zero]
-
-def planeFreeFibreEval (a : Fin 2 → k) :
-    ((ι → A) ⧸ planeFibreRelations (ι → A) a) →ₗ[k] (ι → k) :=
-  (planeFibreRelations (ι → A) a).liftQ (planeVectorEval ι a) (planeVectorEval_relations ι a)
-
-lemma planeFreeFibre_constant_eval (a : Fin 2 → k) (v : ι → A) :
-    (planeFibreRelations (ι → A) a).mkQ (planeVectorConstant ι (planeVectorEval ι a v)) =
-      (planeFibreRelations (ι → A) a).mkQ v := by
-  apply (Submodule.Quotient.eq _).mpr
-  change planeVectorConstant ι (planeVectorEval ι a v) - v ∈
-    planePointIdeal a • (⊤ : Submodule A (ι → A))
-  have he : planeVectorConstant ι (planeVectorEval ι a v) - v =
-      ∑ i : ι, (MvPolynomial.C (MvPolynomial.eval a (v i)) - v i) • Pi.single i (1 : A) := by
-    ext j
-    simp [planeVectorConstant, planeVectorEval, Pi.single_apply]
-  rw [he]
-  apply Submodule.sum_mem
-  intro i hi
-  apply Submodule.smul_mem_smul _ (Submodule.mem_top)
-  simp [planePointIdeal, RingHom.mem_ker]
-
-def planeFreeFibreEquiv (a : Fin 2 → k) :
-    ((ι → A) ⧸ planeFibreRelations (ι → A) a) ≃ₗ[k] (ι → k) :=
-  LinearEquiv.ofLinearMap (planeFreeFibreEval ι a)
-    ((planeFibreRelations (ι → A) a).mkQ.comp (planeVectorConstant ι))
-    (by apply LinearMap.ext; intro v; ext i; simp [planeFreeFibreEval, planeVectorEval, planeVectorConstant])
-    (by apply LinearMap.ext; intro v; obtain ⟨v,rfl⟩ := (planeFibreRelations (ι → A) a).mkQ_surjective v
-        exact planeFreeFibre_constant_eval ι a v)
-
-@[simp] lemma planeFreeFibreEquiv_mk (a : Fin 2 → k) (v : ι → A) :
-    planeFreeFibreEquiv ι a ((planeFibreRelations (ι → A) a).mkQ v) = planeVectorEval ι a v := rfl
-
-end
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.BoundedOriginTarget
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped Pointwise
+universe u
+noncomputable section
+variable {k : Type u} [Field k]
+local notation "A" => MvPolynomial (Fin 2) k
+variable (M N : Type u) [AddCommGroup M] [Module k M] [Module (MvPolynomial (Fin 2) k) M]
+  [IsScalarTower k (MvPolynomial (Fin 2) k) M] [AddCommGroup N] [Module k N] [Module (MvPolynomial (Fin 2) k) N] [IsScalarTower k (MvPolynomial (Fin 2) k) N]
+
+abbrev planeFibreRelations (a : Fin 2 → k) : Submodule k M :=
+  ((planePointIdeal a • (⊤ : Submodule A M))).restrictScalars k
+
+lemma planeFibre_mk_smul (a : Fin 2 → k) (P : A) (m : M) :
+    (planeFibreRelations M a).mkQ (P • m) =
+      MvPolynomial.eval a P • (planeFibreRelations M a).mkQ m := by
+  rw [← map_smul]
+  apply (Submodule.Quotient.eq _).mpr
+  change P • m - MvPolynomial.eval a P • m ∈ planePointIdeal a • (⊤ : Submodule A M)
+  have h : P - MvPolynomial.C (MvPolynomial.eval a P) ∈ planePointIdeal a := by
+    simp [planePointIdeal, RingHom.mem_ker]
+  convert Submodule.smul_mem_smul h (show m ∈ (⊤ : Submodule A M) from trivial) using 1
+  simp only [sub_smul, MvPolynomial.C_eq_algebraMap, algebraMap_smul]
+
+lemma planeFibre_map_mem (a : Fin 2 → k) (f : M →ₗ[A] N) :
+    planeFibreRelations M a ≤ (planeFibreRelations N a).comap (f.restrictScalars k) := by
+  intro m hm
+  change f m ∈ planePointIdeal a • (⊤ : Submodule A N)
+  have hf : (planePointIdeal a • (⊤ : Submodule A M)).map f ≤
+      planePointIdeal a • (⊤ : Submodule A N) := by
+    rw [Submodule.map_smul'']
+    exact smul_mono_right (planePointIdeal a) le_top
+  exact hf (Submodule.mem_map_of_mem hm)
+
+def planeFibreMap (a : Fin 2 → k) (f : M →ₗ[A] N) :
+    (M ⧸ planeFibreRelations M a) →ₗ[k] (N ⧸ planeFibreRelations N a) :=
+  (planeFibreRelations M a).mapQ (planeFibreRelations N a) (f.restrictScalars k)
+    (planeFibre_map_mem M N a f)
+
+@[simp] lemma planeFibreMap_mk (a : Fin 2 → k) (f : M →ₗ[A] N) (m : M) :
+    planeFibreMap M N a f ((planeFibreRelations M a).mkQ m) =
+      (planeFibreRelations N a).mkQ (f m) := rfl
+
+ 
+
+def planeFibreEquivOfSplit (a : Fin 2 → k) (f : M →ₗ[A] N) (g : N →ₗ[A] M)
+    (s : A) (hs : MvPolynomial.eval a s = 1)
+    (hgf : ∀ m, g (f m) = s • m) (hfg : ∀ n, f (g n) = s • n) :
+    (M ⧸ planeFibreRelations M a) ≃ₗ[k] (N ⧸ planeFibreRelations N a) :=
+  LinearEquiv.ofLinearMap (planeFibreMap M N a f) (planeFibreMap N M a g)
+    (by apply LinearMap.ext; intro n; obtain ⟨n,rfl⟩ := (planeFibreRelations N a).mkQ_surjective n
+        change (planeFibreRelations N a).mkQ (f (g n)) = (planeFibreRelations N a).mkQ n
+        rw [hfg, planeFibre_mk_smul, hs, one_smul])
+    (by apply LinearMap.ext; intro m; obtain ⟨m,rfl⟩ := (planeFibreRelations M a).mkQ_surjective m
+        change (planeFibreRelations M a).mkQ (g (f m)) = (planeFibreRelations M a).mkQ m
+        rw [hgf, planeFibre_mk_smul, hs, one_smul])
+
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+
+def planeVectorEval (a : Fin 2 → k) : (ι → A) →ₗ[k] (ι → k) where
+  toFun v i := MvPolynomial.eval a (v i)
+  map_add' v w := by ext i; simp
+  map_smul' c v := by ext i; simp
+
+def planeVectorConstant : (ι → k) →ₗ[k] (ι → A) where
+  toFun v i := MvPolynomial.C (v i)
+  map_add' v w := by ext i; simp
+  map_smul' c v := by ext i; simp [MvPolynomial.C_mul, Algebra.smul_def]
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma planeVectorEval_relations (a : Fin 2 → k) :
+    planeFibreRelations (ι → A) a ≤ (planeVectorEval ι a).ker := by
+  intro v hv
+  change v ∈ planePointIdeal a • (⊤ : Submodule A (ι → A)) at hv
+  change planeVectorEval ι a v = 0
+  refine Submodule.smul_induction_on hv ?_ ?_
+  · intro r hr n hn
+    ext i
+    change MvPolynomial.eval a (r * n i) = 0
+    have hr0 : MvPolynomial.eval a r = 0 := hr
+    simp [hr0]
+  · intro x y hx hy
+    simp only [map_add, hx, hy, add_zero]
+
+def planeFreeFibreEval (a : Fin 2 → k) :
+    ((ι → A) ⧸ planeFibreRelations (ι → A) a) →ₗ[k] (ι → k) :=
+  (planeFibreRelations (ι → A) a).liftQ (planeVectorEval ι a) (planeVectorEval_relations ι a)
+
+lemma planeFreeFibre_constant_eval (a : Fin 2 → k) (v : ι → A) :
+    (planeFibreRelations (ι → A) a).mkQ (planeVectorConstant ι (planeVectorEval ι a v)) =
+      (planeFibreRelations (ι → A) a).mkQ v := by
+  apply (Submodule.Quotient.eq _).mpr
+  change planeVectorConstant ι (planeVectorEval ι a v) - v ∈
+    planePointIdeal a • (⊤ : Submodule A (ι → A))
+  have he : planeVectorConstant ι (planeVectorEval ι a v) - v =
+      ∑ i : ι, (MvPolynomial.C (MvPolynomial.eval a (v i)) - v i) • Pi.single i (1 : A) := by
+    ext j
+    simp [planeVectorConstant, planeVectorEval, Pi.single_apply]
+  rw [he]
+  apply Submodule.sum_mem
+  intro i hi
+  apply Submodule.smul_mem_smul _ (Submodule.mem_top)
+  simp [planePointIdeal, RingHom.mem_ker]
+
+def planeFreeFibreEquiv (a : Fin 2 → k) :
+    ((ι → A) ⧸ planeFibreRelations (ι → A) a) ≃ₗ[k] (ι → k) :=
+  LinearEquiv.ofLinearMap (planeFreeFibreEval ι a)
+    ((planeFibreRelations (ι → A) a).mkQ.comp (planeVectorConstant ι))
+    (by apply LinearMap.ext; intro v; ext i; simp [planeFreeFibreEval, planeVectorEval, planeVectorConstant])
+    (by apply LinearMap.ext; intro v; obtain ⟨v,rfl⟩ := (planeFibreRelations (ι → A) a).mkQ_surjective v
+        exact planeFreeFibre_constant_eval ι a v)
+
+@[simp] lemma planeFreeFibreEquiv_mk (a : Fin 2 → k) (v : ι → A) :
+    planeFreeFibreEquiv ι a ((planeFibreRelations (ι → A) a).mkQ v) = planeVectorEval ι a v := rfl
+
+end
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PlaneMatrixTensor.lean

@@ -1,115 +1,115 @@
-import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators TensorProduct
-universe u
-section MatrixTensor
-variable {k : Type u} [Field k] {G : Type u} [Monoid G]
-variable {β : Type u} [Fintype β] [DecidableEq β]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-
-noncomputable def matrixTensorLinear (A : Matrix β β k) (f : M →ₗ[k] M) :
-    (β → M) →ₗ[k] (β → M) :=
-  LinearMap.pi fun i => ∑ j, A i j • f.comp (LinearMap.proj j)
-
-omit [DecidableEq β] in
-lemma matrixTensorLinear_apply (A : Matrix β β k) (f : M →ₗ[k] M) (v : β → M) (i : β) :
-    matrixTensorLinear A f v i = ∑ j, A i j • f (v j) := by
-  simp only [matrixTensorLinear, LinearMap.pi_apply, LinearMap.sum_apply,
-    LinearMap.smul_apply, LinearMap.comp_apply, LinearMap.proj_apply]
-
-lemma matrixTensorLinear_one : matrixTensorLinear (1 : Matrix β β k) (LinearMap.id : M →ₗ[k] M) = 1 := by
-  apply LinearMap.ext
-  intro v
-  funext i
-  simp [matrixTensorLinear_apply, Matrix.one_apply]
-
-omit [DecidableEq β] in
-lemma matrixTensorLinear_mul (A B : Matrix β β k) (f g : M →ₗ[k] M) :
-    matrixTensorLinear (A*B) (f*g) = matrixTensorLinear A f * matrixTensorLinear B g := by
-  apply LinearMap.ext
-  intro v
-  funext i
-  simp only [Module.End.mul_apply, matrixTensorLinear_apply, Matrix.mul_apply,
-    Finset.sum_smul, map_sum, map_smul, Finset.smul_sum, smul_smul]
-  rw [Finset.sum_comm]
-
-noncomputable def matrixTensorRepresentation
-    (τ : Representation k G (β → k)) (σ : Representation k G M) :
-    Representation k G (β → M) where
-  toFun g := matrixTensorLinear (LinearMap.toMatrix' (τ g)) (σ g)
-  map_one' := by
-    simp only [map_one, LinearMap.toMatrix'_one]
-    exact matrixTensorLinear_one
-  map_mul' g h := by
-    simp only [map_mul, LinearMap.toMatrix'_mul, matrixTensorLinear_mul]
-
-lemma matrixTensorRepresentation_apply (τ : Representation k G (β → k))
-    (σ : Representation k G M) (g : G) (v : β → M) (i : β) :
-    matrixTensorRepresentation τ σ g v i = ∑ j, LinearMap.toMatrix' (τ g) i j • σ g (v j) :=
-  matrixTensorLinear_apply _ _ _ _
-
-end MatrixTensor
-
-section PlaneTensor
-variable (k : Type u) [Field k]
-variable {β : Type u} [Fintype β] [DecidableEq β]
-variable {M : Type u} [AddCommGroup M] [Module k M]
-variable (τ : Representation k (SL2 k) (β → k)) (σ : Representation k (SL2 k) M)
-
-lemma matrixTensor_rational (hτ : IsRational k τ) (hσ : IsRational k σ) :
-    IsRational k (matrixTensorRepresentation τ σ) := by
-  classical
-  intro v l
-  choose P hP using fun (i j : β) => hτ (Pi.single j 1) (LinearMap.proj i)
-  choose Q hQ using fun (i j : β) => hσ (v j) (l.comp (LinearMap.single k (fun _ : β => M) i))
-  refine ⟨∑ i, ∑ j, P i j * Q i j, fun g => ?_⟩
-  have he : matrixTensorRepresentation τ σ g v =
-      ∑ i, ∑ j, LinearMap.toMatrix' (τ g) i j •
-        (LinearMap.single k (fun _ : β => M) i) (σ g (v j)) := by
-    calc
-      _ = ∑ i, (LinearMap.single k (fun _ : β => M) i)
-          (matrixTensorRepresentation τ σ g v i) := (Finset.univ_sum_single _).symm
-      _ = _ := by
-        simp only [matrixTensorRepresentation_apply, map_sum, map_smul]
-  rw [he]
-  simp only [map_sum, map_smul, smul_eq_mul, map_mul, ← hP, ← hQ,
-    LinearMap.comp_apply, LinearMap.toMatrix'_apply, LinearMap.proj_apply]
-
-variable [Module (MvPolynomial (Fin 2) k) M]
-  [IsScalarTower k (MvPolynomial (Fin 2) k) M]
-
-lemma matrixTensor_planeCompatible (hσ : PlaneCompatible k σ) :
-    PlaneCompatible k (matrixTensorRepresentation τ σ) := by
-  intro g P v
-  funext i
-  simp only [matrixTensorRepresentation_apply, Pi.smul_apply, Finset.smul_sum]
-  apply Finset.sum_congr rfl
-  intro j _
-  rw [hσ]
-  exact smul_comm _ _ _
-
-omit [Fintype β] [DecidableEq β] [Module k M] [IsScalarTower k (MvPolynomial (Fin 2) k) M] in
-lemma pi_regular_x
-    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m)) :
-    Function.Injective (fun m : β → M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m) := by
-  intro v w h
-  funext i
-  exact hx (congrFun h i)
-
-omit [Fintype β] [DecidableEq β] [Module k M] [IsScalarTower k (MvPolynomial (Fin 2) k) M] in
-lemma pi_regular_y
-    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n → ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) :
-    ∀ v n : β → M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n → ∃ w : β → M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w := by
-  intro v n h
-  choose w hw using fun i => hy (v i) (n i) (congrFun h i)
-  exact ⟨w, funext hw⟩
-
-end PlaneTensor
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators TensorProduct
+universe u
+section MatrixTensor
+variable {k : Type u} [Field k] {G : Type u} [Monoid G]
+variable {β : Type u} [Fintype β] [DecidableEq β]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+
+noncomputable def matrixTensorLinear (A : Matrix β β k) (f : M →ₗ[k] M) :
+    (β → M) →ₗ[k] (β → M) :=
+  LinearMap.pi fun i => ∑ j, A i j • f.comp (LinearMap.proj j)
+
+omit [DecidableEq β] in
+lemma matrixTensorLinear_apply (A : Matrix β β k) (f : M →ₗ[k] M) (v : β → M) (i : β) :
+    matrixTensorLinear A f v i = ∑ j, A i j • f (v j) := by
+  simp only [matrixTensorLinear, LinearMap.pi_apply, LinearMap.sum_apply,
+    LinearMap.smul_apply, LinearMap.comp_apply, LinearMap.proj_apply]
+
+lemma matrixTensorLinear_one : matrixTensorLinear (1 : Matrix β β k) (LinearMap.id : M →ₗ[k] M) = 1 := by
+  apply LinearMap.ext
+  intro v
+  funext i
+  simp [matrixTensorLinear_apply, Matrix.one_apply]
+
+omit [DecidableEq β] in
+lemma matrixTensorLinear_mul (A B : Matrix β β k) (f g : M →ₗ[k] M) :
+    matrixTensorLinear (A*B) (f*g) = matrixTensorLinear A f * matrixTensorLinear B g := by
+  apply LinearMap.ext
+  intro v
+  funext i
+  simp only [Module.End.mul_apply, matrixTensorLinear_apply, Matrix.mul_apply,
+    Finset.sum_smul, map_sum, map_smul, Finset.smul_sum, smul_smul]
+  rw [Finset.sum_comm]
+
+noncomputable def matrixTensorRepresentation
+    (τ : Representation k G (β → k)) (σ : Representation k G M) :
+    Representation k G (β → M) where
+  toFun g := matrixTensorLinear (LinearMap.toMatrix' (τ g)) (σ g)
+  map_one' := by
+    simp only [map_one, LinearMap.toMatrix'_one]
+    exact matrixTensorLinear_one
+  map_mul' g h := by
+    simp only [map_mul, LinearMap.toMatrix'_mul, matrixTensorLinear_mul]
+
+lemma matrixTensorRepresentation_apply (τ : Representation k G (β → k))
+    (σ : Representation k G M) (g : G) (v : β → M) (i : β) :
+    matrixTensorRepresentation τ σ g v i = ∑ j, LinearMap.toMatrix' (τ g) i j • σ g (v j) :=
+  matrixTensorLinear_apply _ _ _ _
+
+end MatrixTensor
+
+section PlaneTensor
+variable (k : Type u) [Field k]
+variable {β : Type u} [Fintype β] [DecidableEq β]
+variable {M : Type u} [AddCommGroup M] [Module k M]
+variable (τ : Representation k (SL2 k) (β → k)) (σ : Representation k (SL2 k) M)
+
+lemma matrixTensor_rational (hτ : IsRational k τ) (hσ : IsRational k σ) :
+    IsRational k (matrixTensorRepresentation τ σ) := by
+  classical
+  intro v l
+  choose P hP using fun (i j : β) => hτ (Pi.single j 1) (LinearMap.proj i)
+  choose Q hQ using fun (i j : β) => hσ (v j) (l.comp (LinearMap.single k (fun _ : β => M) i))
+  refine ⟨∑ i, ∑ j, P i j * Q i j, fun g => ?_⟩
+  have he : matrixTensorRepresentation τ σ g v =
+      ∑ i, ∑ j, LinearMap.toMatrix' (τ g) i j •
+        (LinearMap.single k (fun _ : β => M) i) (σ g (v j)) := by
+    calc
+      _ = ∑ i, (LinearMap.single k (fun _ : β => M) i)
+          (matrixTensorRepresentation τ σ g v i) := (Finset.univ_sum_single _).symm
+      _ = _ := by
+        simp only [matrixTensorRepresentation_apply, map_sum, map_smul]
+  rw [he]
+  simp only [map_sum, map_smul, smul_eq_mul, map_mul, ← hP, ← hQ,
+    LinearMap.comp_apply, LinearMap.toMatrix'_apply, LinearMap.proj_apply]
+
+variable [Module (MvPolynomial (Fin 2) k) M]
+  [IsScalarTower k (MvPolynomial (Fin 2) k) M]
+
+lemma matrixTensor_planeCompatible (hσ : PlaneCompatible k σ) :
+    PlaneCompatible k (matrixTensorRepresentation τ σ) := by
+  intro g P v
+  funext i
+  simp only [matrixTensorRepresentation_apply, Pi.smul_apply, Finset.smul_sum]
+  apply Finset.sum_congr rfl
+  intro j _
+  rw [hσ]
+  exact smul_comm _ _ _
+
+omit [Fintype β] [DecidableEq β] [Module k M] [IsScalarTower k (MvPolynomial (Fin 2) k) M] in
+lemma pi_regular_x
+    (hx : Function.Injective (fun m : M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m)) :
+    Function.Injective (fun m : β → M => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • m) := by
+  intro v w h
+  funext i
+  exact hx (congrFun h i)
+
+omit [Fintype β] [DecidableEq β] [Module k M] [IsScalarTower k (MvPolynomial (Fin 2) k) M] in
+lemma pi_regular_y
+    (hy : ∀ v n : M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n → ∃ w : M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) :
+    ∀ v n : β → M, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n → ∃ w : β → M, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w := by
+  intro v n h
+  choose w hw using fun i => hy (v i) (n i) (congrFun h i)
+  exact ⟨w, funext hw⟩
+
+end PlaneTensor
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PolynomialActions.lean

@@ -1,398 +1,398 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.PlaneCharts
-
-namespace OAI
-
-/-! Polynomial additive actions and associated polynomial sections. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-variable {k A B : Type*} [CommRing k] [CommRing A] [CommRing B]
-    [Algebra k A] [Algebra k B]
-
-lemma map_aeval_polynomial (f : A →ₐ[k] B) (a : A) (p : Polynomial k) :
-    f (Polynomial.aeval a p) = Polynomial.aeval (f a) p := by
-  have h : f.comp (Polynomial.aeval a) = Polynomial.aeval (f a) := by
-    ext
-    simp
-  exact AlgHom.congr_fun h p
-end
-
-section
-variable {k ι : Type*} [Field k] [Infinite k] [Fintype ι] [DecidableEq ι]
-
- 
-noncomputable def polynomialMatrixEval (P : Matrix ι ι (Polynomial k))
-    {A : Type*} [CommRing A] [Algebra k A] (t : A) : Matrix ι ι A :=
-  fun i j => Polynomial.aeval t (P i j)
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma polynomialMatrixEval_map (P : Matrix ι ι (Polynomial k))
-    {A B : Type*} [CommRing A] [CommRing B] [Algebra k A] [Algebra k B]
-    (f : A →ₐ[k] B) (t : A) :
-    (polynomialMatrixEval P t).map f = polynomialMatrixEval P (f t) := by
-  ext i j
-  exact map_aeval_polynomial f t (P i j)
-
-omit [DecidableEq ι] in
- 
-
-theorem polynomialMatrixEval_add (P : Matrix ι ι (Polynomial k))
-    (hP : ∀ s t : k, polynomialMatrixEval P (s+t) =
-      polynomialMatrixEval P s * polynomialMatrixEval P t)
-    {A : Type*} [CommRing A] [Algebra k A] (s t : A) :
-    polynomialMatrixEval P (s+t) = polynomialMatrixEval P s * polynomialMatrixEval P t := by
-  let X : Fin 2 → MvPolynomial (Fin 2) k := MvPolynomial.X
-  have h : polynomialMatrixEval P (X 0 + X 1) =
-      polynomialMatrixEval P (X 0) * polynomialMatrixEval P (X 1) := by
-    apply Matrix.ext
-    intro i j
-    apply MvPolynomial.funext
-    intro a
-    change MvPolynomial.aeval a _ = MvPolynomial.aeval a _
-    simp only [polynomialMatrixEval, Matrix.mul_apply, map_sum, map_mul,
-      map_aeval_polynomial, map_add, X, MvPolynomial.aeval_X]
-    exact congrArg (fun Q : Matrix ι ι k => Q i j) (hP (a 0) (a 1))
-  have he := congrArg (fun Q : Matrix ι ι (MvPolynomial (Fin 2) k) =>
-    Q.map (MvPolynomial.aeval ![s,t])) h
-  simpa only [polynomialMatrixEval_map, map_add, X, MvPolynomial.aeval_X,
-    Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.map_mul] using he
-
-omit [Infinite k] [Fintype ι] in
-lemma polynomialMatrixEval_zero (P : Matrix ι ι (Polynomial k))
-    (hP : polynomialMatrixEval P (0 : k) = 1)
-    (A : Type*) [CommRing A] [Algebra k A] :
-    polynomialMatrixEval P (0 : A) = 1 := by
-  have he := congrArg (fun Q : Matrix ι ι k => Q.map (algebraMap k A)) hP
-  have hm (i j : ι) : algebraMap k A (polynomialMatrixEval P (0 : k) i j) =
-      polynomialMatrixEval P (0 : A) i j := by
-    simp [polynomialMatrixEval, Polynomial.aeval_def]
-  apply Matrix.ext
-  intro i j
-  have heij := congrArg (fun Q : Matrix ι ι A => Q i j) he
-  rw [Matrix.map_apply, hm] at heij
-  simpa [Matrix.map_apply, Matrix.one_apply] using heij
-
- 
-
-noncomputable def polynomialAdditiveRepresentation
-    (P : Matrix ι ι (Polynomial k))
-    (h0 : polynomialMatrixEval P (0 : k) = 1)
-    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
-      polynomialMatrixEval P s * polynomialMatrixEval P t)
-    (A : Type*) [CommRing A] [Algebra k A] :
-    Multiplicative A →* Matrix ι ι A where
-  toFun t := polynomialMatrixEval P t.toAdd
-  map_one' := polynomialMatrixEval_zero P h0 A
-  map_mul' s t := polynomialMatrixEval_add P hadd s.toAdd t.toAdd
-
-end
-
-section
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma additive_rep_apply_add (s t : k) (v : ι → k) :
-    ρ (Multiplicative.ofAdd (s+t)) v =
-      ρ (Multiplicative.ofAdd s) (ρ (Multiplicative.ofAdd t) v) := by
-  change ρ (Multiplicative.ofAdd s * Multiplicative.ofAdd t) v = _
-  rw [map_mul]
-  rfl
-
-noncomputable def associatedLocalExpression (P : Matrix ι ι (Polynomial k))
-    (a : Fin 2) (f : ι → planeCoordinateChart k a) (i : ι) :
-    regularCoordinateLocalization k a :=
-  ∑ j, Polynomial.aeval
-    (-(algebraMap (regularSL2Functions k) (regularCoordinateLocalization k a)
-      (regularEntry k a 1)) * regularCoordinateInverse k a) (P i j) *
-        planeChartPullback k a (f j)
-
-omit [Infinite k] in
-lemma associatedLocalExpression_evaluation (P : Matrix ι ι (Polynomial k))
-    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-    (a : Fin 2) (f : ι → planeCoordinateChart k a) (g : regularTorusPoints k) :
-    (fun i => regularLocalizationEvaluation k a (associatedLocalExpression k ι P a f i) g) =
-      ρ (Multiplicative.ofAdd (-(g.val a 1 / g.val a 0)))
-        (fun j => planeChartEvaluation k a (f j) (regularToPlaneTorus k g)) := by
-  have h := LinearMap.toMatrix'_mulVec
-    (ρ (Multiplicative.ofAdd (-(g.val a 1 / g.val a 0))))
-    (fun j => planeChartEvaluation k a (f j) (regularToPlaneTorus k g))
-  rw [← hP] at h
-  rw [← h]
-  funext i
-  let ev : regularCoordinateLocalization k a →ₐ[k] k :=
-    (Pi.evalAlgHom k _ g).comp (regularLocalizationEvaluation k a)
-  change ev (associatedLocalExpression k ι P a f i) = _
-  simp only [associatedLocalExpression, map_sum, map_mul,
-    map_aeval_polynomial (k := k) (A := regularCoordinateLocalization k a) (B := k) ev,
-    map_neg]
-  change (∑ j, Polynomial.aeval
-    (-(regularLocalizationEvaluation k a
-      (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k a)
-        (regularEntry k a 1)) g) *
-      regularLocalizationEvaluation k a (regularCoordinateInverse k a) g) (P i j) *
-        regularLocalizationEvaluation k a (planeChartPullback k a (f j)) g) = _
-  rw [regularLocalizationEvaluation_algebraMap]
-  change (∑ j, Polynomial.aeval
-    (-(regularEntry k a 1).val g.val *
-      regularLocalizationEvaluation k a (regularCoordinateInverse k a) g) (P i j) *
-        regularLocalizationEvaluation k a (planeChartPullback k a (f j)) g) = _
-  simp only [regularEntry_apply, regularCoordinateInverse_evaluation,
-    planeChartPullback_evaluation, Matrix.mulVec, dotProduct, polynomialMatrixEval,
-    div_eq_mul_inv, neg_mul]
-
-noncomputable def associatedTorusValue (f : ι → planeCoordinateChart k 0)
-    (g : regularTorusPoints k) : ι → k :=
-  ρ (Multiplicative.ofAdd (-(g.val 0 1 / g.val 0 0)))
-    (fun j => planeChartEvaluation k 0 (f j) (regularToPlaneTorus k g))
-
-omit [Infinite k] in
-lemma associatedChartPair_local_compatible
-    (P : Matrix ι ι (Polynomial k))
-    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
-    (hf : ∀ x : planeTorusPoints k,
-      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
-        ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
-          (fun j => planeChartEvaluation k 0 (f₀ j) x)) (g : regularTorusPoints k) :
-    (fun i => regularLocalizationEvaluation k 1 (associatedLocalExpression k ι P 1 f₁ i) g) =
-      associatedTorusValue k ι ρ f₀ g := by
-  rw [associatedLocalExpression_evaluation k ι ρ P hP, hf,
-    ← additive_rep_apply_add]
-  unfold associatedTorusValue
-  congr 2
-  change -(g.val 1 1 / g.val 1 0) + (g.val 0 0 * g.val 1 0)⁻¹ =
-    -(g.val 0 1 / g.val 0 0)
-  have hd : g.val 0 0 * g.val 1 1 - g.val 0 1 * g.val 1 0 = 1 := by
-    simpa only [Matrix.det_fin_two] using g.val.property
-  field_simp [g.property 0, g.property 1]
-  linear_combination -hd
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma secondColumn_unipotent_mul (g : SL2 k) (t : k) (i : Fin 2) :
-    (g * unipotent k t) i 1 = g i 0 * t + g i 1 := by
-  change (((g : Matrix (Fin 2) (Fin 2) k) *
-    (unipotent k t : Matrix (Fin 2) (Fin 2) k)) i 1) = _
-  simp [Matrix.mul_apply, Fin.sum_univ_two, unipotent]
-
-noncomputable def regularTorusRightUnipotent (g : regularTorusPoints k) (t : k) :
-    regularTorusPoints k :=
-  ⟨g.val * unipotent k t, by intro i; rw [firstColumn_unipotent_mul]; exact g.property i⟩
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma associatedTorusValue_unipotent (f : ι → planeCoordinateChart k 0)
-    (g : regularTorusPoints k) (t : k) :
-    associatedTorusValue k ι ρ f (regularTorusRightUnipotent k g t) =
-      ρ (Multiplicative.ofAdd (-t)) (associatedTorusValue k ι ρ f g) := by
-  have hx : regularToPlaneTorus k (regularTorusRightUnipotent k g t) =
-      regularToPlaneTorus k g := by
-    apply Subtype.ext
-    funext i
-    exact firstColumn_unipotent_mul k g.val t i
-  unfold associatedTorusValue
-  rw [hx, ← additive_rep_apply_add]
-  apply congrArg (fun s : k => ρ (Multiplicative.ofAdd s)
-    (fun j => planeChartEvaluation k 0 (f j) (regularToPlaneTorus k g)))
-  change -((g.val * unipotent k t) 0 1 / (g.val * unipotent k t) 0 0) = _
-  rw [secondColumn_unipotent_mul, firstColumn_unipotent_mul]
-  field_simp [g.property 0]
-  ring
-
-noncomputable def regularVectorCombination (L : (ι → k) →ₗ[k] (ι → k))
-    (f : ι → regularSL2Functions k) (i : ι) : regularSL2Functions k :=
-  ∑ j, (LinearMap.toMatrix' L i j) • f j
-
-omit [Infinite k] in
-lemma regularVectorCombination_evaluation (L : (ι → k) →ₗ[k] (ι → k))
-    (f : ι → regularSL2Functions k) (g : SL2 k) :
-    regularVectorEvaluation k ι g (regularVectorCombination k ι L f) =
-      L (regularVectorEvaluation k ι g f) := by
-  rw [← LinearMap.toMatrix'_mulVec L]
-  funext i
-  change (Subalgebra.val (regularSL2Functions k)
-    (∑ j, (LinearMap.toMatrix' L i j) • f j)) g = _
-  simp only [map_sum, map_smul, Finset.sum_apply, Pi.smul_apply,
-    smul_eq_mul, Matrix.mulVec, dotProduct]
-  rfl
-
- 
-
-theorem associatedChartPair_glue
-    (P : Matrix ι ι (Polynomial k))
-    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
-    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
-    (hf : ∀ x : planeTorusPoints k,
-      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
-        ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
-          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
-    ∃ f : associatedSectionsSubmodule k ι ρ,
-      associatedXChart k ι ρ f = f₀ ∧ associatedYChart k ι ρ f = f₁ := by
-  have hg (i : ι) : ∃ f : regularSL2Functions k,
-      regularTorusRestriction k f = fun g => associatedTorusValue k ι ρ f₀ g i := by
-    apply regularTorus_glue k _ (associatedLocalExpression k ι P 0 f₀ i)
-      (associatedLocalExpression k ι P 1 f₁ i)
-    · funext g
-      exact congrFun (associatedLocalExpression_evaluation k ι ρ P hP 0 f₀ g) i
-    · funext g
-      exact congrFun (associatedChartPair_local_compatible k ι ρ P hP f₀ f₁ hf g) i
-  choose f hfg using hg
-  have hev (g : regularTorusPoints k) : regularVectorEvaluation k ι g.val f =
-      associatedTorusValue k ι ρ f₀ g := by
-    funext i
-    exact congrFun (hfg i) g
-  have hmem : f ∈ associatedSectionsSubmodule k ι ρ := by
-    intro g t
-    funext i
-    have hz : regularRightTranslation k (unipotent k t) (f i) -
-        regularVectorCombination k ι (ρ (Multiplicative.ofAdd (-t))) f i = 0 := by
-      apply regularSL2_torus_dense k
-      intro h ha hc
-      let h' : regularTorusPoints k := ⟨h, by intro j; fin_cases j; exact ha; exact hc⟩
-      have he := associatedTorusValue_unipotent k ι ρ f₀ h' t
-      rw [← hev, ← hev] at he
-      have he' := congrFun he i
-      change (f i).val (h * unipotent k t) = _ at he'
-      change (f i).val (h * unipotent k t) -
-        (regularVectorCombination k ι (ρ (Multiplicative.ofAdd (-t))) f i).val h = 0
-      rw [he']
-      exact sub_eq_zero.mpr
-        (congrFun (regularVectorCombination_evaluation k ι
-          (ρ (Multiplicative.ofAdd (-t))) f h) i).symm
-    have he := congrArg (fun a : regularSL2Functions k => a.val g) (sub_eq_zero.mp hz)
-    change (f i).val (g * unipotent k t) = _ at he
-    exact he.trans (congrFun (regularVectorCombination_evaluation k ι
-      (ρ (Multiplicative.ofAdd (-t))) f g) i)
-  let F : associatedSectionsSubmodule k ι ρ := ⟨f,hmem⟩
-  have hx : associatedXChart k ι ρ F = f₀ := by
-    funext i
-    apply planeChartEvaluation_injective k 0
-    funext x
-    have he := hev ⟨planeXSection k x, by
-      intro j
-      fin_cases j <;> simpa [planeXSection] using x.property _⟩
-    have hx' : regularToPlaneTorus k ⟨planeXSection k x, by
-        intro j; fin_cases j <;> simpa [planeXSection] using x.property _⟩ = x := by
-      apply Subtype.ext
-      funext j
-      fin_cases j <;> simp [regularToPlaneTorus, planeXSection]
-    unfold associatedTorusValue at he
-    rw [hx'] at he
-    change regularVectorEvaluation k ι (planeXSection k x) f =
-      ρ (Multiplicative.ofAdd (-(0 / x.val 0)))
-        (fun j => planeChartEvaluation k 0 (f₀ j) x) at he
-    simp only [zero_div, neg_zero] at he
-    change regularVectorEvaluation k ι (planeXSection k x) f =
-      ρ 1 (fun j => planeChartEvaluation k 0 (f₀ j) x) at he
-    rw [map_one] at he
-    exact (congrFun (associatedXChart_evaluation k ι ρ F x) i).trans (congrFun he i)
-  refine ⟨F,hx,?_⟩
-  funext i
-  apply planeChartEvaluation_injective k 1
-  funext x
-  have he := associatedCharts_transition k ι ρ F x
-  rw [hx, ← hf x] at he
-  exact congrFun he i
-
-end
-
-universe u
-variable (k : Type u) [Field k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-
-noncomputable instance regularPlaneAlgebra :
-    Algebra (MvPolynomial (Fin 2) k) (regularSL2Functions k) :=
-  (regularPlane k).toRingHom.toAlgebra
-
-instance regularPlaneScalarTower :
-    IsScalarTower k (MvPolynomial (Fin 2) k) (regularSL2Functions k) :=
-  IsScalarTower.of_algHom (regularPlane k)
-
-lemma regularPlane_algebraMap (P : MvPolynomial (Fin 2) k) :
-    algebraMap (MvPolynomial (Fin 2) k) (regularSL2Functions k) P = regularPlane k P := rfl
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma regularVector_plane_smul (P : MvPolynomial (Fin 2) k)
-    (f : ι → regularSL2Functions k) (g : SL2 k) :
-    regularVectorEvaluation k ι g (P • f) =
-      MvPolynomial.eval (fun i => g i 0) P • regularVectorEvaluation k ι g f := by
-  funext i
-  change (P • f i).val g = _
-  rw [Algebra.smul_def, regularPlane_algebraMap]
-  change (regularPlane k P).val g * (f i).val g = _
-  rw [regularPlane_evaluation]
-  rfl
-
-omit [Fintype ι] [DecidableEq ��] in
-lemma associatedSections_plane_smul_mem (P : MvPolynomial (Fin 2) k)
-    (f : ι → regularSL2Functions k) (hf : f ∈ associatedSectionsSubmodule k ι ρ) :
-    P • f ∈ associatedSectionsSubmodule k ι ρ := by
-  intro g t
-  rw [regularVector_plane_smul, regularVector_plane_smul, hf, map_smul]
-  simp only [firstColumn_unipotent_mul]
-
-noncomputable def associatedPolynomialSections :
-    Submodule (MvPolynomial (Fin 2) k) (ι → regularSL2Functions k) where
-  carrier := associatedSectionsSubmodule k ι ρ
-  zero_mem' := (associatedSectionsSubmodule k ι ρ).zero_mem
-  add_mem' := (associatedSectionsSubmodule k ι ρ).add_mem
-  smul_mem' := associatedSections_plane_smul_mem k ι ρ
-
-noncomputable instance associatedSectionsAddCommGroup :
-    AddCommGroup (associatedSectionsSubmodule k ι ρ) :=
-  Submodule.addCommGroup (associatedSectionsSubmodule k ι ρ)
-
-noncomputable instance (priority := 2000) associatedSectionsPolynomialSMul :
-    SMul (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
-  (Submodule.module (associatedPolynomialSections k ι ρ)).toSMul
-
-noncomputable instance (priority := 2000) associatedSectionsPolynomialModule :
-    Module (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
-  Submodule.module (associatedPolynomialSections k ι ρ)
-
-instance associatedSectionsScalarTower :
-    IsScalarTower k (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) where
-  smul_assoc a P f := Subtype.ext (smul_assoc a P f.val)
-
-variable [Infinite k]
-noncomputable def associatedXChartPolynomial :
-    (associatedSectionsSubmodule k ι ρ) →ₗ[MvPolynomial (Fin 2) k]
-      (ι → planeCoordinateChart k 0) where
-  toFun := associatedXChart k ι ρ
-  map_add' := (associatedXChart k ι ρ).map_add
-  map_smul' := by
-    intro P f
-    funext i
-    apply planeChartEvaluation_injective k 0
-    funext x
-    have he := congrFun (associatedXChart_evaluation k ι ρ (P • f) x) i
-    change _ = _ at he
-    rw [show (P • f).val = P • f.val from rfl, regularVector_plane_smul] at he
-    rw [he]
-    change MvPolynomial.eval (fun j => (planeXSection k x) j 0) P *
-      regularVectorEvaluation k ι (planeXSection k x) f.val i =
-      planeChartEvaluation k 0 (P • associatedXChart k ι ρ f i) x
-    rw [Algebra.smul_def, map_mul, planeChartEvaluation_algebraMap]
-    change _ = planeTorusEvaluation k P x *
-      planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x
-    rw [planeTorusEvaluation_apply, congrFun (associatedXChart_evaluation k ι ρ f x) i]
-    congr 2
-    apply congrArg MvPolynomial.eval
-    funext j
-    fin_cases j <;> simp [planeXSection]
-
-end FiberFunctorProof
-
- 
-
-open scoped TensorProduct
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.PlaneCharts
+
+namespace OAI
+
+/-! Polynomial additive actions and associated polynomial sections. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+variable {k A B : Type*} [CommRing k] [CommRing A] [CommRing B]
+    [Algebra k A] [Algebra k B]
+
+lemma map_aeval_polynomial (f : A →ₐ[k] B) (a : A) (p : Polynomial k) :
+    f (Polynomial.aeval a p) = Polynomial.aeval (f a) p := by
+  have h : f.comp (Polynomial.aeval a) = Polynomial.aeval (f a) := by
+    ext
+    simp
+  exact AlgHom.congr_fun h p
+end
+
+section
+variable {k ι : Type*} [Field k] [Infinite k] [Fintype ι] [DecidableEq ι]
+
+ 
+noncomputable def polynomialMatrixEval (P : Matrix ι ι (Polynomial k))
+    {A : Type*} [CommRing A] [Algebra k A] (t : A) : Matrix ι ι A :=
+  fun i j => Polynomial.aeval t (P i j)
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma polynomialMatrixEval_map (P : Matrix ι ι (Polynomial k))
+    {A B : Type*} [CommRing A] [CommRing B] [Algebra k A] [Algebra k B]
+    (f : A →ₐ[k] B) (t : A) :
+    (polynomialMatrixEval P t).map f = polynomialMatrixEval P (f t) := by
+  ext i j
+  exact map_aeval_polynomial f t (P i j)
+
+omit [DecidableEq ι] in
+ 
+
+theorem polynomialMatrixEval_add (P : Matrix ι ι (Polynomial k))
+    (hP : ∀ s t : k, polynomialMatrixEval P (s+t) =
+      polynomialMatrixEval P s * polynomialMatrixEval P t)
+    {A : Type*} [CommRing A] [Algebra k A] (s t : A) :
+    polynomialMatrixEval P (s+t) = polynomialMatrixEval P s * polynomialMatrixEval P t := by
+  let X : Fin 2 → MvPolynomial (Fin 2) k := MvPolynomial.X
+  have h : polynomialMatrixEval P (X 0 + X 1) =
+      polynomialMatrixEval P (X 0) * polynomialMatrixEval P (X 1) := by
+    apply Matrix.ext
+    intro i j
+    apply MvPolynomial.funext
+    intro a
+    change MvPolynomial.aeval a _ = MvPolynomial.aeval a _
+    simp only [polynomialMatrixEval, Matrix.mul_apply, map_sum, map_mul,
+      map_aeval_polynomial, map_add, X, MvPolynomial.aeval_X]
+    exact congrArg (fun Q : Matrix ι ι k => Q i j) (hP (a 0) (a 1))
+  have he := congrArg (fun Q : Matrix ι ι (MvPolynomial (Fin 2) k) =>
+    Q.map (MvPolynomial.aeval ![s,t])) h
+  simpa only [polynomialMatrixEval_map, map_add, X, MvPolynomial.aeval_X,
+    Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.map_mul] using he
+
+omit [Infinite k] [Fintype ι] in
+lemma polynomialMatrixEval_zero (P : Matrix ι ι (Polynomial k))
+    (hP : polynomialMatrixEval P (0 : k) = 1)
+    (A : Type*) [CommRing A] [Algebra k A] :
+    polynomialMatrixEval P (0 : A) = 1 := by
+  have he := congrArg (fun Q : Matrix ι ι k => Q.map (algebraMap k A)) hP
+  have hm (i j : ι) : algebraMap k A (polynomialMatrixEval P (0 : k) i j) =
+      polynomialMatrixEval P (0 : A) i j := by
+    simp [polynomialMatrixEval, Polynomial.aeval_def]
+  apply Matrix.ext
+  intro i j
+  have heij := congrArg (fun Q : Matrix ι ι A => Q i j) he
+  rw [Matrix.map_apply, hm] at heij
+  simpa [Matrix.map_apply, Matrix.one_apply] using heij
+
+ 
+
+noncomputable def polynomialAdditiveRepresentation
+    (P : Matrix ι ι (Polynomial k))
+    (h0 : polynomialMatrixEval P (0 : k) = 1)
+    (hadd : ∀ s t : k, polynomialMatrixEval P (s+t) =
+      polynomialMatrixEval P s * polynomialMatrixEval P t)
+    (A : Type*) [CommRing A] [Algebra k A] :
+    Multiplicative A →* Matrix ι ι A where
+  toFun t := polynomialMatrixEval P t.toAdd
+  map_one' := polynomialMatrixEval_zero P h0 A
+  map_mul' s t := polynomialMatrixEval_add P hadd s.toAdd t.toAdd
+
+end
+
+section
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma additive_rep_apply_add (s t : k) (v : ι → k) :
+    ρ (Multiplicative.ofAdd (s+t)) v =
+      ρ (Multiplicative.ofAdd s) (ρ (Multiplicative.ofAdd t) v) := by
+  change ρ (Multiplicative.ofAdd s * Multiplicative.ofAdd t) v = _
+  rw [map_mul]
+  rfl
+
+noncomputable def associatedLocalExpression (P : Matrix ι ι (Polynomial k))
+    (a : Fin 2) (f : ι → planeCoordinateChart k a) (i : ι) :
+    regularCoordinateLocalization k a :=
+  ∑ j, Polynomial.aeval
+    (-(algebraMap (regularSL2Functions k) (regularCoordinateLocalization k a)
+      (regularEntry k a 1)) * regularCoordinateInverse k a) (P i j) *
+        planeChartPullback k a (f j)
+
+omit [Infinite k] in
+lemma associatedLocalExpression_evaluation (P : Matrix ι ι (Polynomial k))
+    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+    (a : Fin 2) (f : ι → planeCoordinateChart k a) (g : regularTorusPoints k) :
+    (fun i => regularLocalizationEvaluation k a (associatedLocalExpression k ι P a f i) g) =
+      ρ (Multiplicative.ofAdd (-(g.val a 1 / g.val a 0)))
+        (fun j => planeChartEvaluation k a (f j) (regularToPlaneTorus k g)) := by
+  have h := LinearMap.toMatrix'_mulVec
+    (ρ (Multiplicative.ofAdd (-(g.val a 1 / g.val a 0))))
+    (fun j => planeChartEvaluation k a (f j) (regularToPlaneTorus k g))
+  rw [← hP] at h
+  rw [← h]
+  funext i
+  let ev : regularCoordinateLocalization k a →ₐ[k] k :=
+    (Pi.evalAlgHom k _ g).comp (regularLocalizationEvaluation k a)
+  change ev (associatedLocalExpression k ι P a f i) = _
+  simp only [associatedLocalExpression, map_sum, map_mul,
+    map_aeval_polynomial (k := k) (A := regularCoordinateLocalization k a) (B := k) ev,
+    map_neg]
+  change (∑ j, Polynomial.aeval
+    (-(regularLocalizationEvaluation k a
+      (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k a)
+        (regularEntry k a 1)) g) *
+      regularLocalizationEvaluation k a (regularCoordinateInverse k a) g) (P i j) *
+        regularLocalizationEvaluation k a (planeChartPullback k a (f j)) g) = _
+  rw [regularLocalizationEvaluation_algebraMap]
+  change (∑ j, Polynomial.aeval
+    (-(regularEntry k a 1).val g.val *
+      regularLocalizationEvaluation k a (regularCoordinateInverse k a) g) (P i j) *
+        regularLocalizationEvaluation k a (planeChartPullback k a (f j)) g) = _
+  simp only [regularEntry_apply, regularCoordinateInverse_evaluation,
+    planeChartPullback_evaluation, Matrix.mulVec, dotProduct, polynomialMatrixEval,
+    div_eq_mul_inv, neg_mul]
+
+noncomputable def associatedTorusValue (f : ι → planeCoordinateChart k 0)
+    (g : regularTorusPoints k) : ι → k :=
+  ρ (Multiplicative.ofAdd (-(g.val 0 1 / g.val 0 0)))
+    (fun j => planeChartEvaluation k 0 (f j) (regularToPlaneTorus k g))
+
+omit [Infinite k] in
+lemma associatedChartPair_local_compatible
+    (P : Matrix ι ι (Polynomial k))
+    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
+    (hf : ∀ x : planeTorusPoints k,
+      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
+        ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
+          (fun j => planeChartEvaluation k 0 (f₀ j) x)) (g : regularTorusPoints k) :
+    (fun i => regularLocalizationEvaluation k 1 (associatedLocalExpression k ι P 1 f₁ i) g) =
+      associatedTorusValue k ι ρ f₀ g := by
+  rw [associatedLocalExpression_evaluation k ι ρ P hP, hf,
+    ← additive_rep_apply_add]
+  unfold associatedTorusValue
+  congr 2
+  change -(g.val 1 1 / g.val 1 0) + (g.val 0 0 * g.val 1 0)⁻¹ =
+    -(g.val 0 1 / g.val 0 0)
+  have hd : g.val 0 0 * g.val 1 1 - g.val 0 1 * g.val 1 0 = 1 := by
+    simpa only [Matrix.det_fin_two] using g.val.property
+  field_simp [g.property 0, g.property 1]
+  linear_combination -hd
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma secondColumn_unipotent_mul (g : SL2 k) (t : k) (i : Fin 2) :
+    (g * unipotent k t) i 1 = g i 0 * t + g i 1 := by
+  change (((g : Matrix (Fin 2) (Fin 2) k) *
+    (unipotent k t : Matrix (Fin 2) (Fin 2) k)) i 1) = _
+  simp [Matrix.mul_apply, Fin.sum_univ_two, unipotent]
+
+noncomputable def regularTorusRightUnipotent (g : regularTorusPoints k) (t : k) :
+    regularTorusPoints k :=
+  ⟨g.val * unipotent k t, by intro i; rw [firstColumn_unipotent_mul]; exact g.property i⟩
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma associatedTorusValue_unipotent (f : ι → planeCoordinateChart k 0)
+    (g : regularTorusPoints k) (t : k) :
+    associatedTorusValue k ι ρ f (regularTorusRightUnipotent k g t) =
+      ρ (Multiplicative.ofAdd (-t)) (associatedTorusValue k ι ρ f g) := by
+  have hx : regularToPlaneTorus k (regularTorusRightUnipotent k g t) =
+      regularToPlaneTorus k g := by
+    apply Subtype.ext
+    funext i
+    exact firstColumn_unipotent_mul k g.val t i
+  unfold associatedTorusValue
+  rw [hx, ← additive_rep_apply_add]
+  apply congrArg (fun s : k => ρ (Multiplicative.ofAdd s)
+    (fun j => planeChartEvaluation k 0 (f j) (regularToPlaneTorus k g)))
+  change -((g.val * unipotent k t) 0 1 / (g.val * unipotent k t) 0 0) = _
+  rw [secondColumn_unipotent_mul, firstColumn_unipotent_mul]
+  field_simp [g.property 0]
+  ring
+
+noncomputable def regularVectorCombination (L : (ι → k) →ₗ[k] (ι → k))
+    (f : ι → regularSL2Functions k) (i : ι) : regularSL2Functions k :=
+  ∑ j, (LinearMap.toMatrix' L i j) • f j
+
+omit [Infinite k] in
+lemma regularVectorCombination_evaluation (L : (ι → k) →ₗ[k] (ι → k))
+    (f : ι → regularSL2Functions k) (g : SL2 k) :
+    regularVectorEvaluation k ι g (regularVectorCombination k ι L f) =
+      L (regularVectorEvaluation k ι g f) := by
+  rw [← LinearMap.toMatrix'_mulVec L]
+  funext i
+  change (Subalgebra.val (regularSL2Functions k)
+    (∑ j, (LinearMap.toMatrix' L i j) • f j)) g = _
+  simp only [map_sum, map_smul, Finset.sum_apply, Pi.smul_apply,
+    smul_eq_mul, Matrix.mulVec, dotProduct]
+  rfl
+
+ 
+
+theorem associatedChartPair_glue
+    (P : Matrix ι ι (Polynomial k))
+    (hP : ∀ t : k, polynomialMatrixEval P t = LinearMap.toMatrix' (ρ (Multiplicative.ofAdd t)))
+    (f₀ : ι → planeCoordinateChart k 0) (f₁ : ι → planeCoordinateChart k 1)
+    (hf : ∀ x : planeTorusPoints k,
+      (fun j => planeChartEvaluation k 1 (f₁ j) x) =
+        ρ (Multiplicative.ofAdd ((x.val 0 * x.val 1)⁻¹))
+          (fun j => planeChartEvaluation k 0 (f₀ j) x)) :
+    ∃ f : associatedSectionsSubmodule k ι ρ,
+      associatedXChart k ι ρ f = f₀ ∧ associatedYChart k ι ρ f = f₁ := by
+  have hg (i : ι) : ∃ f : regularSL2Functions k,
+      regularTorusRestriction k f = fun g => associatedTorusValue k ι ρ f₀ g i := by
+    apply regularTorus_glue k _ (associatedLocalExpression k ι P 0 f₀ i)
+      (associatedLocalExpression k ι P 1 f₁ i)
+    · funext g
+      exact congrFun (associatedLocalExpression_evaluation k ι ρ P hP 0 f₀ g) i
+    · funext g
+      exact congrFun (associatedChartPair_local_compatible k ι ρ P hP f₀ f₁ hf g) i
+  choose f hfg using hg
+  have hev (g : regularTorusPoints k) : regularVectorEvaluation k ι g.val f =
+      associatedTorusValue k ι ρ f₀ g := by
+    funext i
+    exact congrFun (hfg i) g
+  have hmem : f ∈ associatedSectionsSubmodule k ι ρ := by
+    intro g t
+    funext i
+    have hz : regularRightTranslation k (unipotent k t) (f i) -
+        regularVectorCombination k ι (ρ (Multiplicative.ofAdd (-t))) f i = 0 := by
+      apply regularSL2_torus_dense k
+      intro h ha hc
+      let h' : regularTorusPoints k := ⟨h, by intro j; fin_cases j; exact ha; exact hc⟩
+      have he := associatedTorusValue_unipotent k ι ρ f₀ h' t
+      rw [← hev, ← hev] at he
+      have he' := congrFun he i
+      change (f i).val (h * unipotent k t) = _ at he'
+      change (f i).val (h * unipotent k t) -
+        (regularVectorCombination k ι (ρ (Multiplicative.ofAdd (-t))) f i).val h = 0
+      rw [he']
+      exact sub_eq_zero.mpr
+        (congrFun (regularVectorCombination_evaluation k ι
+          (ρ (Multiplicative.ofAdd (-t))) f h) i).symm
+    have he := congrArg (fun a : regularSL2Functions k => a.val g) (sub_eq_zero.mp hz)
+    change (f i).val (g * unipotent k t) = _ at he
+    exact he.trans (congrFun (regularVectorCombination_evaluation k ι
+      (ρ (Multiplicative.ofAdd (-t))) f g) i)
+  let F : associatedSectionsSubmodule k ι ρ := ⟨f,hmem⟩
+  have hx : associatedXChart k ι ρ F = f₀ := by
+    funext i
+    apply planeChartEvaluation_injective k 0
+    funext x
+    have he := hev ⟨planeXSection k x, by
+      intro j
+      fin_cases j <;> simpa [planeXSection] using x.property _⟩
+    have hx' : regularToPlaneTorus k ⟨planeXSection k x, by
+        intro j; fin_cases j <;> simpa [planeXSection] using x.property _⟩ = x := by
+      apply Subtype.ext
+      funext j
+      fin_cases j <;> simp [regularToPlaneTorus, planeXSection]
+    unfold associatedTorusValue at he
+    rw [hx'] at he
+    change regularVectorEvaluation k ι (planeXSection k x) f =
+      ρ (Multiplicative.ofAdd (-(0 / x.val 0)))
+        (fun j => planeChartEvaluation k 0 (f₀ j) x) at he
+    simp only [zero_div, neg_zero] at he
+    change regularVectorEvaluation k ι (planeXSection k x) f =
+      ρ 1 (fun j => planeChartEvaluation k 0 (f₀ j) x) at he
+    rw [map_one] at he
+    exact (congrFun (associatedXChart_evaluation k ι ρ F x) i).trans (congrFun he i)
+  refine ⟨F,hx,?_⟩
+  funext i
+  apply planeChartEvaluation_injective k 1
+  funext x
+  have he := associatedCharts_transition k ι ρ F x
+  rw [hx, ← hf x] at he
+  exact congrFun he i
+
+end
+
+universe u
+variable (k : Type u) [Field k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+
+noncomputable instance regularPlaneAlgebra :
+    Algebra (MvPolynomial (Fin 2) k) (regularSL2Functions k) :=
+  (regularPlane k).toRingHom.toAlgebra
+
+instance regularPlaneScalarTower :
+    IsScalarTower k (MvPolynomial (Fin 2) k) (regularSL2Functions k) :=
+  IsScalarTower.of_algHom (regularPlane k)
+
+lemma regularPlane_algebraMap (P : MvPolynomial (Fin 2) k) :
+    algebraMap (MvPolynomial (Fin 2) k) (regularSL2Functions k) P = regularPlane k P := rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma regularVector_plane_smul (P : MvPolynomial (Fin 2) k)
+    (f : ι → regularSL2Functions k) (g : SL2 k) :
+    regularVectorEvaluation k ι g (P • f) =
+      MvPolynomial.eval (fun i => g i 0) P • regularVectorEvaluation k ι g f := by
+  funext i
+  change (P • f i).val g = _
+  rw [Algebra.smul_def, regularPlane_algebraMap]
+  change (regularPlane k P).val g * (f i).val g = _
+  rw [regularPlane_evaluation]
+  rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedSections_plane_smul_mem (P : MvPolynomial (Fin 2) k)
+    (f : ι → regularSL2Functions k) (hf : f ∈ associatedSectionsSubmodule k ι ρ) :
+    P • f ∈ associatedSectionsSubmodule k ι ρ := by
+  intro g t
+  rw [regularVector_plane_smul, regularVector_plane_smul, hf, map_smul]
+  simp only [firstColumn_unipotent_mul]
+
+noncomputable def associatedPolynomialSections :
+    Submodule (MvPolynomial (Fin 2) k) (ι → regularSL2Functions k) where
+  carrier := associatedSectionsSubmodule k ι ρ
+  zero_mem' := (associatedSectionsSubmodule k ι ρ).zero_mem
+  add_mem' := (associatedSectionsSubmodule k ι ρ).add_mem
+  smul_mem' := associatedSections_plane_smul_mem k ι ρ
+
+noncomputable instance associatedSectionsAddCommGroup :
+    AddCommGroup (associatedSectionsSubmodule k ι ρ) :=
+  Submodule.addCommGroup (associatedSectionsSubmodule k ι ρ)
+
+noncomputable instance (priority := 2000) associatedSectionsPolynomialSMul :
+    SMul (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
+  (Submodule.module (associatedPolynomialSections k ι ρ)).toSMul
+
+noncomputable instance (priority := 2000) associatedSectionsPolynomialModule :
+    Module (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) :=
+  Submodule.module (associatedPolynomialSections k ι ρ)
+
+instance associatedSectionsScalarTower :
+    IsScalarTower k (MvPolynomial (Fin 2) k) (associatedSectionsSubmodule k ι ρ) where
+  smul_assoc a P f := Subtype.ext (smul_assoc a P f.val)
+
+variable [Infinite k]
+noncomputable def associatedXChartPolynomial :
+    (associatedSectionsSubmodule k ι ρ) →ₗ[MvPolynomial (Fin 2) k]
+      (ι → planeCoordinateChart k 0) where
+  toFun := associatedXChart k ι ρ
+  map_add' := (associatedXChart k ι ρ).map_add
+  map_smul' := by
+    intro P f
+    funext i
+    apply planeChartEvaluation_injective k 0
+    funext x
+    have he := congrFun (associatedXChart_evaluation k ι ρ (P • f) x) i
+    change _ = _ at he
+    rw [show (P • f).val = P • f.val from rfl, regularVector_plane_smul] at he
+    rw [he]
+    change MvPolynomial.eval (fun j => (planeXSection k x) j 0) P *
+      regularVectorEvaluation k ι (planeXSection k x) f.val i =
+      planeChartEvaluation k 0 (P • associatedXChart k ι ρ f i) x
+    rw [Algebra.smul_def, map_mul, planeChartEvaluation_algebraMap]
+    change _ = planeTorusEvaluation k P x *
+      planeChartEvaluation k 0 (associatedXChart k ι ρ f i) x
+    rw [planeTorusEvaluation_apply, congrFun (associatedXChart_evaluation k ι ρ f x) i]
+    congr 2
+    apply congrArg MvPolynomial.eval
+    funext j
+    fin_cases j <;> simp [planeXSection]
+
+end FiberFunctorProof
+
+ 
+
+open scoped TensorProduct
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PolynomialCovers.lean

@@ -1,78 +1,78 @@
-import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
-import OAI.RepresentationTheory.RestrictedTilting.TensorWeights
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-
-lemma costandard_zero_tilting : IsTilting k (costandard k 0) :=
-  costandard_tilting_of_choose_ne_zero k 0 (by intro i; fin_cases i; norm_num)
-lemma costandard_one_tilting : IsTilting k (costandard k 1) :=
-  costandard_tilting_of_choose_ne_zero k 1 (by intro i; fin_cases i <;> norm_num)
-
-noncomputable def tensorPowerFrom (A : FDRep k (SL2 k)) : ℕ → FDRep k (SL2 k)
-  | 0 => A
-  | n+1 => tensorPowerFrom A n ⊗ costandard k 1
-
-noncomputable def polynomialPowerMap (m : ℕ) : ∀ n,
-    tensorPowerFrom k (costandard k m) n ⟶ costandard k (m+n)
-  | 0 => 𝟙 _
-  | n+1 => (tensorRight (costandard k 1)).map (polynomialPowerMap m n) ≫
-      costandardMultiply k (m+n) 1
-
-omit [Infinite k] in
-lemma polynomialPowerMap_goodKernel (m n : ℕ) :
-    HasGoodKernel k (polynomialPowerMap k m n) := by
-  induction n with
-  | zero => exact HasGoodKernel.id k _
-  | succ n ih =>
-    exact (ih.tensor_right k _ (costandard_hasGoodFiltration k 1)).comp k
-      (costandardMultiply_goodKernel k (m+n) 1)
-
-lemma tensorPowerFrom_tilting {A : FDRep k (SL2 k)} (hA : IsTilting k A) (n : ℕ) :
-    IsTilting k (tensorPowerFrom k A n) := by
-  induction n with
-  | zero => exact hA
-  | succ n ih => exact ih.tensor k (costandard_one_tilting k)
-
-omit [Infinite k] in
-lemma tensorPowerFrom_rational {A : FDRep k (SL2 k)}
-    (hA : IsRational k A.ρ) (n : ℕ) : IsRational k (tensorPowerFrom k A n).ρ := by
-  induction n with
-  | zero => exact hA
-  | succ n ih =>
-    exact IsRational.tensor k (tensorPowerFrom k A n).ρ (costandard k 1).ρ ih
-      (costandard_rational k 1)
-
-lemma tensorPowerFrom_weights {A : FDRep k (SL2 k)}
-    (hA : IsRational k A.ρ) (a : ℕ) (ha : HasWeightsBetween A.ρ (-(a : ℤ)) a) (n : ℕ) :
-    HasWeightsBetween (tensorPowerFrom k A n).ρ (-((a+n : ℕ) : ℤ)) (a+n) := by
-  induction n with
-  | zero =>
-    change HasWeightsBetween A.ρ (-((a+0 : ℕ) : ℤ)) (a+0)
-    simpa only [Nat.add_zero, add_zero] using ha
-  | succ n ih =>
-    exact hasWeightsBetween_tensor (tensorPowerFrom k A n).ρ (costandard k 1).ρ
-      (tensorPowerFrom_rational k hA n) (costandard_rational k 1) (a+n) 1 ih
-      (fun m v hm hv => costandard_weight_bound k 1 m hm v hv)
-
- 
-
-omit [Infinite k] in
-lemma tensorPowerFrom_factor (m n : ℕ) :
-    Nonempty (tensorPowerFrom k (costandard k m) n ≅
-      costandard k m ⊗ tensorPowerFrom k (costandard k 0) n) := by
-  induction n with
-  | zero =>
-    have := costandardMultiply_isIso_of_zero k m 0 (Or.inr rfl)
-    exact ⟨(asIso (costandardMultiply k m 0)).symm⟩
-  | succ n ih =>
-    obtain ⟨e⟩ := ih
-    exact ⟨(tensorRight (costandard k 1)).mapIso e ≪≫
-      α_ (costandard k m) (tensorPowerFrom k (costandard k 0) n) (costandard k 1)⟩
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.GoodKernel
+import OAI.RepresentationTheory.RestrictedTilting.TensorWeights
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+
+lemma costandard_zero_tilting : IsTilting k (costandard k 0) :=
+  costandard_tilting_of_choose_ne_zero k 0 (by intro i; fin_cases i; norm_num)
+lemma costandard_one_tilting : IsTilting k (costandard k 1) :=
+  costandard_tilting_of_choose_ne_zero k 1 (by intro i; fin_cases i <;> norm_num)
+
+noncomputable def tensorPowerFrom (A : FDRep k (SL2 k)) : ℕ → FDRep k (SL2 k)
+  | 0 => A
+  | n+1 => tensorPowerFrom A n ⊗ costandard k 1
+
+noncomputable def polynomialPowerMap (m : ℕ) : ∀ n,
+    tensorPowerFrom k (costandard k m) n ⟶ costandard k (m+n)
+  | 0 => 𝟙 _
+  | n+1 => (tensorRight (costandard k 1)).map (polynomialPowerMap m n) ≫
+      costandardMultiply k (m+n) 1
+
+omit [Infinite k] in
+lemma polynomialPowerMap_goodKernel (m n : ℕ) :
+    HasGoodKernel k (polynomialPowerMap k m n) := by
+  induction n with
+  | zero => exact HasGoodKernel.id k _
+  | succ n ih =>
+    exact (ih.tensor_right k _ (costandard_hasGoodFiltration k 1)).comp k
+      (costandardMultiply_goodKernel k (m+n) 1)
+
+lemma tensorPowerFrom_tilting {A : FDRep k (SL2 k)} (hA : IsTilting k A) (n : ℕ) :
+    IsTilting k (tensorPowerFrom k A n) := by
+  induction n with
+  | zero => exact hA
+  | succ n ih => exact ih.tensor k (costandard_one_tilting k)
+
+omit [Infinite k] in
+lemma tensorPowerFrom_rational {A : FDRep k (SL2 k)}
+    (hA : IsRational k A.ρ) (n : ℕ) : IsRational k (tensorPowerFrom k A n).ρ := by
+  induction n with
+  | zero => exact hA
+  | succ n ih =>
+    exact IsRational.tensor k (tensorPowerFrom k A n).ρ (costandard k 1).ρ ih
+      (costandard_rational k 1)
+
+lemma tensorPowerFrom_weights {A : FDRep k (SL2 k)}
+    (hA : IsRational k A.ρ) (a : ℕ) (ha : HasWeightsBetween A.ρ (-(a : ℤ)) a) (n : ℕ) :
+    HasWeightsBetween (tensorPowerFrom k A n).ρ (-((a+n : ℕ) : ℤ)) (a+n) := by
+  induction n with
+  | zero =>
+    change HasWeightsBetween A.ρ (-((a+0 : ℕ) : ℤ)) (a+0)
+    simpa only [Nat.add_zero, add_zero] using ha
+  | succ n ih =>
+    exact hasWeightsBetween_tensor (tensorPowerFrom k A n).ρ (costandard k 1).ρ
+      (tensorPowerFrom_rational k hA n) (costandard_rational k 1) (a+n) 1 ih
+      (fun m v hm hv => costandard_weight_bound k 1 m hm v hv)
+
+ 
+
+omit [Infinite k] in
+lemma tensorPowerFrom_factor (m n : ℕ) :
+    Nonempty (tensorPowerFrom k (costandard k m) n ≅
+      costandard k m ⊗ tensorPowerFrom k (costandard k 0) n) := by
+  induction n with
+  | zero =>
+    have := costandardMultiply_isIso_of_zero k m 0 (Or.inr rfl)
+    exact ⟨(asIso (costandardMultiply k m 0)).symm⟩
+  | succ n ih =>
+    obtain ⟨e⟩ := ih
+    exact ⟨(tensorRight (costandard k 1)).mapIso e ≪≫
+      α_ (costandard k m) (tensorPowerFrom k (costandard k 0) n) (costandard k 1)⟩
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PolynomialIntertwiner.lean

@@ -1,58 +1,58 @@
-import OAI.RepresentationTheory.RestrictedTilting.RationalMatrices
-import OAI.RepresentationTheory.RestrictedTilting.LaurentPolynomialSeparation
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators
-section
-variable {k K ι : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
-  [Fintype ι] [DecidableEq ι]
-
-omit [Infinite k] [Fintype ι] [DecidableEq ι] in
-lemma polynomialMatrixEval_base (P : Matrix ι ι (Polynomial k)) (t : k) :
-    polynomialMatrixEval P (algebraMap k K t) =
-      (polynomialMatrixEval P t).map (algebraMap k K) :=
-  (polynomialMatrixEval_map P (Algebra.ofId k K) t).symm
-
-omit [DecidableEq ι] in
-lemma polynomial_intertwiner_extension (P B : Matrix ι ι (Polynomial k))
-    (C : Matrix ι ι K) (z : K)
-    (h : ∀ t : k, C * polynomialMatrixEval B (algebraMap k K t) =
-      polynomialMatrixEval P (algebraMap k K t * z) * C) :
-    ∀ t : K, C * polynomialMatrixEval B t = polynomialMatrixEval P (t*z) * C := by
-  let CP : Matrix ι ι (Polynomial K) := C.map Polynomial.C
-  let BP := polynomialMatrixEval B (Polynomial.X : Polynomial K)
-  let PP := polynomialMatrixEval P (Polynomial.X * Polynomial.C z)
-  let ev (t : K) : Polynomial K →ₐ[k] K := (Polynomial.aeval t).restrictScalars k
-  have heC (t : K) : CP.map (ev t) = C := by
-    apply Matrix.ext
-    intro i j
-    exact Polynomial.aeval_C t (C i j)
-  have heB (t : K) : BP.map (ev t) = polynomialMatrixEval B t := by
-    rw [polynomialMatrixEval_map]
-    congr 1
-    exact Polynomial.aeval_X t
-  have heP (t : K) : PP.map (ev t) = polynomialMatrixEval P (t*z) := by
-    rw [polynomialMatrixEval_map]
-    congr 1
-    change Polynomial.aeval t (Polynomial.X * Polynomial.C z) = t*z
-    rw [map_mul, Polynomial.aeval_X, Polynomial.aeval_C]
-    rfl
-  have hid : CP * BP = PP * CP := by
-    apply Matrix.ext
-    intro i j
-    apply polynomial_eq_of_base_evals (k := k)
-    intro t
-    have hM : (CP * BP).map (ev (algebraMap k K t)) =
-        (PP*CP).map (ev (algebraMap k K t)) := by
-      rw [Matrix.map_mul, Matrix.map_mul, heC, heB, heP]
-      exact h t
-    exact congrArg (fun A : Matrix ι ι K => A i j) hM
-  intro t
-  have he := congrArg (fun A : Matrix ι ι (Polynomial K) => A.map (ev t)) hid
-  simpa only [Matrix.map_mul, heC, heB, heP] using he
-end
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.RationalMatrices
+import OAI.RepresentationTheory.RestrictedTilting.LaurentPolynomialSeparation
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators
+section
+variable {k K ι : Type*} [Field k] [Infinite k] [Field K] [Algebra k K]
+  [Fintype ι] [DecidableEq ι]
+
+omit [Infinite k] [Fintype ι] [DecidableEq ι] in
+lemma polynomialMatrixEval_base (P : Matrix ι ι (Polynomial k)) (t : k) :
+    polynomialMatrixEval P (algebraMap k K t) =
+      (polynomialMatrixEval P t).map (algebraMap k K) :=
+  (polynomialMatrixEval_map P (Algebra.ofId k K) t).symm
+
+omit [DecidableEq ι] in
+lemma polynomial_intertwiner_extension (P B : Matrix ι ι (Polynomial k))
+    (C : Matrix ι ι K) (z : K)
+    (h : ∀ t : k, C * polynomialMatrixEval B (algebraMap k K t) =
+      polynomialMatrixEval P (algebraMap k K t * z) * C) :
+    ∀ t : K, C * polynomialMatrixEval B t = polynomialMatrixEval P (t*z) * C := by
+  let CP : Matrix ι ι (Polynomial K) := C.map Polynomial.C
+  let BP := polynomialMatrixEval B (Polynomial.X : Polynomial K)
+  let PP := polynomialMatrixEval P (Polynomial.X * Polynomial.C z)
+  let ev (t : K) : Polynomial K →ₐ[k] K := (Polynomial.aeval t).restrictScalars k
+  have heC (t : K) : CP.map (ev t) = C := by
+    apply Matrix.ext
+    intro i j
+    exact Polynomial.aeval_C t (C i j)
+  have heB (t : K) : BP.map (ev t) = polynomialMatrixEval B t := by
+    rw [polynomialMatrixEval_map]
+    congr 1
+    exact Polynomial.aeval_X t
+  have heP (t : K) : PP.map (ev t) = polynomialMatrixEval P (t*z) := by
+    rw [polynomialMatrixEval_map]
+    congr 1
+    change Polynomial.aeval t (Polynomial.X * Polynomial.C z) = t*z
+    rw [map_mul, Polynomial.aeval_X, Polynomial.aeval_C]
+    rfl
+  have hid : CP * BP = PP * CP := by
+    apply Matrix.ext
+    intro i j
+    apply polynomial_eq_of_base_evals (k := k)
+    intro t
+    have hM : (CP * BP).map (ev (algebraMap k K t)) =
+        (PP*CP).map (ev (algebraMap k K t)) := by
+      rw [Matrix.map_mul, Matrix.map_mul, heC, heB, heP]
+      exact h t
+    exact congrArg (fun A : Matrix ι ι K => A i j) hM
+  intro t
+  have he := congrArg (fun A : Matrix ι ι (Polynomial K) => A.map (ev t)) hid
+  simpa only [Matrix.map_mul, heC, heB, heP] using he
+end
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/PolynomialJets.lean

@@ -1,109 +1,109 @@
-import OAI.RepresentationTheory.RestrictedTilting.JetTriviality
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped TensorProduct
-universe u
-variable {k : Type u} [Field k]
-variable {T N : Type u} [AddCommGroup T] [Module k T]
-  [AddCommGroup N] [Module k N]
-  [Module (MvPolynomial (Fin 2) k) N] [IsScalarTower k (MvPolynomial (Fin 2) k) N]
-
-noncomputable def polynomialExtend (L : T →ₗ[k] N) :
-    (MvPolynomial (Fin 2) k) ⊗[k] T →ₗ[MvPolynomial (Fin 2) k] N :=
-  TensorProduct.AlgebraTensorModule.lift
-    (LinearMap.toSpanSingleton (MvPolynomial (Fin 2) k) (T →ₗ[k] N) L)
-
-@[simp] lemma polynomialExtend_tmul (L : T →ₗ[k] N)
-    (P : MvPolynomial (Fin 2) k) (t : T) :
-    polynomialExtend L (P ⊗ₜ[k] t) = P • L t := rfl
-
-noncomputable def polynomialAugment : (MvPolynomial (Fin 2) k) ⊗[k] T →ₗ[k] T :=
-  (TensorProduct.lid k T).toLinearMap ∘ₗ TensorProduct.map
-    ({ toFun := MvPolynomial.constantCoeff
-       map_add' := map_add _
-       map_smul' := MvPolynomial.constantCoeff_smul } : MvPolynomial (Fin 2) k →ₗ[k] k)
-    LinearMap.id
-
-@[simp] lemma polynomialAugment_tmul (P : MvPolynomial (Fin 2) k) (t : T) :
-    polynomialAugment (P ⊗ₜ[k] t) = MvPolynomial.constantCoeff P • t := rfl
-
-lemma polynomialAugment_smul (P : MvPolynomial (Fin 2) k)
-    (z : (MvPolynomial (Fin 2) k) ⊗[k] T) :
-    polynomialAugment (P • z) = MvPolynomial.constantCoeff P • polynomialAugment z := by
-  induction z using TensorProduct.inductionOn with
-  | tmul Q t => rw [TensorProduct.smul_tmul', polynomialAugment_tmul]; simp [smul_eq_mul, mul_smul]
-  | add z w hz hw => simp [smul_add, hz, hw]
-
-lemma polynomialAugment_pairRelation
-    (z : (MvPolynomial (Fin 2) k) ⊗[k] T)
-    (hz : z ∈ pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)) :
-    polynomialAugment z = 0 := by
-  obtain ⟨a,b,rfl⟩ := (mem_pairRelation _ _ z).mp hz
-  simp [polynomialAugment_smul]
-
-lemma polynomial_origin_representative (z : (MvPolynomial (Fin 2) k) ⊗[k] T) :
-    z - (1 : MvPolynomial (Fin 2) k) ⊗ₜ[k] polynomialAugment z ∈
-      pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) := by
-  let Q := (pairRelation (M := (MvPolynomial (Fin 2) k) ⊗[k] T)
-    (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)).restrictScalars k
-  suffices h : Q.mkQ z = Q.mkQ (1 ⊗ₜ[k] polynomialAugment z) by
-    exact (Submodule.Quotient.mk_eq_zero Q).mp (by change Q.mkQ (z - 1 ⊗ₜ[k] polynomialAugment z) = 0; rw [map_sub, h, sub_self])
-  induction z using TensorProduct.inductionOn with
-  | tmul P t =>
-    have hX : ∀ (i : Fin 2) (m : (MvPolynomial (Fin 2) k) ⊗[k] T),
-        (MvPolynomial.X i : MvPolynomial (Fin 2) k) • m ∈ Q := by
-      intro i m
-      fin_cases i
-      · exact x_smul_mem_pairRelation _ _ m
-      · exact y_smul_mem_pairRelation _ _ m
-    have hh := originQuotient_polynomial_smul Q hX P (1 ⊗ₜ[k] t)
-    rw [TensorProduct.smul_tmul', smul_eq_mul, mul_one] at hh
-    rw [polynomialAugment_tmul, TensorProduct.tmul_smul, map_smul]
-    exact hh
-  | add z w hz hw => simp [map_add, TensorProduct.tmul_add, hz, hw]
-
- 
-
-theorem polynomialExtend_jet_bijective (q : N →ₗ[k] T) (L : T →ₗ[k] N)
-    (hq : ∀ n, q n = 0 ↔ n ∈ pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1))
-    (hL : q ∘ₗ L = LinearMap.id)
-    (hx : Function.Injective (fun n : N => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n))
-    (hy : ∀ v n : N, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
-      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
-      ∃ w, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
-    Function.Bijective (jetMap (polynomialExtend L) (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j) := by
-  have hqL : ∀ t, q (L t) = t := fun t => congrArg (fun f : T →ₗ[k] T => f t) hL
-  have hqX : ∀ i n, q ((MvPolynomial.X i : MvPolynomial (Fin 2) k) • n) = 0 := by
-    intro i n
-    apply (hq _).mpr
-    fin_cases i
-    · exact x_smul_mem_pairRelation _ _ n
-    · exact y_smul_mem_pairRelation _ _ n
-  have hqP : ∀ P n, q ((P : MvPolynomial (Fin 2) k) • n) = MvPolynomial.constantCoeff P • q n := by
-    intro P n
-    induction P using MvPolynomial.induction_on with
-    | C a =>
-      rw [MvPolynomial.constantCoeff_C]
-      change q (algebraMap k (MvPolynomial (Fin 2) k) a • n) = a • q n
-      rw [algebraMap_smul, map_smul]
-    | add P Q hP hQ => simp only [add_smul, map_add, hP, hQ]
-    | mul_X P i _ => rw [mul_comm, mul_smul, hqX]; simp
-  have he : ∀ z, q (polynomialExtend L z) = polynomialAugment z := by
-    intro z
-    induction z using TensorProduct.inductionOn with
-    | tmul P t => simp [hqP, hqL]
-    | add z w hz hw => simp [hz, hw]
-  constructor
-  · apply jetMap_injective (polynomialExtend L) _ _ hx hy
-    intro z hz
-    have hzero : polynomialAugment z = 0 := (he z).symm.trans ((hq _).mpr hz)
-    simpa only [hzero, TensorProduct.tmul_zero, sub_zero] using polynomial_origin_representative z
-  · apply jetMap_surjective
-    intro n
-    refine ⟨1 ⊗ₜ[k] q n, (hq _).mp ?_⟩
-    simp [hqL]
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.JetTriviality
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped TensorProduct
+universe u
+variable {k : Type u} [Field k]
+variable {T N : Type u} [AddCommGroup T] [Module k T]
+  [AddCommGroup N] [Module k N]
+  [Module (MvPolynomial (Fin 2) k) N] [IsScalarTower k (MvPolynomial (Fin 2) k) N]
+
+noncomputable def polynomialExtend (L : T →ₗ[k] N) :
+    (MvPolynomial (Fin 2) k) ⊗[k] T →ₗ[MvPolynomial (Fin 2) k] N :=
+  TensorProduct.AlgebraTensorModule.lift
+    (LinearMap.toSpanSingleton (MvPolynomial (Fin 2) k) (T →ₗ[k] N) L)
+
+@[simp] lemma polynomialExtend_tmul (L : T →ₗ[k] N)
+    (P : MvPolynomial (Fin 2) k) (t : T) :
+    polynomialExtend L (P ⊗ₜ[k] t) = P • L t := rfl
+
+noncomputable def polynomialAugment : (MvPolynomial (Fin 2) k) ⊗[k] T →ₗ[k] T :=
+  (TensorProduct.lid k T).toLinearMap ∘ₗ TensorProduct.map
+    ({ toFun := MvPolynomial.constantCoeff
+       map_add' := map_add _
+       map_smul' := MvPolynomial.constantCoeff_smul } : MvPolynomial (Fin 2) k →ₗ[k] k)
+    LinearMap.id
+
+@[simp] lemma polynomialAugment_tmul (P : MvPolynomial (Fin 2) k) (t : T) :
+    polynomialAugment (P ⊗ₜ[k] t) = MvPolynomial.constantCoeff P • t := rfl
+
+lemma polynomialAugment_smul (P : MvPolynomial (Fin 2) k)
+    (z : (MvPolynomial (Fin 2) k) ⊗[k] T) :
+    polynomialAugment (P • z) = MvPolynomial.constantCoeff P • polynomialAugment z := by
+  induction z using TensorProduct.inductionOn with
+  | tmul Q t => rw [TensorProduct.smul_tmul', polynomialAugment_tmul]; simp [smul_eq_mul, mul_smul]
+  | add z w hz hw => simp [smul_add, hz, hw]
+
+lemma polynomialAugment_pairRelation
+    (z : (MvPolynomial (Fin 2) k) ⊗[k] T)
+    (hz : z ∈ pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)) :
+    polynomialAugment z = 0 := by
+  obtain ⟨a,b,rfl⟩ := (mem_pairRelation _ _ z).mp hz
+  simp [polynomialAugment_smul]
+
+lemma polynomial_origin_representative (z : (MvPolynomial (Fin 2) k) ⊗[k] T) :
+    z - (1 : MvPolynomial (Fin 2) k) ⊗ₜ[k] polynomialAugment z ∈
+      pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) := by
+  let Q := (pairRelation (M := (MvPolynomial (Fin 2) k) ⊗[k] T)
+    (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1)).restrictScalars k
+  suffices h : Q.mkQ z = Q.mkQ (1 ⊗ₜ[k] polynomialAugment z) by
+    exact (Submodule.Quotient.mk_eq_zero Q).mp (by change Q.mkQ (z - 1 ⊗ₜ[k] polynomialAugment z) = 0; rw [map_sub, h, sub_self])
+  induction z using TensorProduct.inductionOn with
+  | tmul P t =>
+    have hX : ∀ (i : Fin 2) (m : (MvPolynomial (Fin 2) k) ⊗[k] T),
+        (MvPolynomial.X i : MvPolynomial (Fin 2) k) • m ∈ Q := by
+      intro i m
+      fin_cases i
+      · exact x_smul_mem_pairRelation _ _ m
+      · exact y_smul_mem_pairRelation _ _ m
+    have hh := originQuotient_polynomial_smul Q hX P (1 ⊗ₜ[k] t)
+    rw [TensorProduct.smul_tmul', smul_eq_mul, mul_one] at hh
+    rw [polynomialAugment_tmul, TensorProduct.tmul_smul, map_smul]
+    exact hh
+  | add z w hz hw => simp [map_add, TensorProduct.tmul_add, hz, hw]
+
+ 
+
+theorem polynomialExtend_jet_bijective (q : N →ₗ[k] T) (L : T →ₗ[k] N)
+    (hq : ∀ n, q n = 0 ↔ n ∈ pairRelation (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1))
+    (hL : q ∘ₗ L = LinearMap.id)
+    (hx : Function.Injective (fun n : N => (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n))
+    (hy : ∀ v n : N, (MvPolynomial.X 1 : MvPolynomial (Fin 2) k) • v =
+      (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • n →
+      ∃ w, v = (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) • w) (j : ℕ) :
+    Function.Bijective (jetMap (polynomialExtend L) (MvPolynomial.X 0 : MvPolynomial (Fin 2) k) (MvPolynomial.X 1) j) := by
+  have hqL : ∀ t, q (L t) = t := fun t => congrArg (fun f : T →ₗ[k] T => f t) hL
+  have hqX : ∀ i n, q ((MvPolynomial.X i : MvPolynomial (Fin 2) k) • n) = 0 := by
+    intro i n
+    apply (hq _).mpr
+    fin_cases i
+    · exact x_smul_mem_pairRelation _ _ n
+    · exact y_smul_mem_pairRelation _ _ n
+  have hqP : ∀ P n, q ((P : MvPolynomial (Fin 2) k) • n) = MvPolynomial.constantCoeff P • q n := by
+    intro P n
+    induction P using MvPolynomial.induction_on with
+    | C a =>
+      rw [MvPolynomial.constantCoeff_C]
+      change q (algebraMap k (MvPolynomial (Fin 2) k) a • n) = a • q n
+      rw [algebraMap_smul, map_smul]
+    | add P Q hP hQ => simp only [add_smul, map_add, hP, hQ]
+    | mul_X P i _ => rw [mul_comm, mul_smul, hqX]; simp
+  have he : ∀ z, q (polynomialExtend L z) = polynomialAugment z := by
+    intro z
+    induction z using TensorProduct.inductionOn with
+    | tmul P t => simp [hqP, hqL]
+    | add z w hz hw => simp [hz, hw]
+  constructor
+  · apply jetMap_injective (polynomialExtend L) _ _ hx hy
+    intro z hz
+    have hzero : polynomialAugment z = 0 := (he z).symm.trans ((hq _).mpr hz)
+    simpa only [hzero, TensorProduct.tmul_zero, sub_zero] using polynomial_origin_representative z
+  · apply jetMap_surjective
+    intro n
+    refine ⟨1 ⊗ₜ[k] q n, (hq _).mp ?_⟩
+    simp [hqL]
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/ProjectiveFactor.lean

@@ -1,46 +1,46 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.Limits
-open scoped ZeroObject
-
- 
-def FactorsThroughProjective {C : Type*} [Category* C] {X Y : C} (f : X ⟶ Y) : Prop :=
-  ∃ P : C, Projective P ∧ ∃ a : X ⟶ P, ∃ b : P ⟶ Y, a ≫ b = f
-
-variable {k : Type*} [Field k]
-variable {C : Type*} [Category* C] [Preadditive C] [Linear k C]
-variable [HasFiniteBiproducts C] {X Y : C}
-
-lemma FactorsThroughProjective.zero : FactorsThroughProjective (0 : X ⟶ Y) := by
-  refine ⟨0, (isZero_zero C).projective, 0, 0, ?_⟩
-  simp
-
-lemma FactorsThroughProjective.add {f g : X ⟶ Y}
-    (hf : FactorsThroughProjective f) (hg : FactorsThroughProjective g) :
-    FactorsThroughProjective (f+g) := by
-  obtain ⟨P,hP,a,b,rfl⟩ := hf
-  obtain ⟨Q,hQ,c,d,rfl⟩ := hg
-  let : HasBinaryBiproducts C := hasBinaryBiproducts_of_finite_biproducts C
-  let := hP
-  let := hQ
-  exact ⟨P ⊞ Q, inferInstance, biprod.lift a c, biprod.desc b d, by simp⟩
-
-omit [HasFiniteBiproducts C] in
-lemma FactorsThroughProjective.smul {f : X ⟶ Y}
-    (a : k) (hf : FactorsThroughProjective f) : FactorsThroughProjective (a • f) := by
-  obtain ⟨P,hP,b,c,rfl⟩ := hf
-  exact ⟨P,hP,a • b,c, by simp⟩
-
- 
-
-def projectiveFactorSubmodule (X Y : C) : Submodule k (X ⟶ Y) where
-  carrier := {f | FactorsThroughProjective f}
-  zero_mem' := FactorsThroughProjective.zero
-  add_mem' := FactorsThroughProjective.add
-  smul_mem' := fun a _ h => FactorsThroughProjective.smul a h
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.Limits
+open scoped ZeroObject
+
+ 
+def FactorsThroughProjective {C : Type*} [Category* C] {X Y : C} (f : X ⟶ Y) : Prop :=
+  ∃ P : C, Projective P ∧ ∃ a : X ⟶ P, ∃ b : P ⟶ Y, a ≫ b = f
+
+variable {k : Type*} [Field k]
+variable {C : Type*} [Category* C] [Preadditive C] [Linear k C]
+variable [HasFiniteBiproducts C] {X Y : C}
+
+lemma FactorsThroughProjective.zero : FactorsThroughProjective (0 : X ⟶ Y) := by
+  refine ⟨0, (isZero_zero C).projective, 0, 0, ?_⟩
+  simp
+
+lemma FactorsThroughProjective.add {f g : X ⟶ Y}
+    (hf : FactorsThroughProjective f) (hg : FactorsThroughProjective g) :
+    FactorsThroughProjective (f+g) := by
+  obtain ⟨P,hP,a,b,rfl⟩ := hf
+  obtain ⟨Q,hQ,c,d,rfl⟩ := hg
+  let : HasBinaryBiproducts C := hasBinaryBiproducts_of_finite_biproducts C
+  let := hP
+  let := hQ
+  exact ⟨P ⊞ Q, inferInstance, biprod.lift a c, biprod.desc b d, by simp⟩
+
+omit [HasFiniteBiproducts C] in
+lemma FactorsThroughProjective.smul {f : X ⟶ Y}
+    (a : k) (hf : FactorsThroughProjective f) : FactorsThroughProjective (a • f) := by
+  obtain ⟨P,hP,b,c,rfl⟩ := hf
+  exact ⟨P,hP,a • b,c, by simp⟩
+
+ 
+
+def projectiveFactorSubmodule (X Y : C) : Submodule k (X ⟶ Y) where
+  carrier := {f | FactorsThroughProjective f}
+  zero_mem' := FactorsThroughProjective.zero
+  add_mem' := FactorsThroughProjective.add
+  smul_mem' := fun a _ h => FactorsThroughProjective.smul a h
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/ProjectiveRegular.lean

@@ -1,25 +1,25 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory
-universe u v
-variable (k : Type u) [Field k]
-
- 
-
-theorem rep_leftRegular_projective (G : Type v) [Group G] :
-    Projective (Rep.leftRegular k G) := by
-  let e := Representation.ofMulActionSelfAsModuleEquiv (k := k) (G := G)
-  let b := (Module.Basis.singleton (PUnit.{1}) (MonoidAlgebra k G)).map e.symm
-  exact (Rep.toModuleMonoidAlgebra (k := k) (G := G)).projective_of_map_projective
-    (P := Rep.leftRegular k G) (ModuleCat.projective_of_free b)
-
-theorem fdrep_leftRegular_projective (G : Type) [Group G] [Fintype G] :
-    Projective (FDRep.of (Representation.leftRegular k G)) := by
-  apply (forget₂ (FDRep k G) (Rep k G)).projective_of_map_projective
-  exact rep_leftRegular_projective k G
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory
+universe u v
+variable (k : Type u) [Field k]
+
+ 
+
+theorem rep_leftRegular_projective (G : Type v) [Group G] :
+    Projective (Rep.leftRegular k G) := by
+  let e := Representation.ofMulActionSelfAsModuleEquiv (k := k) (G := G)
+  let b := (Module.Basis.singleton (PUnit.{1}) (MonoidAlgebra k G)).map e.symm
+  exact (Rep.toModuleMonoidAlgebra (k := k) (G := G)).projective_of_map_projective
+    (P := Rep.leftRegular k G) (ModuleCat.projective_of_free b)
+
+theorem fdrep_leftRegular_projective (G : Type) [Group G] [Fintype G] :
+    Projective (FDRep.of (Representation.leftRegular k G)) := by
+  apply (forget₂ (FDRep k G) (Rep k G)).projective_of_map_projective
+  exact rep_leftRegular_projective k G
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RationalHomWeights.lean

@@ -1,65 +1,65 @@
-import OAI.RepresentationTheory.RestrictedTilting.Basic
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped BigOperators
-universe u
-variable {k : Type u} [Field k] [Infinite k]
-variable {V W : Type u} [AddCommGroup V] [Module k V] [Module.Finite k V]
-  [AddCommGroup W] [Module k W] [Module.Finite k W]
-
-omit [Infinite k] in
-lemma IsRational.linHom (ρ : Representation k (SL2 k) V)
-    (σ : Representation k (SL2 k) W) (hρ : IsRational k ρ) (hσ : IsRational k σ) :
-    IsRational k (Representation.linHom ρ σ) := by
-  let e := Representation.Equiv.dualTensorHom ρ σ
-  exact IsRational.of_surjective k _ _ e.toLinearMap e.toLinearEquiv.surjective
-    (fun g x => congrArg (fun t => t x) (e.isIntertwining' g))
-    (IsRational.tensor k _ _ (IsRational.dual k ρ hρ) hσ)
-
-omit [Infinite k] [Module.Finite k V] [Module.Finite k W] in
-lemma linHom_weight_apply (ρ : Representation k (SL2 k) V)
-    (σ : Representation k (SL2 k) W) (n m : ℤ) (f : V →ₗ[k] W) (v : V)
-    (hf : ∀ a, (Representation.linHom ρ σ) (diagonalTorus k a) f =
-      integerCharacter k n a • f)
-    (hv : ∀ a, ρ (diagonalTorus k a) v = integerCharacter k m a • v) :
-    ∀ a, σ (diagonalTorus k a) (f v) = integerCharacter k (n+m) a • f v := by
-  intro a
-  have h := congrArg (fun q : V →ₗ[k] W => q (ρ (diagonalTorus k a) v)) (hf a)
-  simp only [Representation.linHom_apply, LinearMap.comp_apply] at h
-  rw [Representation.inv_self_apply] at h
-  have hh : integerCharacter k (n+m) a =
-      integerCharacter k n a * integerCharacter k m a := by
-    simp [integerCharacter, zpow_add]
-  simpa only [LinearMap.smul_apply, hv, map_smul, smul_smul, hh, mul_comm] using h
-
- 
-omit [Module.Finite k W] in
-lemma hasWeightsBetween_linHom (ρ : Representation k (SL2 k) V)
-    (σ : Representation k (SL2 k) W) (hρ : IsRational k ρ) (a b : ℕ)
-    (hA : HasWeightsBetween ρ (-(a : ℤ)) a)
-    (hB : HasWeightsBetween σ (-(b : ℤ)) b) :
-    HasWeightsBetween (Representation.linHom ρ σ) (-(a+b : ℤ)) (a+b) := by
-  intro n f hn hf
-  have hvanish (m : ℤ) (v : V)
-      (hv : ∀ t, ρ (diagonalTorus k t) v = integerCharacter k m t • v) : f v = 0 := by
-    by_cases hz : v = 0
-    · simp [hz]
-    have hm : -(a : ℤ) ≤ m ∧ m ≤ a := by
-      constructor <;> by_contra hh <;> apply hz
-      · exact hA m v (Or.inl (by omega)) hv
-      · exact hA m v (Or.inr (by omega)) hv
-    apply hB (n+m) (f v) (by omega)
-    exact linHom_weight_apply ρ σ n m f v hf hv
-  ext v
-  obtain ⟨c,hc⟩ := rational_torus_integerExpansions k ρ hρ v
-  have hs : v = ∑ n ∈ c.support, c n := by
-    simpa [Finsupp.sum, integerCharacter] using hc 1
-  rw [hs, map_sum]
-  apply Finset.sum_eq_zero
-  intro m hm
-  exact hvanish m (c m) (integer_coefficient_eigen k ρ v c hc m)
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.Basic
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped BigOperators
+universe u
+variable {k : Type u} [Field k] [Infinite k]
+variable {V W : Type u} [AddCommGroup V] [Module k V] [Module.Finite k V]
+  [AddCommGroup W] [Module k W] [Module.Finite k W]
+
+omit [Infinite k] in
+lemma IsRational.linHom (ρ : Representation k (SL2 k) V)
+    (σ : Representation k (SL2 k) W) (hρ : IsRational k ρ) (hσ : IsRational k σ) :
+    IsRational k (Representation.linHom ρ σ) := by
+  let e := Representation.Equiv.dualTensorHom ρ σ
+  exact IsRational.of_surjective k _ _ e.toLinearMap e.toLinearEquiv.surjective
+    (fun g x => congrArg (fun t => t x) (e.isIntertwining' g))
+    (IsRational.tensor k _ _ (IsRational.dual k ρ hρ) hσ)
+
+omit [Infinite k] [Module.Finite k V] [Module.Finite k W] in
+lemma linHom_weight_apply (ρ : Representation k (SL2 k) V)
+    (σ : Representation k (SL2 k) W) (n m : ℤ) (f : V →ₗ[k] W) (v : V)
+    (hf : ∀ a, (Representation.linHom ρ σ) (diagonalTorus k a) f =
+      integerCharacter k n a • f)
+    (hv : ∀ a, ρ (diagonalTorus k a) v = integerCharacter k m a • v) :
+    ∀ a, σ (diagonalTorus k a) (f v) = integerCharacter k (n+m) a • f v := by
+  intro a
+  have h := congrArg (fun q : V →ₗ[k] W => q (ρ (diagonalTorus k a) v)) (hf a)
+  simp only [Representation.linHom_apply, LinearMap.comp_apply] at h
+  rw [Representation.inv_self_apply] at h
+  have hh : integerCharacter k (n+m) a =
+      integerCharacter k n a * integerCharacter k m a := by
+    simp [integerCharacter, zpow_add]
+  simpa only [LinearMap.smul_apply, hv, map_smul, smul_smul, hh, mul_comm] using h
+
+ 
+omit [Module.Finite k W] in
+lemma hasWeightsBetween_linHom (ρ : Representation k (SL2 k) V)
+    (σ : Representation k (SL2 k) W) (hρ : IsRational k ρ) (a b : ℕ)
+    (hA : HasWeightsBetween ρ (-(a : ℤ)) a)
+    (hB : HasWeightsBetween σ (-(b : ℤ)) b) :
+    HasWeightsBetween (Representation.linHom ρ σ) (-(a+b : ℤ)) (a+b) := by
+  intro n f hn hf
+  have hvanish (m : ℤ) (v : V)
+      (hv : ∀ t, ρ (diagonalTorus k t) v = integerCharacter k m t • v) : f v = 0 := by
+    by_cases hz : v = 0
+    · simp [hz]
+    have hm : -(a : ℤ) ≤ m ∧ m ≤ a := by
+      constructor <;> by_contra hh <;> apply hz
+      · exact hA m v (Or.inl (by omega)) hv
+      · exact hA m v (Or.inr (by omega)) hv
+    apply hB (n+m) (f v) (by omega)
+    exact linHom_weight_apply ρ σ n m f v hf hv
+  ext v
+  obtain ⟨c,hc⟩ := rational_torus_integerExpansions k ρ hρ v
+  have hs : v = ∑ n ∈ c.support, c n := by
+    simpa [Finsupp.sum, integerCharacter] using hc 1
+  rw [hs, map_sum]
+  apply Finset.sum_eq_zero
+  intro m hm
+  exact hvanish m (c m) (integer_coefficient_eigen k ρ v c hc m)
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RationalMatrices.lean

@@ -1,79 +1,79 @@
-import OAI.RepresentationTheory.RestrictedTilting.Basic
-
-namespace OAI
-
-namespace FiberFunctorProof
-open scoped LaurentPolynomial BigOperators
-universe u
-variable (k : Type u) [Field k]
-variable {ι : Type u} [Fintype ι] [DecidableEq ι]
-variable (ρ : Representation k (SL2 k) (ι → k)) (hρ : IsRational k ρ)
-
-noncomputable def rationalCoefficient (i j : ι) : MvPolynomial (Fin 2 × Fin 2) k :=
-  (hρ (Pi.single j 1) (LinearMap.proj i)).choose
-
-lemma eval_rationalCoefficient (g : SL2 k) (i j : ι) :
-    MvPolynomial.eval (fun ij => g ij.1 ij.2) (rationalCoefficient k ρ hρ i j) =
-      LinearMap.toMatrix' (ρ g) i j := by
-  exact ((hρ (Pi.single j 1) (LinearMap.proj i)).choose_spec g).symm
-
-noncomputable def unipotentPolynomialCoordinates (ij : Fin 2 × Fin 2) : Polynomial k :=
-  if ij.1 = ij.2 then 1 else if ij = (0,1) then Polynomial.X else 0
-
-noncomputable def torusLaurentCoordinates (ij : Fin 2 × Fin 2) : LaurentPolynomial k :=
-  if ij = (0,0) then LaurentPolynomial.T 1 else
-  if ij = (1,1) then LaurentPolynomial.T (-1) else 0
-
-noncomputable def rationalUnipotentMatrix : Matrix ι ι (Polynomial k) := fun i j =>
-  MvPolynomial.eval₂ Polynomial.C (unipotentPolynomialCoordinates k)
-    (rationalCoefficient k ρ hρ i j)
-
-noncomputable def rationalTorusMatrix : Matrix ι ι (LaurentPolynomial k) := fun i j =>
-  MvPolynomial.eval₂ LaurentPolynomial.C (torusLaurentCoordinates k)
-    (rationalCoefficient k ρ hρ i j)
-
-lemma eval_unipotentPolynomialCoordinates (t : k) (ij : Fin 2 × Fin 2) :
-    (unipotentPolynomialCoordinates k ij).eval t = unipotent k t ij.1 ij.2 := by
-  obtain ⟨i,j⟩ := ij
-  fin_cases i <;> fin_cases j <;> simp [unipotentPolynomialCoordinates, unipotent]
-
-lemma eval_torusLaurentCoordinates (a : kˣ) (ij : Fin 2 × Fin 2) :
-    LaurentPolynomial.eval₂ (RingHom.id k) a (torusLaurentCoordinates k ij) =
-      diagonalTorus k a ij.1 ij.2 := by
-  change _ = (!![(a : k), 0; 0, (↑a⁻¹ : k)] : Matrix (Fin 2) (Fin 2) k) ij.1 ij.2
-  obtain ⟨i,j⟩ := ij
-  fin_cases i <;> fin_cases j <;>
-    simp [torusLaurentCoordinates, LaurentPolynomial.eval₂_T]
-
-lemma eval_rationalUnipotentMatrix (t : k) :
-    (rationalUnipotentMatrix k ρ hρ).map (Polynomial.evalRingHom t) =
-      LinearMap.toMatrix' (ρ (unipotent k t)) := by
-  ext i j
-  change Polynomial.eval t (MvPolynomial.eval₂ _ _ _) = _
-  have hcomp : (Polynomial.evalRingHom t).comp
-      (MvPolynomial.eval₂Hom Polynomial.C (unipotentPolynomialCoordinates k)) =
-      MvPolynomial.eval (fun ij => unipotent k t ij.1 ij.2) := by
-    apply MvPolynomial.ringHom_ext
-    · intro c; simp
-    · intro ij; simpa using eval_unipotentPolynomialCoordinates k t ij
-  have he := congrArg (fun f : MvPolynomial (Fin 2 × Fin 2) k →+* k =>
-    f (rationalCoefficient k ρ hρ i j)) hcomp
-  exact he.trans (eval_rationalCoefficient k ρ hρ _ i j)
-
-lemma eval_rationalTorusMatrix (a : kˣ) :
-    (rationalTorusMatrix k ρ hρ).map (LaurentPolynomial.eval₂ (RingHom.id k) a) =
-      LinearMap.toMatrix' (ρ (diagonalTorus k a)) := by
-  ext i j
-  change LaurentPolynomial.eval₂ (RingHom.id k) a (MvPolynomial.eval₂ _ _ _) = _
-  have hcomp : (LaurentPolynomial.eval₂ (RingHom.id k) a).comp
-      (MvPolynomial.eval₂Hom LaurentPolynomial.C (torusLaurentCoordinates k)) =
-      MvPolynomial.eval (fun ij => diagonalTorus k a ij.1 ij.2) := by
-    apply MvPolynomial.ringHom_ext
-    · intro c; simp [LaurentPolynomial.eval₂_C]
-    · intro ij; simpa using eval_torusLaurentCoordinates k a ij
-  have he := congrArg (fun f : MvPolynomial (Fin 2 × Fin 2) k →+* k =>
-    f (rationalCoefficient k ρ hρ i j)) hcomp
-  exact he.trans (eval_rationalCoefficient k ρ hρ _ i j)
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.Basic
+
+namespace OAI
+
+namespace FiberFunctorProof
+open scoped LaurentPolynomial BigOperators
+universe u
+variable (k : Type u) [Field k]
+variable {ι : Type u} [Fintype ι] [DecidableEq ι]
+variable (ρ : Representation k (SL2 k) (ι → k)) (hρ : IsRational k ρ)
+
+noncomputable def rationalCoefficient (i j : ι) : MvPolynomial (Fin 2 × Fin 2) k :=
+  (hρ (Pi.single j 1) (LinearMap.proj i)).choose
+
+lemma eval_rationalCoefficient (g : SL2 k) (i j : ι) :
+    MvPolynomial.eval (fun ij => g ij.1 ij.2) (rationalCoefficient k ρ hρ i j) =
+      LinearMap.toMatrix' (ρ g) i j := by
+  exact ((hρ (Pi.single j 1) (LinearMap.proj i)).choose_spec g).symm
+
+noncomputable def unipotentPolynomialCoordinates (ij : Fin 2 × Fin 2) : Polynomial k :=
+  if ij.1 = ij.2 then 1 else if ij = (0,1) then Polynomial.X else 0
+
+noncomputable def torusLaurentCoordinates (ij : Fin 2 × Fin 2) : LaurentPolynomial k :=
+  if ij = (0,0) then LaurentPolynomial.T 1 else
+  if ij = (1,1) then LaurentPolynomial.T (-1) else 0
+
+noncomputable def rationalUnipotentMatrix : Matrix ι ι (Polynomial k) := fun i j =>
+  MvPolynomial.eval₂ Polynomial.C (unipotentPolynomialCoordinates k)
+    (rationalCoefficient k ρ hρ i j)
+
+noncomputable def rationalTorusMatrix : Matrix ι ι (LaurentPolynomial k) := fun i j =>
+  MvPolynomial.eval₂ LaurentPolynomial.C (torusLaurentCoordinates k)
+    (rationalCoefficient k ρ hρ i j)
+
+lemma eval_unipotentPolynomialCoordinates (t : k) (ij : Fin 2 × Fin 2) :
+    (unipotentPolynomialCoordinates k ij).eval t = unipotent k t ij.1 ij.2 := by
+  obtain ⟨i,j⟩ := ij
+  fin_cases i <;> fin_cases j <;> simp [unipotentPolynomialCoordinates, unipotent]
+
+lemma eval_torusLaurentCoordinates (a : kˣ) (ij : Fin 2 × Fin 2) :
+    LaurentPolynomial.eval₂ (RingHom.id k) a (torusLaurentCoordinates k ij) =
+      diagonalTorus k a ij.1 ij.2 := by
+  change _ = (!![(a : k), 0; 0, (↑a⁻¹ : k)] : Matrix (Fin 2) (Fin 2) k) ij.1 ij.2
+  obtain ⟨i,j⟩ := ij
+  fin_cases i <;> fin_cases j <;>
+    simp [torusLaurentCoordinates, LaurentPolynomial.eval₂_T]
+
+lemma eval_rationalUnipotentMatrix (t : k) :
+    (rationalUnipotentMatrix k ρ hρ).map (Polynomial.evalRingHom t) =
+      LinearMap.toMatrix' (ρ (unipotent k t)) := by
+  ext i j
+  change Polynomial.eval t (MvPolynomial.eval₂ _ _ _) = _
+  have hcomp : (Polynomial.evalRingHom t).comp
+      (MvPolynomial.eval₂Hom Polynomial.C (unipotentPolynomialCoordinates k)) =
+      MvPolynomial.eval (fun ij => unipotent k t ij.1 ij.2) := by
+    apply MvPolynomial.ringHom_ext
+    · intro c; simp
+    · intro ij; simpa using eval_unipotentPolynomialCoordinates k t ij
+  have he := congrArg (fun f : MvPolynomial (Fin 2 × Fin 2) k →+* k =>
+    f (rationalCoefficient k ρ hρ i j)) hcomp
+  exact he.trans (eval_rationalCoefficient k ρ hρ _ i j)
+
+lemma eval_rationalTorusMatrix (a : kˣ) :
+    (rationalTorusMatrix k ρ hρ).map (LaurentPolynomial.eval₂ (RingHom.id k) a) =
+      LinearMap.toMatrix' (ρ (diagonalTorus k a)) := by
+  ext i j
+  change LaurentPolynomial.eval₂ (RingHom.id k) a (MvPolynomial.eval₂ _ _ _) = _
+  have hcomp : (LaurentPolynomial.eval₂ (RingHom.id k) a).comp
+      (MvPolynomial.eval₂Hom LaurentPolynomial.C (torusLaurentCoordinates k)) =
+      MvPolynomial.eval (fun ij => diagonalTorus k a ij.1 ij.2) := by
+    apply MvPolynomial.ringHom_ext
+    · intro c; simp [LaurentPolynomial.eval₂_C]
+    · intro ij; simpa using eval_torusLaurentCoordinates k a ij
+  have he := congrArg (fun f : MvPolynomial (Fin 2 × Fin 2) k →+* k =>
+    f (rationalCoefficient k ρ hρ i j)) hcomp
+  exact he.trans (eval_rationalCoefficient k ρ hρ _ i j)
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RegularActions.lean

@@ -1,311 +1,311 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.DualSplitting
-
-namespace OAI
-
-/-! Polynomial coordinate representations and associated sections. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-universe u
-variable (k : Type u) [Field k]
-open scoped Matrix Kronecker
-
-noncomputable def leftCoordinateMatrix : SL2 k →* Matrix (Fin 2 × Fin 2) (Fin 2 × Fin 2) k where
-  toFun g := (dualMatrix k g) ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) k)
-  map_one' := by rw [map_one, Matrix.one_kronecker_one]
-  map_mul' g h := by rw [map_mul, ← Matrix.mul_kronecker_mul, one_mul]
-
-noncomputable def coordinatePolynomialRepresentation :
-    Representation k (SL2 k) (MvPolynomial (Fin 2 × Fin 2) k) where
-  toFun g := (linearChange (leftCoordinateMatrix k g)).toLinearMap
-  map_one' := by rw [map_one, linearChange_one]; rfl
-  map_mul' g h := by rw [map_mul, linearChange_mul]; rfl
-
-lemma coordinatePolynomial_rational : IsRational k (coordinatePolynomialRepresentation k) := by
-  intro v l
-  apply regular_linearChange_coeff k
-    (fun g : SL2 k => fun ij : Fin 2 × Fin 2 => g ij.1 ij.2)
-    (leftCoordinateMatrix k) _ v l
-  intro a b
-  refine ⟨inverseCoordinatePolynomial k (b.1,a.1) *
-    MvPolynomial.C ((1 : Matrix (Fin 2) (Fin 2) k) a.2 b.2), fun g => ?_⟩
-  change (g⁻¹ : SL2 k) b.1 a.1 * (1 : Matrix (Fin 2) (Fin 2) k) a.2 b.2 = _
-  rw [MvPolynomial.eval_mul, MvPolynomial.eval_C, eval_inverseCoordinatePolynomial]
-
-noncomputable def coordinateEvaluation :
-    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] (SL2 k → k) :=
-  MvPolynomial.aeval (fun ij => fun g : SL2 k => g ij.1 ij.2)
-
-lemma coordinateEvaluation_apply (P : MvPolynomial (Fin 2 × Fin 2) k) (g : SL2 k) :
-    coordinateEvaluation k P g = MvPolynomial.eval (fun ij => g ij.1 ij.2) P := by
-  induction P using MvPolynomial.induction_on with
-  | C c => simp [coordinateEvaluation]
-  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
-  | mul_X P i hp =>
-    simp only [map_mul, Pi.mul_apply, hp]
-    congr 1
-    simp [coordinateEvaluation]
-
-lemma coordinatePolynomial_evaluation (g h : SL2 k)
-    (P : MvPolynomial (Fin 2 × Fin 2) k) :
-    coordinateEvaluation k (coordinatePolynomialRepresentation k g P) h =
-      coordinateEvaluation k P (g⁻¹ * h) := by
-  rw [coordinateEvaluation_apply, coordinateEvaluation_apply]
-  change MvPolynomial.eval _ (linearChange (leftCoordinateMatrix k g) P) = _
-  rw [eval_linearChange]
-  apply congrArg (fun z => MvPolynomial.eval z P)
-  funext i
-  change (∑ j : Fin 2 × Fin 2, (g⁻¹ : SL2 k) i.1 j.1 *
-    (1 : Matrix (Fin 2) (Fin 2) k) j.2 i.2 * h j.1 j.2) = _
-  simp [Fintype.sum_prod_type, Matrix.one_apply, Matrix.mul_apply]
-
- 
-
-noncomputable def regularSL2Functions : Subalgebra k (SL2 k → k) :=
-  (coordinateEvaluation k).range
-
-noncomputable def regularSL2Representation :
-    Representation k (SL2 k) (regularSL2Functions k) where
-  toFun g :=
-    { toFun := fun f => ⟨fun h => f.val (g⁻¹ * h), by
-        obtain ⟨P,hP⟩ := f.property
-        refine ⟨coordinatePolynomialRepresentation k g P, ?_⟩
-        ext h
-        change coordinateEvaluation k (coordinatePolynomialRepresentation k g P) h = _
-        rw [coordinatePolynomial_evaluation]
-        exact congrArg (fun f : SL2 k → k => f (g⁻¹ * h)) hP⟩
-      map_add' := by intro f f'; rfl
-      map_smul' := by intro a f; rfl }
-  map_one' := by ext f h; simp
-  map_mul' := by intro g h; ext f a; simp [mul_assoc]
-
-noncomputable def coordinateToRegular :
-    MvPolynomial (Fin 2 × Fin 2) k →ₗ[k] regularSL2Functions k :=
-  (coordinateEvaluation k).rangeRestrict.toLinearMap
-
-lemma coordinateToRegular_surjective : Function.Surjective (coordinateToRegular k) := by
-  intro f
-  obtain ⟨P,hP⟩ := f.property
-  exact ⟨P, Subtype.ext hP⟩
-
-lemma regularSL2_rational : IsRational k (regularSL2Representation k) := by
-  apply IsRational.of_surjective k (coordinatePolynomialRepresentation k)
-    (regularSL2Representation k) (coordinateToRegular k) (coordinateToRegular_surjective k)
-    _ (coordinatePolynomial_rational k)
-  intro g P
-  apply Subtype.ext
-  funext h
-  exact coordinatePolynomial_evaluation k g h P
-
- 
-
-noncomputable def regularVectorRepresentation (ι : Type u) :
-    Representation k (SL2 k) (ι → regularSL2Functions k) where
-  toFun g :=
-    { toFun := fun f i => regularSL2Representation k g (f i)
-      map_add' := by intro f f'; funext i; exact map_add (regularSL2Representation k g) _ _
-      map_smul' := by intro a f; funext i; exact map_smul (regularSL2Representation k g) _ _ }
-  map_one' := by
-    apply LinearMap.ext
-    intro f
-    funext i
-    exact congrArg (fun a : Module.End k (regularSL2Functions k) => a (f i))
-      (map_one (regularSL2Representation k))
-  map_mul' := by
-    intro g h
-    apply LinearMap.ext
-    intro f
-    funext i
-    exact congrArg (fun a : Module.End k (regularSL2Functions k) => a (f i))
-      (map_mul (regularSL2Representation k) g h)
-
-lemma regularVector_rational (ι : Type u) [Fintype ι] [DecidableEq ι] :
-    IsRational k (regularVectorRepresentation k ι) := by
-  intro v l
-  let ei (i : ι) : regularSL2Functions k →ₗ[k] (ι → regularSL2Functions k) :=
-    LinearMap.single k (fun _ : ι => regularSL2Functions k) i
-  have hsum (w : ι → regularSL2Functions k) : ∑ i, ei i (w i) = w := by
-    ext i
-    simp [ei]
-  choose P hP using fun i => regularSL2_rational k (v i) (l.comp (ei i))
-  refine ⟨∑ i, P i, fun g => ?_⟩
-  rw [← hsum (regularVectorRepresentation k ι g v), map_sum, MvPolynomial.eval_sum]
-  apply Finset.sum_congr rfl
-  intro i _
-  exact hP i g
-
-end
-
-universe u
-variable (k : Type u) [Field k]
-variable (ι : Type u) [Fintype ι] [DecidableEq ι]
-
-noncomputable def regularVectorEvaluation (g : SL2 k) :
-    (ι → regularSL2Functions k) →ₗ[k] (ι → k) where
-  toFun f i := (f i).val g
-  map_add' := by intro f h; rfl
-  map_smul' := by intro a f; rfl
-
-variable (ρ : Representation k (Multiplicative k) (ι → k))
-
- 
-
-noncomputable def associatedSectionsSubmodule :
-    Submodule k (ι → regularSL2Functions k) where
-  carrier := {f | ∀ (g : SL2 k) (t : k),
-    regularVectorEvaluation k ι (g * unipotent k t) f =
-      ρ (Multiplicative.ofAdd (-t)) (regularVectorEvaluation k ι g f)}
-  zero_mem' := by intro g t; simp
-  add_mem' := by
-    intro f h hf hh g t
-    rw [map_add, hf, hh, map_add, map_add]
-  smul_mem' := by
-    intro a f hf g t
-    rw [map_smul, hf, map_smul, map_smul]
-
-noncomputable def associatedSectionsSubrepresentation :
-    Subrepresentation (regularVectorRepresentation k ι) where
-  toSubmodule := associatedSectionsSubmodule k ι ρ
-  apply_mem_toSubmodule g f hf := by
-    intro h t
-    change regularVectorEvaluation k ι (g⁻¹ * (h * unipotent k t)) f =
-      ρ (Multiplicative.ofAdd (-t)) (regularVectorEvaluation k ι (g⁻¹ * h) f)
-    rw [← mul_assoc]
-    exact hf (g⁻¹ * h) t
-
-noncomputable def associatedSectionsRepresentation :
-    Representation k (SL2 k) (associatedSectionsSubmodule k ι ρ) :=
-  (associatedSectionsSubrepresentation k ι ρ).toRepresentation
-
-lemma associatedSections_rational : IsRational k
-    (M := associatedSectionsSubmodule k ι ρ) (associatedSectionsRepresentation k ι ρ) := by
-  exact IsRational.of_injective k (M := associatedSectionsSubmodule k ι ρ)
-    (N := ι → regularSL2Functions k) (associatedSectionsRepresentation k ι ρ)
-    (regularVectorRepresentation k ι) (associatedSectionsSubmodule k ι ρ).subtype
-    (associatedSectionsSubmodule k ι ρ).injective_subtype (fun _ _ => rfl)
-    (regularVector_rational k ι)
-
-noncomputable def regularFirstColumn (i : Fin 2) : regularSL2Functions k :=
-  coordinateToRegular k (MvPolynomial.X (i,0))
-
-lemma regularFirstColumn_apply (i : Fin 2) (g : SL2 k) :
-    (regularFirstColumn k i).val g = g i 0 := by
-  change coordinateEvaluation k (MvPolynomial.X (i,0)) g = _
-  rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
-
-lemma firstColumn_unipotent_mul (g : SL2 k) (t : k) (i : Fin 2) :
-    (g * unipotent k t) i 0 = g i 0 := by
-  change (((g : Matrix (Fin 2) (Fin 2) k) *
-    (unipotent k t : Matrix (Fin 2) (Fin 2) k)) i 0) = _
-  simp [Matrix.mul_apply, Fin.sum_univ_two, unipotent]
-
-noncomputable def regularVectorCoordinateMul (i : Fin 2) :
-    (ι → regularSL2Functions k) →ₗ[k] (ι → regularSL2Functions k) where
-  toFun f j := regularFirstColumn k i * f j
-  map_add' := by intro f h; funext j; exact mul_add _ _ _
-  map_smul' := by intro a f; funext j; exact mul_smul_comm a (regularFirstColumn k i) (f j)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma regularVectorCoordinateMul_evaluation (i : Fin 2)
-    (f : ι → regularSL2Functions k) (g : SL2 k) :
-    regularVectorEvaluation k ι g (regularVectorCoordinateMul k ι i f) =
-      g i 0 • regularVectorEvaluation k ι g f := by
-  funext j
-  change (regularFirstColumn k i).val g * (f j).val g = _
-  rw [regularFirstColumn_apply]
-  rfl
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedSections_coordinate_mul_mem (i : Fin 2)
-    (f : ι → regularSL2Functions k) (hf : f ∈ associatedSectionsSubmodule k ι ρ) :
-    regularVectorCoordinateMul k ι i f ∈ associatedSectionsSubmodule k ι ρ := by
-  intro g t
-  rw [regularVectorCoordinateMul_evaluation, regularVectorCoordinateMul_evaluation,
-    firstColumn_unipotent_mul, hf, map_smul]
-
-noncomputable def associatedCoordinateMul (i : Fin 2) :
-    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (associatedSectionsSubmodule k ι ρ) :=
-  (regularVectorCoordinateMul k ι i).restrict
-    (associatedSections_coordinate_mul_mem k ι ρ i)
-
-omit [Fintype ι] [DecidableEq ι] in
- 
-
-lemma associatedCoordinateMul_action (g : SL2 k) (i : Fin 2)
-    (f : associatedSectionsSubmodule k ι ρ) :
-    associatedSectionsRepresentation k ι ρ g (associatedCoordinateMul k ι ρ i f) =
-      ∑ j : Fin 2, (g⁻¹ : SL2 k) i j •
-        associatedCoordinateMul k ι ρ j (associatedSectionsRepresentation k ι ρ g f) := by
-  rw [Fin.sum_univ_two]
-  apply Subtype.ext
-  funext a
-  apply Subtype.ext
-  funext h
-  change (regularFirstColumn k i).val (g⁻¹ * h) * (f.val a).val (g⁻¹ * h) =
-    (g⁻¹ : SL2 k) i 0 * ((regularFirstColumn k 0).val h * (f.val a).val (g⁻¹ * h)) +
-    (g⁻¹ : SL2 k) i 1 * ((regularFirstColumn k 1).val h * (f.val a).val (g⁻¹ * h))
-  rw [regularFirstColumn_apply, regularFirstColumn_apply, regularFirstColumn_apply]
-  change (((g⁻¹ : SL2 k) : Matrix (Fin 2) (Fin 2) k) *
-    (h : Matrix (Fin 2) (Fin 2) k)) i 0 * _ = _
-  simp only [Matrix.mul_apply, Fin.sum_univ_two]
-  ring
-
- 
-noncomputable def associatedOriginRelations : Submodule k (associatedSectionsSubmodule k ι ρ) :=
-  LinearMap.range (associatedCoordinateMul k ι ρ 0) ⊔
-    LinearMap.range (associatedCoordinateMul k ι ρ 1)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma associatedOriginRelations_stable (g : SL2 k) :
-    associatedOriginRelations k ι ρ ≤
-      (associatedOriginRelations k ι ρ).comap (associatedSectionsRepresentation k ι ρ g) := by
-  have hcoord (i : Fin 2) (f : associatedSectionsSubmodule k ι ρ) :
-      associatedSectionsRepresentation k ι ρ g (associatedCoordinateMul k ι ρ i f) ∈
-        associatedOriginRelations k ι ρ := by
-    rw [associatedCoordinateMul_action]
-    apply Submodule.sum_mem
-    intro j _
-    apply Submodule.smul_mem
-    fin_cases j
-    · exact Submodule.mem_sup_left ⟨_,rfl⟩
-    · exact Submodule.mem_sup_right ⟨_,rfl⟩
-  apply sup_le
-  · rintro _ ⟨f,rfl⟩
-    exact hcoord 0 f
-  · rintro _ ⟨f,rfl⟩
-    exact hcoord 1 f
-
-noncomputable def quotientRationalModule {V : Type u} [AddCommGroup V] [Module k V]
-    (σ : Representation k (SL2 k) V) (P : Submodule k V)
-    (hP : ∀ g, P ≤ P.comap (σ g)) : Rep k (SL2 k) :=
-  Rep.of (Representation.quotient σ P hP)
-
-omit [Fintype ι] [DecidableEq ι] in
-lemma quotientRationalModule_rational {V : Type u} [AddCommGroup V] [Module k V]
-    (σ : Representation k (SL2 k) V) (P : Submodule k V)
-    (hP : ∀ g, P ≤ P.comap (σ g)) (hσ : IsRational k σ) :
-    IsRational k (quotientRationalModule k σ P hP).ρ := by
-  exact IsRational.of_surjective k (M := V) (N := V ⧸ P)
-    σ (Representation.quotient σ P hP) P.mkQ P.mkQ_surjective (fun _ _ => rfl) hσ
-
- 
-noncomputable def associatedOriginRep : Rep k (SL2 k) :=
-  quotientRationalModule k (V := associatedSectionsSubmodule k ι ρ)
-    (associatedSectionsRepresentation k ι ρ) (associatedOriginRelations k ι ρ)
-    (associatedOriginRelations_stable k ι ρ)
-
- 
-
-lemma associatedOrigin_rational : IsRational k (associatedOriginRep k ι ρ).ρ := by
-  exact quotientRationalModule_rational k _ _ _ (associatedSections_rational k ι ρ)
-
-end FiberFunctorProof
-
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.DualSplitting
+
+namespace OAI
+
+/-! Polynomial coordinate representations and associated sections. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+universe u
+variable (k : Type u) [Field k]
+open scoped Matrix Kronecker
+
+noncomputable def leftCoordinateMatrix : SL2 k →* Matrix (Fin 2 × Fin 2) (Fin 2 × Fin 2) k where
+  toFun g := (dualMatrix k g) ⊗ₖ (1 : Matrix (Fin 2) (Fin 2) k)
+  map_one' := by rw [map_one, Matrix.one_kronecker_one]
+  map_mul' g h := by rw [map_mul, ← Matrix.mul_kronecker_mul, one_mul]
+
+noncomputable def coordinatePolynomialRepresentation :
+    Representation k (SL2 k) (MvPolynomial (Fin 2 × Fin 2) k) where
+  toFun g := (linearChange (leftCoordinateMatrix k g)).toLinearMap
+  map_one' := by rw [map_one, linearChange_one]; rfl
+  map_mul' g h := by rw [map_mul, linearChange_mul]; rfl
+
+lemma coordinatePolynomial_rational : IsRational k (coordinatePolynomialRepresentation k) := by
+  intro v l
+  apply regular_linearChange_coeff k
+    (fun g : SL2 k => fun ij : Fin 2 × Fin 2 => g ij.1 ij.2)
+    (leftCoordinateMatrix k) _ v l
+  intro a b
+  refine ⟨inverseCoordinatePolynomial k (b.1,a.1) *
+    MvPolynomial.C ((1 : Matrix (Fin 2) (Fin 2) k) a.2 b.2), fun g => ?_⟩
+  change (g⁻¹ : SL2 k) b.1 a.1 * (1 : Matrix (Fin 2) (Fin 2) k) a.2 b.2 = _
+  rw [MvPolynomial.eval_mul, MvPolynomial.eval_C, eval_inverseCoordinatePolynomial]
+
+noncomputable def coordinateEvaluation :
+    MvPolynomial (Fin 2 × Fin 2) k →ₐ[k] (SL2 k → k) :=
+  MvPolynomial.aeval (fun ij => fun g : SL2 k => g ij.1 ij.2)
+
+lemma coordinateEvaluation_apply (P : MvPolynomial (Fin 2 × Fin 2) k) (g : SL2 k) :
+    coordinateEvaluation k P g = MvPolynomial.eval (fun ij => g ij.1 ij.2) P := by
+  induction P using MvPolynomial.induction_on with
+  | C c => simp [coordinateEvaluation]
+  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
+  | mul_X P i hp =>
+    simp only [map_mul, Pi.mul_apply, hp]
+    congr 1
+    simp [coordinateEvaluation]
+
+lemma coordinatePolynomial_evaluation (g h : SL2 k)
+    (P : MvPolynomial (Fin 2 × Fin 2) k) :
+    coordinateEvaluation k (coordinatePolynomialRepresentation k g P) h =
+      coordinateEvaluation k P (g⁻¹ * h) := by
+  rw [coordinateEvaluation_apply, coordinateEvaluation_apply]
+  change MvPolynomial.eval _ (linearChange (leftCoordinateMatrix k g) P) = _
+  rw [eval_linearChange]
+  apply congrArg (fun z => MvPolynomial.eval z P)
+  funext i
+  change (∑ j : Fin 2 × Fin 2, (g⁻¹ : SL2 k) i.1 j.1 *
+    (1 : Matrix (Fin 2) (Fin 2) k) j.2 i.2 * h j.1 j.2) = _
+  simp [Fintype.sum_prod_type, Matrix.one_apply, Matrix.mul_apply]
+
+ 
+
+noncomputable def regularSL2Functions : Subalgebra k (SL2 k → k) :=
+  (coordinateEvaluation k).range
+
+noncomputable def regularSL2Representation :
+    Representation k (SL2 k) (regularSL2Functions k) where
+  toFun g :=
+    { toFun := fun f => ⟨fun h => f.val (g⁻¹ * h), by
+        obtain ⟨P,hP⟩ := f.property
+        refine ⟨coordinatePolynomialRepresentation k g P, ?_⟩
+        ext h
+        change coordinateEvaluation k (coordinatePolynomialRepresentation k g P) h = _
+        rw [coordinatePolynomial_evaluation]
+        exact congrArg (fun f : SL2 k → k => f (g⁻¹ * h)) hP⟩
+      map_add' := by intro f f'; rfl
+      map_smul' := by intro a f; rfl }
+  map_one' := by ext f h; simp
+  map_mul' := by intro g h; ext f a; simp [mul_assoc]
+
+noncomputable def coordinateToRegular :
+    MvPolynomial (Fin 2 × Fin 2) k →ₗ[k] regularSL2Functions k :=
+  (coordinateEvaluation k).rangeRestrict.toLinearMap
+
+lemma coordinateToRegular_surjective : Function.Surjective (coordinateToRegular k) := by
+  intro f
+  obtain ⟨P,hP⟩ := f.property
+  exact ⟨P, Subtype.ext hP⟩
+
+lemma regularSL2_rational : IsRational k (regularSL2Representation k) := by
+  apply IsRational.of_surjective k (coordinatePolynomialRepresentation k)
+    (regularSL2Representation k) (coordinateToRegular k) (coordinateToRegular_surjective k)
+    _ (coordinatePolynomial_rational k)
+  intro g P
+  apply Subtype.ext
+  funext h
+  exact coordinatePolynomial_evaluation k g h P
+
+ 
+
+noncomputable def regularVectorRepresentation (ι : Type u) :
+    Representation k (SL2 k) (ι → regularSL2Functions k) where
+  toFun g :=
+    { toFun := fun f i => regularSL2Representation k g (f i)
+      map_add' := by intro f f'; funext i; exact map_add (regularSL2Representation k g) _ _
+      map_smul' := by intro a f; funext i; exact map_smul (regularSL2Representation k g) _ _ }
+  map_one' := by
+    apply LinearMap.ext
+    intro f
+    funext i
+    exact congrArg (fun a : Module.End k (regularSL2Functions k) => a (f i))
+      (map_one (regularSL2Representation k))
+  map_mul' := by
+    intro g h
+    apply LinearMap.ext
+    intro f
+    funext i
+    exact congrArg (fun a : Module.End k (regularSL2Functions k) => a (f i))
+      (map_mul (regularSL2Representation k) g h)
+
+lemma regularVector_rational (ι : Type u) [Fintype ι] [DecidableEq ι] :
+    IsRational k (regularVectorRepresentation k ι) := by
+  intro v l
+  let ei (i : ι) : regularSL2Functions k →ₗ[k] (ι → regularSL2Functions k) :=
+    LinearMap.single k (fun _ : ι => regularSL2Functions k) i
+  have hsum (w : ι → regularSL2Functions k) : ∑ i, ei i (w i) = w := by
+    ext i
+    simp [ei]
+  choose P hP using fun i => regularSL2_rational k (v i) (l.comp (ei i))
+  refine ⟨∑ i, P i, fun g => ?_⟩
+  rw [← hsum (regularVectorRepresentation k ι g v), map_sum, MvPolynomial.eval_sum]
+  apply Finset.sum_congr rfl
+  intro i _
+  exact hP i g
+
+end
+
+universe u
+variable (k : Type u) [Field k]
+variable (ι : Type u) [Fintype ι] [DecidableEq ι]
+
+noncomputable def regularVectorEvaluation (g : SL2 k) :
+    (ι → regularSL2Functions k) →ₗ[k] (ι → k) where
+  toFun f i := (f i).val g
+  map_add' := by intro f h; rfl
+  map_smul' := by intro a f; rfl
+
+variable (ρ : Representation k (Multiplicative k) (ι → k))
+
+ 
+
+noncomputable def associatedSectionsSubmodule :
+    Submodule k (ι → regularSL2Functions k) where
+  carrier := {f | ∀ (g : SL2 k) (t : k),
+    regularVectorEvaluation k ι (g * unipotent k t) f =
+      ρ (Multiplicative.ofAdd (-t)) (regularVectorEvaluation k ι g f)}
+  zero_mem' := by intro g t; simp
+  add_mem' := by
+    intro f h hf hh g t
+    rw [map_add, hf, hh, map_add, map_add]
+  smul_mem' := by
+    intro a f hf g t
+    rw [map_smul, hf, map_smul, map_smul]
+
+noncomputable def associatedSectionsSubrepresentation :
+    Subrepresentation (regularVectorRepresentation k ι) where
+  toSubmodule := associatedSectionsSubmodule k ι ρ
+  apply_mem_toSubmodule g f hf := by
+    intro h t
+    change regularVectorEvaluation k ι (g⁻¹ * (h * unipotent k t)) f =
+      ρ (Multiplicative.ofAdd (-t)) (regularVectorEvaluation k ι (g⁻¹ * h) f)
+    rw [← mul_assoc]
+    exact hf (g⁻¹ * h) t
+
+noncomputable def associatedSectionsRepresentation :
+    Representation k (SL2 k) (associatedSectionsSubmodule k ι ρ) :=
+  (associatedSectionsSubrepresentation k ι ρ).toRepresentation
+
+lemma associatedSections_rational : IsRational k
+    (M := associatedSectionsSubmodule k ι ρ) (associatedSectionsRepresentation k ι ρ) := by
+  exact IsRational.of_injective k (M := associatedSectionsSubmodule k ι ρ)
+    (N := ι → regularSL2Functions k) (associatedSectionsRepresentation k ι ρ)
+    (regularVectorRepresentation k ι) (associatedSectionsSubmodule k ι ρ).subtype
+    (associatedSectionsSubmodule k ι ρ).injective_subtype (fun _ _ => rfl)
+    (regularVector_rational k ι)
+
+noncomputable def regularFirstColumn (i : Fin 2) : regularSL2Functions k :=
+  coordinateToRegular k (MvPolynomial.X (i,0))
+
+lemma regularFirstColumn_apply (i : Fin 2) (g : SL2 k) :
+    (regularFirstColumn k i).val g = g i 0 := by
+  change coordinateEvaluation k (MvPolynomial.X (i,0)) g = _
+  rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
+
+lemma firstColumn_unipotent_mul (g : SL2 k) (t : k) (i : Fin 2) :
+    (g * unipotent k t) i 0 = g i 0 := by
+  change (((g : Matrix (Fin 2) (Fin 2) k) *
+    (unipotent k t : Matrix (Fin 2) (Fin 2) k)) i 0) = _
+  simp [Matrix.mul_apply, Fin.sum_univ_two, unipotent]
+
+noncomputable def regularVectorCoordinateMul (i : Fin 2) :
+    (ι → regularSL2Functions k) →ₗ[k] (ι → regularSL2Functions k) where
+  toFun f j := regularFirstColumn k i * f j
+  map_add' := by intro f h; funext j; exact mul_add _ _ _
+  map_smul' := by intro a f; funext j; exact mul_smul_comm a (regularFirstColumn k i) (f j)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma regularVectorCoordinateMul_evaluation (i : Fin 2)
+    (f : ι → regularSL2Functions k) (g : SL2 k) :
+    regularVectorEvaluation k ι g (regularVectorCoordinateMul k ι i f) =
+      g i 0 • regularVectorEvaluation k ι g f := by
+  funext j
+  change (regularFirstColumn k i).val g * (f j).val g = _
+  rw [regularFirstColumn_apply]
+  rfl
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedSections_coordinate_mul_mem (i : Fin 2)
+    (f : ι → regularSL2Functions k) (hf : f ∈ associatedSectionsSubmodule k ι ρ) :
+    regularVectorCoordinateMul k ι i f ∈ associatedSectionsSubmodule k ι ρ := by
+  intro g t
+  rw [regularVectorCoordinateMul_evaluation, regularVectorCoordinateMul_evaluation,
+    firstColumn_unipotent_mul, hf, map_smul]
+
+noncomputable def associatedCoordinateMul (i : Fin 2) :
+    (associatedSectionsSubmodule k ι ρ) →ₗ[k] (associatedSectionsSubmodule k ι ρ) :=
+  (regularVectorCoordinateMul k ι i).restrict
+    (associatedSections_coordinate_mul_mem k ι ρ i)
+
+omit [Fintype ι] [DecidableEq ι] in
+ 
+
+lemma associatedCoordinateMul_action (g : SL2 k) (i : Fin 2)
+    (f : associatedSectionsSubmodule k ι ρ) :
+    associatedSectionsRepresentation k ι ρ g (associatedCoordinateMul k ι ρ i f) =
+      ∑ j : Fin 2, (g⁻¹ : SL2 k) i j •
+        associatedCoordinateMul k ι ρ j (associatedSectionsRepresentation k ι ρ g f) := by
+  rw [Fin.sum_univ_two]
+  apply Subtype.ext
+  funext a
+  apply Subtype.ext
+  funext h
+  change (regularFirstColumn k i).val (g⁻¹ * h) * (f.val a).val (g⁻¹ * h) =
+    (g⁻¹ : SL2 k) i 0 * ((regularFirstColumn k 0).val h * (f.val a).val (g⁻¹ * h)) +
+    (g⁻¹ : SL2 k) i 1 * ((regularFirstColumn k 1).val h * (f.val a).val (g⁻¹ * h))
+  rw [regularFirstColumn_apply, regularFirstColumn_apply, regularFirstColumn_apply]
+  change (((g⁻¹ : SL2 k) : Matrix (Fin 2) (Fin 2) k) *
+    (h : Matrix (Fin 2) (Fin 2) k)) i 0 * _ = _
+  simp only [Matrix.mul_apply, Fin.sum_univ_two]
+  ring
+
+ 
+noncomputable def associatedOriginRelations : Submodule k (associatedSectionsSubmodule k ι ρ) :=
+  LinearMap.range (associatedCoordinateMul k ι ρ 0) ⊔
+    LinearMap.range (associatedCoordinateMul k ι ρ 1)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma associatedOriginRelations_stable (g : SL2 k) :
+    associatedOriginRelations k ι ρ ≤
+      (associatedOriginRelations k ι ρ).comap (associatedSectionsRepresentation k ι ρ g) := by
+  have hcoord (i : Fin 2) (f : associatedSectionsSubmodule k ι ρ) :
+      associatedSectionsRepresentation k ι ρ g (associatedCoordinateMul k ι ρ i f) ∈
+        associatedOriginRelations k ι ρ := by
+    rw [associatedCoordinateMul_action]
+    apply Submodule.sum_mem
+    intro j _
+    apply Submodule.smul_mem
+    fin_cases j
+    · exact Submodule.mem_sup_left ⟨_,rfl⟩
+    · exact Submodule.mem_sup_right ⟨_,rfl⟩
+  apply sup_le
+  · rintro _ ⟨f,rfl⟩
+    exact hcoord 0 f
+  · rintro _ ⟨f,rfl⟩
+    exact hcoord 1 f
+
+noncomputable def quotientRationalModule {V : Type u} [AddCommGroup V] [Module k V]
+    (σ : Representation k (SL2 k) V) (P : Submodule k V)
+    (hP : ∀ g, P ≤ P.comap (σ g)) : Rep k (SL2 k) :=
+  Rep.of (Representation.quotient σ P hP)
+
+omit [Fintype ι] [DecidableEq ι] in
+lemma quotientRationalModule_rational {V : Type u} [AddCommGroup V] [Module k V]
+    (σ : Representation k (SL2 k) V) (P : Submodule k V)
+    (hP : ∀ g, P ≤ P.comap (σ g)) (hσ : IsRational k σ) :
+    IsRational k (quotientRationalModule k σ P hP).ρ := by
+  exact IsRational.of_surjective k (M := V) (N := V ⧸ P)
+    σ (Representation.quotient σ P hP) P.mkQ P.mkQ_surjective (fun _ _ => rfl) hσ
+
+ 
+noncomputable def associatedOriginRep : Rep k (SL2 k) :=
+  quotientRationalModule k (V := associatedSectionsSubmodule k ι ρ)
+    (associatedSectionsRepresentation k ι ρ) (associatedOriginRelations k ι ρ)
+    (associatedOriginRelations_stable k ι ρ)
+
+ 
+
+lemma associatedOrigin_rational : IsRational k (associatedOriginRep k ι ρ).ρ := by
+  exact quotientRationalModule_rational k _ _ _ (associatedSections_rational k ι ρ)
+
+end FiberFunctorProof
+
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RegularSplitting.lean

@@ -1,82 +1,82 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open Representation
-universe u v
-variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
-variable {V W : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
-
-lemma intertwining_norm {ρ : Representation k G V} {σ : Representation k G W}
-    (f : ρ.IntertwiningMap σ) (v : V) : f (ρ.norm v) = σ.norm (f v) := by
-  simp only [Representation.norm, LinearMap.sum_apply, map_sum, f.isIntertwining]
-
-noncomputable def regularCoefficients : MonoidAlgebra k G ≃ₗ[k] (G → k) :=
-  (MonoidAlgebra.coeffLinearEquiv k).trans (Finsupp.linearEquivFunOnFinite k k G)
-
-omit [Group G] in
-@[simp] lemma regularCoefficients_apply (x : MonoidAlgebra k G) (g : G) :
-    regularCoefficients x g = x.coeff g := rfl
-
-omit [Group G] in
-@[simp] lemma regularCoefficients_symm_coeff (v : G → k) (g : G) :
-    (regularCoefficients.symm v).coeff g = v g := by
-  exact congrFun (regularCoefficients.apply_symm_apply v) g
-
- 
-
-noncomputable def regularCofree (ρ : Representation k G V) (φ : V →ₗ[k] k) :
-    ρ.IntertwiningMap (Representation.leftRegular k G) where
-  toLinearMap := regularCoefficients.symm.toLinearMap.comp
-    (LinearMap.pi fun g : G => φ.comp (ρ g⁻¹))
-  isIntertwining' h := by
-    ext v g
-    simp [regularCoefficients_symm_coeff, Representation.coeff_ofMulAction,
-      mul_inv_rev, map_mul]
-
-@[simp] lemma regularCofree_coeff (ρ : Representation k G V) (φ : V →ₗ[k] k)
-    (v : V) (g : G) : (regularCofree ρ φ v).coeff g = φ (ρ g⁻¹ v) := by
-  exact regularCoefficients_symm_coeff _ g
-
- 
-
-theorem regular_split_of_injective (ρ : Representation k G V)
-    (f : (Representation.leftRegular k G).IntertwiningMap ρ)
-    (hf : Function.Injective f) :
-    ∃ s : ρ.IntertwiningMap (Representation.leftRegular k G),
-      s.comp f = Representation.IntertwiningMap.id _ := by
-  obtain ⟨j,hj⟩ := f.toLinearMap.exists_leftInverse_of_injective
-    (LinearMap.ker_eq_bot.mpr hf)
-  have hji (x : MonoidAlgebra k G) : j (f x) = x := congr($(hj) x)
-  let φ : V →ₗ[k] k := (Finsupp.lapply 1).comp
-    ((MonoidAlgebra.coeffLinearEquiv k).toLinearMap.comp j)
-  refine ⟨regularCofree ρ φ, ?_⟩
-  apply IntertwiningMap.ext
-  apply LinearMap.ext
-  intro x
-  apply MonoidAlgebra.ext
-  apply Finsupp.ext
-  intro g
-  change (regularCofree ρ φ (f x)).coeff g = x.coeff g
-  rw [regularCofree_coeff, ← f.isIntertwining]
-  change (j (f ((Representation.leftRegular k G) g⁻¹ x))).coeff 1 = x.coeff g
-  rw [hji]
-  simp [Representation.coeff_ofMulAction]
-
-lemma regular_norm_single_coeff (g : G) :
-    ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)).coeff g = 1 := by
-  classical
-  simp [Representation.norm]
-
- 
-theorem regular_invariant_eq (x : MonoidAlgebra k G)
-    (hx : ∀ g, (Representation.leftRegular k G) g x = x) :
-    x = x.coeff 1 • (Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1) := by
-  ext g
-  have h := congrArg (fun a : MonoidAlgebra k G => a.coeff g) (hx g)
-  simp [Representation.coeff_ofMulAction] at h
-  simpa [regular_norm_single_coeff] using h.symm
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open Representation
+universe u v
+variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
+variable {V W : Type u} [AddCommGroup V] [Module k V] [AddCommGroup W] [Module k W]
+
+lemma intertwining_norm {ρ : Representation k G V} {σ : Representation k G W}
+    (f : ρ.IntertwiningMap σ) (v : V) : f (ρ.norm v) = σ.norm (f v) := by
+  simp only [Representation.norm, LinearMap.sum_apply, map_sum, f.isIntertwining]
+
+noncomputable def regularCoefficients : MonoidAlgebra k G ≃ₗ[k] (G → k) :=
+  (MonoidAlgebra.coeffLinearEquiv k).trans (Finsupp.linearEquivFunOnFinite k k G)
+
+omit [Group G] in
+@[simp] lemma regularCoefficients_apply (x : MonoidAlgebra k G) (g : G) :
+    regularCoefficients x g = x.coeff g := rfl
+
+omit [Group G] in
+@[simp] lemma regularCoefficients_symm_coeff (v : G → k) (g : G) :
+    (regularCoefficients.symm v).coeff g = v g := by
+  exact congrFun (regularCoefficients.apply_symm_apply v) g
+
+ 
+
+noncomputable def regularCofree (ρ : Representation k G V) (φ : V →ₗ[k] k) :
+    ρ.IntertwiningMap (Representation.leftRegular k G) where
+  toLinearMap := regularCoefficients.symm.toLinearMap.comp
+    (LinearMap.pi fun g : G => φ.comp (ρ g⁻¹))
+  isIntertwining' h := by
+    ext v g
+    simp [regularCoefficients_symm_coeff, Representation.coeff_ofMulAction,
+      mul_inv_rev, map_mul]
+
+@[simp] lemma regularCofree_coeff (ρ : Representation k G V) (φ : V →ₗ[k] k)
+    (v : V) (g : G) : (regularCofree ρ φ v).coeff g = φ (ρ g⁻¹ v) := by
+  exact regularCoefficients_symm_coeff _ g
+
+ 
+
+theorem regular_split_of_injective (ρ : Representation k G V)
+    (f : (Representation.leftRegular k G).IntertwiningMap ρ)
+    (hf : Function.Injective f) :
+    ∃ s : ρ.IntertwiningMap (Representation.leftRegular k G),
+      s.comp f = Representation.IntertwiningMap.id _ := by
+  obtain ⟨j,hj⟩ := f.toLinearMap.exists_leftInverse_of_injective
+    (LinearMap.ker_eq_bot.mpr hf)
+  have hji (x : MonoidAlgebra k G) : j (f x) = x := congr($(hj) x)
+  let φ : V →ₗ[k] k := (Finsupp.lapply 1).comp
+    ((MonoidAlgebra.coeffLinearEquiv k).toLinearMap.comp j)
+  refine ⟨regularCofree ρ φ, ?_⟩
+  apply IntertwiningMap.ext
+  apply LinearMap.ext
+  intro x
+  apply MonoidAlgebra.ext
+  apply Finsupp.ext
+  intro g
+  change (regularCofree ρ φ (f x)).coeff g = x.coeff g
+  rw [regularCofree_coeff, ← f.isIntertwining]
+  change (j (f ((Representation.leftRegular k G) g⁻¹ x))).coeff 1 = x.coeff g
+  rw [hji]
+  simp [Representation.coeff_ofMulAction]
+
+lemma regular_norm_single_coeff (g : G) :
+    ((Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1)).coeff g = 1 := by
+  classical
+  simp [Representation.norm]
+
+ 
+theorem regular_invariant_eq (x : MonoidAlgebra k G)
+    (hx : ∀ g, (Representation.leftRegular k G) g x = x) :
+    x = x.coeff 1 • (Representation.leftRegular k G).norm (MonoidAlgebra.single 1 1) := by
+  ext g
+  have h := congrArg (fun a : MonoidAlgebra k G => a.coeff g) (hx g)
+  simp [Representation.coeff_ofMulAction] at h
+  simpa [regular_norm_single_coeff] using h.symm
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RegularTorus.lean

@@ -1,438 +1,438 @@
-import Mathlib
-import OAI.RepresentationTheory.RestrictedTilting.RegularActions
-
-namespace OAI
-
-/-! Torus density, regular localization and coprime denominator gluing. -/
-
-noncomputable section
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-open scoped BigOperators
-
-namespace FiberFunctorProof
-section
-variable (k : Type*) [Field k] [Infinite k]
-
-abbrev planeTorusPoints := {x : Fin 2 → k // ∀ i, x i ≠ 0}
-
-noncomputable def planeTorusEvaluation :
-    MvPolynomial (Fin 2) k →ₐ[k] (planeTorusPoints k → k) :=
-  MvPolynomial.aeval (fun i x => x.val i)
-
-omit [Infinite k] in
-lemma planeTorusEvaluation_apply (P : MvPolynomial (Fin 2) k) (x : planeTorusPoints k) :
-    planeTorusEvaluation k P x = MvPolynomial.eval x.val P := by
-  induction P using MvPolynomial.induction_on with
-  | C c => simp [planeTorusEvaluation]
-  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
-  | mul_X P i hp =>
-    simp only [map_mul, Pi.mul_apply, hp]
-    congr 1
-    simp [planeTorusEvaluation]
-
-theorem planeTorusEvaluation_injective : Function.Injective (planeTorusEvaluation k) := by
-  intro P Q h
-  apply MvPolynomial.funext_set (fun _ : Fin 2 => ({0} : Set k)ᶜ)
-    (fun _ => (Set.finite_singleton (0 : k)).infinite_compl)
-  intro x hx
-  have hx' : ∀ i, x i ≠ 0 := by
-    intro i
-    simpa only [Set.mem_compl_iff, Set.mem_singleton_iff] using hx i (Set.mem_univ i)
-  exact (planeTorusEvaluation_apply k P ⟨x,hx'⟩).symm.trans
-    ((congrFun h ⟨x,hx'⟩).trans (planeTorusEvaluation_apply k Q ⟨x,hx'⟩))
-
-omit [Infinite k] in
-lemma planeTorusEvaluation_X_isUnit (i : Fin 2) :
-    IsUnit (planeTorusEvaluation k (MvPolynomial.X i)) := by
-  refine ⟨⟨fun x => x.val i, fun x => (x.val i)⁻¹, ?_, ?_⟩, ?_⟩
-  · funext x; exact mul_inv_cancel₀ (x.property i)
-  · funext x; exact inv_mul_cancel₀ (x.property i)
-  · ext x; simp [planeTorusEvaluation]
-
-abbrev planeCoordinateChart (i : Fin 2) :=
-  Localization.Away (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-
-noncomputable def planeChartEvaluation (i : Fin 2) :
-    planeCoordinateChart k i →ₐ[k] (planeTorusPoints k → k) :=
-  IsLocalization.Away.liftAlgHom (MvPolynomial.X i) (planeTorusEvaluation_X_isUnit k i)
-
-omit [Infinite k] in
-lemma planeChartEvaluation_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
-    planeChartEvaluation k i
-      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
-      planeTorusEvaluation k P :=
-  IsLocalization.Away.lift_eq _ (planeTorusEvaluation_X_isUnit k i) _
-
-theorem planeChartEvaluation_injective (i : Fin 2) :
-    Function.Injective (planeChartEvaluation k i) := by
-  apply (IsLocalization.injective_iff_map_algebraMap_eq
-    (R := MvPolynomial (Fin 2) k) (S := planeCoordinateChart k i)
-    (Submonoid.powers (MvPolynomial.X i)) (planeChartEvaluation k i).toRingHom).mpr
-  intro P Q
-  constructor
-  · exact congrArg (planeChartEvaluation k i)
-  · intro h
-    have h' : planeTorusEvaluation k P = planeTorusEvaluation k Q := by
-      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
-        planeChartEvaluation_algebraMap] using h
-    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i))
-      (planeTorusEvaluation_injective k h')
-
-end
-
-section
-universe u
-variable (k : Type u) [Field k]
-
- 
-lemma regularSL2_polynomial_path (f : regularSL2Functions k)
-    (g : k → SL2 k) (A : Matrix (Fin 2) (Fin 2) (Polynomial k))
-    (hA : ∀ t i j, (A i j).eval t = g t i j) :
-    ∃ P : Polynomial k, ∀ t, P.eval t = f.val (g t) := by
-  obtain ⟨Q,hQ⟩ := f.property
-  change coordinateEvaluation k Q = f.val at hQ
-  refine ⟨MvPolynomial.aeval (fun ij => A ij.1 ij.2) Q, ?_⟩
-  intro t
-  rw [← congrFun hQ (g t), coordinateEvaluation_apply]
-  clear hQ
-  induction Q using MvPolynomial.induction_on with
-  | C c => simp
-  | add Q R hQ hR => simp only [map_add, Polynomial.eval_add, hQ, hR]
-  | mul_X Q i hQ =>
-    simp only [map_mul, Polynomial.eval_mul, MvPolynomial.aeval_X, hA,
-      MvPolynomial.eval_X, hQ]
-
-noncomputable def regularLowerShear (t : k) : SL2 k :=
-  ⟨!![1,0;t,1], by simp [Matrix.det_fin_two]⟩
-
-lemma regularLowerShear_zero : regularLowerShear k 0 = 1 := by
-  apply Subtype.ext
-  ext i j
-  fin_cases i <;> fin_cases j <;> rfl
-
-lemma lowerShear_mul_entry (t : k) (g : SL2 k) (i j : Fin 2) :
-    (regularLowerShear k t * g) i j =
-      (!![g 0 0, g 0 1; t * g 0 0 + g 1 0, t * g 0 1 + g 1 1]) i j := by
-  change ((regularLowerShear k t : Matrix (Fin 2) (Fin 2) k) *
-    (g : Matrix (Fin 2) (Fin 2) k)) i j = _
-  fin_cases i <;> fin_cases j <;>
-    simp [regularLowerShear, Matrix.mul_apply, Fin.sum_univ_two]
-
-lemma upperShear_mul_entry (t : k) (g : SL2 k) (i j : Fin 2) :
-    (unipotent k t * g) i j =
-      (!![g 0 0 + t * g 1 0, g 0 1 + t * g 1 1; g 1 0, g 1 1]) i j := by
-  change ((unipotent k t : Matrix (Fin 2) (Fin 2) k) *
-    (g : Matrix (Fin 2) (Fin 2) k)) i j = _
-  fin_cases i <;> fin_cases j <;>
-    simp [unipotent, Matrix.mul_apply, Fin.sum_univ_two]
-
- 
-
-theorem regularSL2_torus_dense [Infinite k] (f : regularSL2Functions k)
-    (hf : ∀ g : SL2 k, g 0 0 ≠ 0 → g 1 0 ≠ 0 → f.val g = 0) : f = 0 := by
-  have hfirst (g : SL2 k) (ha : g 0 0 ≠ 0) : f.val g = 0 := by
-    obtain ⟨P,hP⟩ := regularSL2_polynomial_path k f (fun t => regularLowerShear k t * g)
-      (!![Polynomial.C (g 0 0), Polynomial.C (g 0 1);
-        Polynomial.X * Polynomial.C (g 0 0) + Polynomial.C (g 1 0),
-        Polynomial.X * Polynomial.C (g 0 1) + Polynomial.C (g 1 1)]) (by
-          intro t i j
-          rw [lowerShear_mul_entry]
-          fin_cases i <;> fin_cases j <;> simp <;> ring)
-    have hzero : P = 0 := by
-      apply Polynomial.eq_zero_of_infinite_isRoot
-      apply ((Set.finite_singleton (-g 1 0 / g 0 0)).infinite_compl).mono
-      intro t ht
-      change P.eval t = 0
-      rw [hP]
-      apply hf
-      · simpa [lowerShear_mul_entry] using ha
-      · have ht' : t ≠ -g 1 0 / g 0 0 := ht
-        simp only [lowerShear_mul_entry]
-        intro hz
-        exact ht' ((eq_div_iff ha).mpr (eq_neg_of_add_eq_zero_left hz))
-    have h := hP 0
-    rw [hzero, Polynomial.eval_zero, regularLowerShear_zero, one_mul] at h
-    exact h.symm
-  apply Subtype.ext
-  funext g
-  change f.val g = 0
-  by_cases ha : g 0 0 = 0
-  · have hc : g 1 0 ≠ 0 := by
-      intro hc
-      have hd := g.property
-      rw [Matrix.det_fin_two, ha, hc] at hd
-      norm_num at hd
-    obtain ⟨P,hP⟩ := regularSL2_polynomial_path k f (fun t => unipotent k t * g)
-      (!![Polynomial.C (g 0 0) + Polynomial.X * Polynomial.C (g 1 0),
-        Polynomial.C (g 0 1) + Polynomial.X * Polynomial.C (g 1 1);
-        Polynomial.C (g 1 0), Polynomial.C (g 1 1)]) (by
-          intro t i j
-          rw [upperShear_mul_entry]
-          fin_cases i <;> fin_cases j <;> simp <;> ring)
-    have hzero : P = 0 := by
-      apply Polynomial.eq_zero_of_infinite_isRoot
-      apply ((Set.finite_singleton (0 : k)).infinite_compl).mono
-      intro t ht
-      change P.eval t = 0
-      rw [hP]
-      apply hfirst
-      simpa [upperShear_mul_entry, ha] using mul_ne_zero ht hc
-    have h := hP 0
-    rw [hzero, Polynomial.eval_zero, unipotent_zero, one_mul] at h
-    exact h.symm
-  · exact hfirst g ha
-
-
-noncomputable def regularEntry (i j : Fin 2) : regularSL2Functions k :=
-  coordinateToRegular k (MvPolynomial.X (i,j))
-
-lemma regularEntry_apply (i j : Fin 2) (g : SL2 k) :
-    (regularEntry k i j).val g = g i j := by
-  change coordinateEvaluation k (MvPolynomial.X (i,j)) g = _
-  rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
-
-lemma regularFirstColumn_eq_entry (i : Fin 2) :
-    regularFirstColumn k i = regularEntry k i 0 := rfl
-
-abbrev regularTorusPoints := {g : SL2 k // ∀ i, g i 0 ≠ 0}
-
-noncomputable def regularTorusRestriction :
-    regularSL2Functions k →ₐ[k] (regularTorusPoints k → k) where
-  toFun f g := f.val g.val
-  map_zero' := rfl
-  map_one' := rfl
-  map_add' _ _ := rfl
-  map_mul' _ _ := rfl
-  commutes' _ := rfl
-
-lemma regularTorusRestriction_injective [Infinite k] :
-    Function.Injective (regularTorusRestriction k) := by
-  intro f h he
-  apply sub_eq_zero.mp
-  apply regularSL2_torus_dense k
-  intro g ha hc
-  exact sub_eq_zero.mpr (congrFun he ⟨g, by intro i; fin_cases i; exact ha; exact hc⟩)
-
-noncomputable def regularPlane :
-    MvPolynomial (Fin 2) k →ₐ[k] regularSL2Functions k :=
-  MvPolynomial.aeval (regularFirstColumn k)
-
-lemma regularPlane_evaluation (P : MvPolynomial (Fin 2) k) (g : SL2 k) :
-    (regularPlane k P).val g = MvPolynomial.eval (fun i => g i 0) P := by
-  induction P using MvPolynomial.induction_on with
-  | C c => simp [regularPlane]
-  | add P Q hP hQ =>
-    simp only [map_add, Subalgebra.coe_add, Pi.add_apply, hP, hQ]
-  | mul_X P i hP =>
-    rw [map_mul, MvPolynomial.eval_mul, MvPolynomial.eval_X]
-    simp only [Subalgebra.coe_mul, Pi.mul_apply]
-    rw [hP]
-    congr 1
-    simpa only [regularPlane, MvPolynomial.aeval_X] using regularFirstColumn_apply k i g
-
-abbrev regularCoordinateLocalization (i : Fin 2) :=
-  Localization.Away (regularFirstColumn k i)
-
-lemma regularTorusRestriction_coordinate_isUnit (i : Fin 2) :
-    IsUnit (regularTorusRestriction k (regularFirstColumn k i)) := by
-  refine ⟨⟨fun g => g.val i 0, fun g => (g.val i 0)⁻¹, ?_, ?_⟩, ?_⟩
-  · funext g; exact mul_inv_cancel₀ (g.property i)
-  · funext g; exact inv_mul_cancel₀ (g.property i)
-  · funext g; exact (regularFirstColumn_apply k i g.val).symm
-
-noncomputable def regularLocalizationEvaluation (i : Fin 2) :
-    regularCoordinateLocalization k i →ₐ[k] (regularTorusPoints k → k) :=
-  IsLocalization.Away.liftAlgHom (regularFirstColumn k i)
-    (regularTorusRestriction_coordinate_isUnit k i)
-
-lemma regularLocalizationEvaluation_algebraMap (i : Fin 2) (f : regularSL2Functions k) :
-    regularLocalizationEvaluation k i
-      (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i) f) =
-      regularTorusRestriction k f :=
-  IsLocalization.Away.lift_eq _ (regularTorusRestriction_coordinate_isUnit k i) _
-
-noncomputable def planeChartPullback (i : Fin 2) :
-    planeCoordinateChart k i →ₐ[k] regularCoordinateLocalization k i :=
-  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
-    (f := (IsScalarTower.toAlgHom k (regularSL2Functions k)
-      (regularCoordinateLocalization k i)).comp (regularPlane k)) (by
-        change IsUnit (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i)
-          (regularPlane k (MvPolynomial.X i)))
-        simp only [regularPlane, MvPolynomial.aeval_X]
-        exact IsLocalization.Away.algebraMap_isUnit _)
-
-lemma planeChartPullback_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
-    planeChartPullback k i
-      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
-      algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i) (regularPlane k P) := by
-  unfold planeChartPullback
-  rw [IsLocalization.Away.liftAlgHom_apply, IsLocalization.Away.lift_eq]
-  rfl
-
-noncomputable def regularToPlaneTorus (g : regularTorusPoints k) : planeTorusPoints k :=
-  ⟨fun i => g.val i 0, g.property⟩
-
-lemma planeChartPullback_evaluation (i : Fin 2) (f : planeCoordinateChart k i)
-    (g : regularTorusPoints k) :
-    regularLocalizationEvaluation k i (planeChartPullback k i f) g =
-      planeChartEvaluation k i f (regularToPlaneTorus k g) := by
-  let ev : (planeTorusPoints k → k) →+* (regularTorusPoints k → k) :=
-    { toFun := fun f g => f (regularToPlaneTorus k g)
-      map_zero' := rfl
-      map_one' := rfl
-      map_add' := fun _ _ => rfl
-      map_mul' := fun _ _ => rfl }
-  have h : (regularLocalizationEvaluation k i).toRingHom.comp
-      (planeChartPullback k i).toRingHom = ev.comp (planeChartEvaluation k i).toRingHom := by
-    apply IsLocalization.ringHom_ext (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
-    apply RingHom.ext
-    intro P
-    ext g
-    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
-      planeChartPullback_algebraMap, regularLocalizationEvaluation_algebraMap,
-      planeChartEvaluation_algebraMap]
-    exact (regularPlane_evaluation k P g.val).trans
-      (planeTorusEvaluation_apply k P (regularToPlaneTorus k g)).symm
-  exact congrFun (RingHom.congr_fun h f) g
-
-noncomputable def regularCoordinateInverse (i : Fin 2) : regularCoordinateLocalization k i :=
-  IsLocalization.Away.invSelf (S := regularCoordinateLocalization k i) (regularFirstColumn k i)
-
-lemma regularCoordinateInverse_evaluation (i : Fin 2) (g : regularTorusPoints k) :
-    regularLocalizationEvaluation k i (regularCoordinateInverse k i) g = (g.val i 0)⁻¹ := by
-  have hmul := IsLocalization.Away.mul_invSelf (S := regularCoordinateLocalization k i)
-    (regularFirstColumn k i)
-  have h := congrFun (congrArg (regularLocalizationEvaluation k i) hmul) g
-  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
-    regularLocalizationEvaluation_algebraMap] at h
-  change (regularFirstColumn k i).val g.val *
-    regularLocalizationEvaluation k i (regularCoordinateInverse k i) g = 1 at h
-  rw [regularFirstColumn_apply] at h
-  exact mul_left_cancel₀ (g.property i) (h.trans (mul_inv_cancel₀ (g.property i)).symm)
-
- 
-
-lemma regularLocalization_has_numerator (i : Fin 2) (f : regularCoordinateLocalization k i) :
-    ∃ (n : ℕ) (a : regularSL2Functions k), ∀ g : regularTorusPoints k,
-      (g.val i 0)^n * regularLocalizationEvaluation k i f g = a.val g.val := by
-  obtain ⟨n,a,ha⟩ := IsLocalization.Away.surj (regularFirstColumn k i) f
-  refine ⟨n,a,fun g => ?_⟩
-  have h := congrFun (congrArg (regularLocalizationEvaluation k i) ha) g
-  simp only [map_mul, map_pow, regularLocalizationEvaluation_algebraMap,
-    Pi.mul_apply, Pi.pow_apply] at h
-  change _ * ((regularFirstColumn k i).val g.val)^n = a.val g.val at h
-  rwa [regularFirstColumn_apply, mul_comm] at h
-
-end
-
- 
-
-lemma coprime_denominator_glue {R : Type*} [CommRing R] {a b : R}
-    (hab : IsCoprime a b) (n m : ℕ) (f g : R)
-    (hfg : b^m * f = a^n * g) :
-    ∃ h : R, a^n * h = f ∧ b^m * h = g := by
-  obtain ⟨c,d,hcd⟩ := (hab.pow : IsCoprime (a^n) (b^m))
-  refine ⟨c*f+d*g, ?_, ?_⟩
-  · calc
-      a^n * (c*f+d*g) = c*a^n*f + d*(a^n*g) := by ring
-      _ = c*a^n*f + d*(b^m*f) := by rw [hfg]
-      _ = (c*a^n+d*b^m)*f := by ring
-      _ = f := by rw [hcd, one_mul]
-  · calc
-      b^m * (c*f+d*g) = c*(b^m*f) + d*b^m*g := by ring
-      _ = c*(a^n*g) + d*b^m*g := by rw [hfg]
-      _ = (c*a^n+d*b^m)*g := by ring
-      _ = g := by rw [hcd, one_mul]
-
-universe u
-variable (k : Type u) [Field k] [Infinite k]
-
-omit [Infinite k] in
-lemma regularFirstColumns_coprime :
-    IsCoprime (regularFirstColumn k 0) (regularFirstColumn k 1) := by
-  refine ⟨regularEntry k 1 1, -regularEntry k 0 1, ?_⟩
-  apply Subtype.ext
-  funext g
-  change (regularEntry k 1 1).val g * (regularFirstColumn k 0).val g +
-    -(regularEntry k 0 1).val g * (regularFirstColumn k 1).val g = 1
-  rw [regularEntry_apply, regularEntry_apply, regularFirstColumn_apply, regularFirstColumn_apply]
-  have hd := g.property
-  rw [Matrix.det_fin_two] at hd
-  linear_combination hd
-
- 
-
-theorem regularTorus_glue (F : regularTorusPoints k → k)
-    (f₀ : regularCoordinateLocalization k 0) (f₁ : regularCoordinateLocalization k 1)
-    (h₀ : regularLocalizationEvaluation k 0 f₀ = F)
-    (h₁ : regularLocalizationEvaluation k 1 f₁ = F) :
-    ∃ f : regularSL2Functions k, regularTorusRestriction k f = F := by
-  obtain ⟨n,a,ha⟩ := regularLocalization_has_numerator k 0 f₀
-  obtain ⟨m,b,hb⟩ := regularLocalization_has_numerator k 1 f₁
-  have hab : (regularFirstColumn k 1)^m * a = (regularFirstColumn k 0)^n * b := by
-    apply regularTorusRestriction_injective k
-    funext g
-    change ((regularFirstColumn k 1).val g.val)^m * a.val g.val =
-      ((regularFirstColumn k 0).val g.val)^n * b.val g.val
-    rw [regularFirstColumn_apply, regularFirstColumn_apply, ← ha g, ← hb g, h₀, h₁]
-    ring
-  obtain ⟨f,hf,-⟩ := coprime_denominator_glue (regularFirstColumns_coprime k) n m a b hab
-  refine ⟨f,funext fun g => ?_⟩
-  apply mul_left_cancel₀ (pow_ne_zero n (g.property 0))
-  have h := congrArg (fun a : regularSL2Functions k => a.val g.val) hf
-  change ((regularFirstColumn k 0).val g.val)^n * f.val g.val = a.val g.val at h
-  rw [regularFirstColumn_apply, ← ha g, h₀] at h
-  exact h
-
-omit [Infinite k] in
-lemma subalgebra_polynomial_mem {Ω σ : Type*} (S : Subalgebra k (Ω → k))
-    (x : σ → Ω → k) (hx : ∀ i, x i ∈ S) (P : MvPolynomial σ k) :
-    (fun g => MvPolynomial.eval (fun i => x i g) P) ∈ S := by
-  induction P using MvPolynomial.induction_on with
-  | C c =>
-    convert S.algebraMap_mem c using 1
-    ext g
-    simp
-  | add P Q hP hQ =>
-    convert S.add_mem hP hQ using 1
-    ext g
-    simp
-  | mul_X P i hP =>
-    convert S.mul_mem hP (hx i) using 1
-    ext g
-    simp
-
-omit [Infinite k] in
-lemma regularSL2_pullback_mem (φ : SL2 k → SL2 k)
-    (A : Matrix (Fin 2) (Fin 2) (regularSL2Functions k))
-    (hA : ∀ g i j, (A i j).val g = φ g i j) (f : regularSL2Functions k) :
-    (fun g => f.val (φ g)) ∈ regularSL2Functions k := by
-  obtain ⟨P,hP⟩ := f.property
-  have h := subalgebra_polynomial_mem k (regularSL2Functions k)
-    (fun ij : Fin 2 × Fin 2 => (A ij.1 ij.2).val) (fun ij => (A ij.1 ij.2).property) P
-  have he : (fun g => MvPolynomial.eval (fun ij => (A ij.1 ij.2).val g) P) =
-      (fun g => f.val (φ g)) := by
-    funext g
-    simp only [hA]
-    exact (coordinateEvaluation_apply k P (φ g)).symm.trans (congrFun hP (φ g))
-  exact he ▸ h
-
-noncomputable def regularRightTranslation (h : SL2 k) (f : regularSL2Functions k) :
-    regularSL2Functions k :=
-  ⟨fun g => f.val (g*h), regularSL2_pullback_mem k (fun g => g*h)
-    (fun i j => ∑ l : Fin 2, (h l j) • regularEntry k i l) (by
-      intro g i j
-      rw [Fin.sum_univ_two]
-      change h 0 j * (regularEntry k i 0).val g + h 1 j * (regularEntry k i 1).val g =
-        ((g : Matrix (Fin 2) (Fin 2) k) * (h : Matrix (Fin 2) (Fin 2) k)) i j
-      rw [regularEntry_apply, regularEntry_apply, Matrix.mul_apply, Fin.sum_univ_two]
-      ring) f⟩
-
-omit [Infinite k] in
-lemma regularRightTranslation_apply (h g : SL2 k) (f : regularSL2Functions k) :
-    (regularRightTranslation k h f).val g = f.val (g*h) := rfl
-
-end FiberFunctorProof
-end
-
-end OAI
+import Mathlib
+import OAI.RepresentationTheory.RestrictedTilting.RegularActions
+
+namespace OAI
+
+/-! Torus density, regular localization and coprime denominator gluing. -/
+
+noncomputable section
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+open scoped BigOperators
+
+namespace FiberFunctorProof
+section
+variable (k : Type*) [Field k] [Infinite k]
+
+abbrev planeTorusPoints := {x : Fin 2 → k // ∀ i, x i ≠ 0}
+
+noncomputable def planeTorusEvaluation :
+    MvPolynomial (Fin 2) k →ₐ[k] (planeTorusPoints k → k) :=
+  MvPolynomial.aeval (fun i x => x.val i)
+
+omit [Infinite k] in
+lemma planeTorusEvaluation_apply (P : MvPolynomial (Fin 2) k) (x : planeTorusPoints k) :
+    planeTorusEvaluation k P x = MvPolynomial.eval x.val P := by
+  induction P using MvPolynomial.induction_on with
+  | C c => simp [planeTorusEvaluation]
+  | add P Q hp hq => simp only [map_add, Pi.add_apply, hp, hq]
+  | mul_X P i hp =>
+    simp only [map_mul, Pi.mul_apply, hp]
+    congr 1
+    simp [planeTorusEvaluation]
+
+theorem planeTorusEvaluation_injective : Function.Injective (planeTorusEvaluation k) := by
+  intro P Q h
+  apply MvPolynomial.funext_set (fun _ : Fin 2 => ({0} : Set k)ᶜ)
+    (fun _ => (Set.finite_singleton (0 : k)).infinite_compl)
+  intro x hx
+  have hx' : ∀ i, x i ≠ 0 := by
+    intro i
+    simpa only [Set.mem_compl_iff, Set.mem_singleton_iff] using hx i (Set.mem_univ i)
+  exact (planeTorusEvaluation_apply k P ⟨x,hx'⟩).symm.trans
+    ((congrFun h ⟨x,hx'⟩).trans (planeTorusEvaluation_apply k Q ⟨x,hx'⟩))
+
+omit [Infinite k] in
+lemma planeTorusEvaluation_X_isUnit (i : Fin 2) :
+    IsUnit (planeTorusEvaluation k (MvPolynomial.X i)) := by
+  refine ⟨⟨fun x => x.val i, fun x => (x.val i)⁻¹, ?_, ?_⟩, ?_⟩
+  · funext x; exact mul_inv_cancel₀ (x.property i)
+  · funext x; exact inv_mul_cancel₀ (x.property i)
+  · ext x; simp [planeTorusEvaluation]
+
+abbrev planeCoordinateChart (i : Fin 2) :=
+  Localization.Away (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+
+noncomputable def planeChartEvaluation (i : Fin 2) :
+    planeCoordinateChart k i →ₐ[k] (planeTorusPoints k → k) :=
+  IsLocalization.Away.liftAlgHom (MvPolynomial.X i) (planeTorusEvaluation_X_isUnit k i)
+
+omit [Infinite k] in
+lemma planeChartEvaluation_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
+    planeChartEvaluation k i
+      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
+      planeTorusEvaluation k P :=
+  IsLocalization.Away.lift_eq _ (planeTorusEvaluation_X_isUnit k i) _
+
+theorem planeChartEvaluation_injective (i : Fin 2) :
+    Function.Injective (planeChartEvaluation k i) := by
+  apply (IsLocalization.injective_iff_map_algebraMap_eq
+    (R := MvPolynomial (Fin 2) k) (S := planeCoordinateChart k i)
+    (Submonoid.powers (MvPolynomial.X i)) (planeChartEvaluation k i).toRingHom).mpr
+  intro P Q
+  constructor
+  · exact congrArg (planeChartEvaluation k i)
+  · intro h
+    have h' : planeTorusEvaluation k P = planeTorusEvaluation k Q := by
+      simpa only [AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+        planeChartEvaluation_algebraMap] using h
+    exact congrArg (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i))
+      (planeTorusEvaluation_injective k h')
+
+end
+
+section
+universe u
+variable (k : Type u) [Field k]
+
+ 
+lemma regularSL2_polynomial_path (f : regularSL2Functions k)
+    (g : k → SL2 k) (A : Matrix (Fin 2) (Fin 2) (Polynomial k))
+    (hA : ∀ t i j, (A i j).eval t = g t i j) :
+    ∃ P : Polynomial k, ∀ t, P.eval t = f.val (g t) := by
+  obtain ⟨Q,hQ⟩ := f.property
+  change coordinateEvaluation k Q = f.val at hQ
+  refine ⟨MvPolynomial.aeval (fun ij => A ij.1 ij.2) Q, ?_⟩
+  intro t
+  rw [← congrFun hQ (g t), coordinateEvaluation_apply]
+  clear hQ
+  induction Q using MvPolynomial.induction_on with
+  | C c => simp
+  | add Q R hQ hR => simp only [map_add, Polynomial.eval_add, hQ, hR]
+  | mul_X Q i hQ =>
+    simp only [map_mul, Polynomial.eval_mul, MvPolynomial.aeval_X, hA,
+      MvPolynomial.eval_X, hQ]
+
+noncomputable def regularLowerShear (t : k) : SL2 k :=
+  ⟨!![1,0;t,1], by simp [Matrix.det_fin_two]⟩
+
+lemma regularLowerShear_zero : regularLowerShear k 0 = 1 := by
+  apply Subtype.ext
+  ext i j
+  fin_cases i <;> fin_cases j <;> rfl
+
+lemma lowerShear_mul_entry (t : k) (g : SL2 k) (i j : Fin 2) :
+    (regularLowerShear k t * g) i j =
+      (!![g 0 0, g 0 1; t * g 0 0 + g 1 0, t * g 0 1 + g 1 1]) i j := by
+  change ((regularLowerShear k t : Matrix (Fin 2) (Fin 2) k) *
+    (g : Matrix (Fin 2) (Fin 2) k)) i j = _
+  fin_cases i <;> fin_cases j <;>
+    simp [regularLowerShear, Matrix.mul_apply, Fin.sum_univ_two]
+
+lemma upperShear_mul_entry (t : k) (g : SL2 k) (i j : Fin 2) :
+    (unipotent k t * g) i j =
+      (!![g 0 0 + t * g 1 0, g 0 1 + t * g 1 1; g 1 0, g 1 1]) i j := by
+  change ((unipotent k t : Matrix (Fin 2) (Fin 2) k) *
+    (g : Matrix (Fin 2) (Fin 2) k)) i j = _
+  fin_cases i <;> fin_cases j <;>
+    simp [unipotent, Matrix.mul_apply, Fin.sum_univ_two]
+
+ 
+
+theorem regularSL2_torus_dense [Infinite k] (f : regularSL2Functions k)
+    (hf : ∀ g : SL2 k, g 0 0 ≠ 0 → g 1 0 ≠ 0 → f.val g = 0) : f = 0 := by
+  have hfirst (g : SL2 k) (ha : g 0 0 ≠ 0) : f.val g = 0 := by
+    obtain ⟨P,hP⟩ := regularSL2_polynomial_path k f (fun t => regularLowerShear k t * g)
+      (!![Polynomial.C (g 0 0), Polynomial.C (g 0 1);
+        Polynomial.X * Polynomial.C (g 0 0) + Polynomial.C (g 1 0),
+        Polynomial.X * Polynomial.C (g 0 1) + Polynomial.C (g 1 1)]) (by
+          intro t i j
+          rw [lowerShear_mul_entry]
+          fin_cases i <;> fin_cases j <;> simp <;> ring)
+    have hzero : P = 0 := by
+      apply Polynomial.eq_zero_of_infinite_isRoot
+      apply ((Set.finite_singleton (-g 1 0 / g 0 0)).infinite_compl).mono
+      intro t ht
+      change P.eval t = 0
+      rw [hP]
+      apply hf
+      · simpa [lowerShear_mul_entry] using ha
+      · have ht' : t ≠ -g 1 0 / g 0 0 := ht
+        simp only [lowerShear_mul_entry]
+        intro hz
+        exact ht' ((eq_div_iff ha).mpr (eq_neg_of_add_eq_zero_left hz))
+    have h := hP 0
+    rw [hzero, Polynomial.eval_zero, regularLowerShear_zero, one_mul] at h
+    exact h.symm
+  apply Subtype.ext
+  funext g
+  change f.val g = 0
+  by_cases ha : g 0 0 = 0
+  · have hc : g 1 0 ≠ 0 := by
+      intro hc
+      have hd := g.property
+      rw [Matrix.det_fin_two, ha, hc] at hd
+      norm_num at hd
+    obtain ⟨P,hP⟩ := regularSL2_polynomial_path k f (fun t => unipotent k t * g)
+      (!![Polynomial.C (g 0 0) + Polynomial.X * Polynomial.C (g 1 0),
+        Polynomial.C (g 0 1) + Polynomial.X * Polynomial.C (g 1 1);
+        Polynomial.C (g 1 0), Polynomial.C (g 1 1)]) (by
+          intro t i j
+          rw [upperShear_mul_entry]
+          fin_cases i <;> fin_cases j <;> simp <;> ring)
+    have hzero : P = 0 := by
+      apply Polynomial.eq_zero_of_infinite_isRoot
+      apply ((Set.finite_singleton (0 : k)).infinite_compl).mono
+      intro t ht
+      change P.eval t = 0
+      rw [hP]
+      apply hfirst
+      simpa [upperShear_mul_entry, ha] using mul_ne_zero ht hc
+    have h := hP 0
+    rw [hzero, Polynomial.eval_zero, unipotent_zero, one_mul] at h
+    exact h.symm
+  · exact hfirst g ha
+
+
+noncomputable def regularEntry (i j : Fin 2) : regularSL2Functions k :=
+  coordinateToRegular k (MvPolynomial.X (i,j))
+
+lemma regularEntry_apply (i j : Fin 2) (g : SL2 k) :
+    (regularEntry k i j).val g = g i j := by
+  change coordinateEvaluation k (MvPolynomial.X (i,j)) g = _
+  rw [coordinateEvaluation_apply, MvPolynomial.eval_X]
+
+lemma regularFirstColumn_eq_entry (i : Fin 2) :
+    regularFirstColumn k i = regularEntry k i 0 := rfl
+
+abbrev regularTorusPoints := {g : SL2 k // ∀ i, g i 0 ≠ 0}
+
+noncomputable def regularTorusRestriction :
+    regularSL2Functions k →ₐ[k] (regularTorusPoints k → k) where
+  toFun f g := f.val g.val
+  map_zero' := rfl
+  map_one' := rfl
+  map_add' _ _ := rfl
+  map_mul' _ _ := rfl
+  commutes' _ := rfl
+
+lemma regularTorusRestriction_injective [Infinite k] :
+    Function.Injective (regularTorusRestriction k) := by
+  intro f h he
+  apply sub_eq_zero.mp
+  apply regularSL2_torus_dense k
+  intro g ha hc
+  exact sub_eq_zero.mpr (congrFun he ⟨g, by intro i; fin_cases i; exact ha; exact hc⟩)
+
+noncomputable def regularPlane :
+    MvPolynomial (Fin 2) k →ₐ[k] regularSL2Functions k :=
+  MvPolynomial.aeval (regularFirstColumn k)
+
+lemma regularPlane_evaluation (P : MvPolynomial (Fin 2) k) (g : SL2 k) :
+    (regularPlane k P).val g = MvPolynomial.eval (fun i => g i 0) P := by
+  induction P using MvPolynomial.induction_on with
+  | C c => simp [regularPlane]
+  | add P Q hP hQ =>
+    simp only [map_add, Subalgebra.coe_add, Pi.add_apply, hP, hQ]
+  | mul_X P i hP =>
+    rw [map_mul, MvPolynomial.eval_mul, MvPolynomial.eval_X]
+    simp only [Subalgebra.coe_mul, Pi.mul_apply]
+    rw [hP]
+    congr 1
+    simpa only [regularPlane, MvPolynomial.aeval_X] using regularFirstColumn_apply k i g
+
+abbrev regularCoordinateLocalization (i : Fin 2) :=
+  Localization.Away (regularFirstColumn k i)
+
+lemma regularTorusRestriction_coordinate_isUnit (i : Fin 2) :
+    IsUnit (regularTorusRestriction k (regularFirstColumn k i)) := by
+  refine ⟨⟨fun g => g.val i 0, fun g => (g.val i 0)⁻¹, ?_, ?_⟩, ?_⟩
+  · funext g; exact mul_inv_cancel₀ (g.property i)
+  · funext g; exact inv_mul_cancel₀ (g.property i)
+  · funext g; exact (regularFirstColumn_apply k i g.val).symm
+
+noncomputable def regularLocalizationEvaluation (i : Fin 2) :
+    regularCoordinateLocalization k i →ₐ[k] (regularTorusPoints k → k) :=
+  IsLocalization.Away.liftAlgHom (regularFirstColumn k i)
+    (regularTorusRestriction_coordinate_isUnit k i)
+
+lemma regularLocalizationEvaluation_algebraMap (i : Fin 2) (f : regularSL2Functions k) :
+    regularLocalizationEvaluation k i
+      (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i) f) =
+      regularTorusRestriction k f :=
+  IsLocalization.Away.lift_eq _ (regularTorusRestriction_coordinate_isUnit k i) _
+
+noncomputable def planeChartPullback (i : Fin 2) :
+    planeCoordinateChart k i →ₐ[k] regularCoordinateLocalization k i :=
+  IsLocalization.Away.liftAlgHom (MvPolynomial.X i : MvPolynomial (Fin 2) k)
+    (f := (IsScalarTower.toAlgHom k (regularSL2Functions k)
+      (regularCoordinateLocalization k i)).comp (regularPlane k)) (by
+        change IsUnit (algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i)
+          (regularPlane k (MvPolynomial.X i)))
+        simp only [regularPlane, MvPolynomial.aeval_X]
+        exact IsLocalization.Away.algebraMap_isUnit _)
+
+lemma planeChartPullback_algebraMap (i : Fin 2) (P : MvPolynomial (Fin 2) k) :
+    planeChartPullback k i
+      (algebraMap (MvPolynomial (Fin 2) k) (planeCoordinateChart k i) P) =
+      algebraMap (regularSL2Functions k) (regularCoordinateLocalization k i) (regularPlane k P) := by
+  unfold planeChartPullback
+  rw [IsLocalization.Away.liftAlgHom_apply, IsLocalization.Away.lift_eq]
+  rfl
+
+noncomputable def regularToPlaneTorus (g : regularTorusPoints k) : planeTorusPoints k :=
+  ⟨fun i => g.val i 0, g.property⟩
+
+lemma planeChartPullback_evaluation (i : Fin 2) (f : planeCoordinateChart k i)
+    (g : regularTorusPoints k) :
+    regularLocalizationEvaluation k i (planeChartPullback k i f) g =
+      planeChartEvaluation k i f (regularToPlaneTorus k g) := by
+  let ev : (planeTorusPoints k → k) →+* (regularTorusPoints k → k) :=
+    { toFun := fun f g => f (regularToPlaneTorus k g)
+      map_zero' := rfl
+      map_one' := rfl
+      map_add' := fun _ _ => rfl
+      map_mul' := fun _ _ => rfl }
+  have h : (regularLocalizationEvaluation k i).toRingHom.comp
+      (planeChartPullback k i).toRingHom = ev.comp (planeChartEvaluation k i).toRingHom := by
+    apply IsLocalization.ringHom_ext (Submonoid.powers (MvPolynomial.X i : MvPolynomial (Fin 2) k))
+    apply RingHom.ext
+    intro P
+    ext g
+    simp only [RingHom.comp_apply, AlgHom.toRingHom_eq_coe, RingHom.coe_coe,
+      planeChartPullback_algebraMap, regularLocalizationEvaluation_algebraMap,
+      planeChartEvaluation_algebraMap]
+    exact (regularPlane_evaluation k P g.val).trans
+      (planeTorusEvaluation_apply k P (regularToPlaneTorus k g)).symm
+  exact congrFun (RingHom.congr_fun h f) g
+
+noncomputable def regularCoordinateInverse (i : Fin 2) : regularCoordinateLocalization k i :=
+  IsLocalization.Away.invSelf (S := regularCoordinateLocalization k i) (regularFirstColumn k i)
+
+lemma regularCoordinateInverse_evaluation (i : Fin 2) (g : regularTorusPoints k) :
+    regularLocalizationEvaluation k i (regularCoordinateInverse k i) g = (g.val i 0)⁻¹ := by
+  have hmul := IsLocalization.Away.mul_invSelf (S := regularCoordinateLocalization k i)
+    (regularFirstColumn k i)
+  have h := congrFun (congrArg (regularLocalizationEvaluation k i) hmul) g
+  simp only [map_mul, map_one, Pi.mul_apply, Pi.one_apply,
+    regularLocalizationEvaluation_algebraMap] at h
+  change (regularFirstColumn k i).val g.val *
+    regularLocalizationEvaluation k i (regularCoordinateInverse k i) g = 1 at h
+  rw [regularFirstColumn_apply] at h
+  exact mul_left_cancel₀ (g.property i) (h.trans (mul_inv_cancel₀ (g.property i)).symm)
+
+ 
+
+lemma regularLocalization_has_numerator (i : Fin 2) (f : regularCoordinateLocalization k i) :
+    ∃ (n : ℕ) (a : regularSL2Functions k), ∀ g : regularTorusPoints k,
+      (g.val i 0)^n * regularLocalizationEvaluation k i f g = a.val g.val := by
+  obtain ⟨n,a,ha⟩ := IsLocalization.Away.surj (regularFirstColumn k i) f
+  refine ⟨n,a,fun g => ?_⟩
+  have h := congrFun (congrArg (regularLocalizationEvaluation k i) ha) g
+  simp only [map_mul, map_pow, regularLocalizationEvaluation_algebraMap,
+    Pi.mul_apply, Pi.pow_apply] at h
+  change _ * ((regularFirstColumn k i).val g.val)^n = a.val g.val at h
+  rwa [regularFirstColumn_apply, mul_comm] at h
+
+end
+
+ 
+
+lemma coprime_denominator_glue {R : Type*} [CommRing R] {a b : R}
+    (hab : IsCoprime a b) (n m : ℕ) (f g : R)
+    (hfg : b^m * f = a^n * g) :
+    ∃ h : R, a^n * h = f ∧ b^m * h = g := by
+  obtain ⟨c,d,hcd⟩ := (hab.pow : IsCoprime (a^n) (b^m))
+  refine ⟨c*f+d*g, ?_, ?_⟩
+  · calc
+      a^n * (c*f+d*g) = c*a^n*f + d*(a^n*g) := by ring
+      _ = c*a^n*f + d*(b^m*f) := by rw [hfg]
+      _ = (c*a^n+d*b^m)*f := by ring
+      _ = f := by rw [hcd, one_mul]
+  · calc
+      b^m * (c*f+d*g) = c*(b^m*f) + d*b^m*g := by ring
+      _ = c*(a^n*g) + d*b^m*g := by rw [hfg]
+      _ = (c*a^n+d*b^m)*g := by ring
+      _ = g := by rw [hcd, one_mul]
+
+universe u
+variable (k : Type u) [Field k] [Infinite k]
+
+omit [Infinite k] in
+lemma regularFirstColumns_coprime :
+    IsCoprime (regularFirstColumn k 0) (regularFirstColumn k 1) := by
+  refine ⟨regularEntry k 1 1, -regularEntry k 0 1, ?_⟩
+  apply Subtype.ext
+  funext g
+  change (regularEntry k 1 1).val g * (regularFirstColumn k 0).val g +
+    -(regularEntry k 0 1).val g * (regularFirstColumn k 1).val g = 1
+  rw [regularEntry_apply, regularEntry_apply, regularFirstColumn_apply, regularFirstColumn_apply]
+  have hd := g.property
+  rw [Matrix.det_fin_two] at hd
+  linear_combination hd
+
+ 
+
+theorem regularTorus_glue (F : regularTorusPoints k → k)
+    (f₀ : regularCoordinateLocalization k 0) (f₁ : regularCoordinateLocalization k 1)
+    (h₀ : regularLocalizationEvaluation k 0 f₀ = F)
+    (h₁ : regularLocalizationEvaluation k 1 f₁ = F) :
+    ∃ f : regularSL2Functions k, regularTorusRestriction k f = F := by
+  obtain ⟨n,a,ha⟩ := regularLocalization_has_numerator k 0 f₀
+  obtain ⟨m,b,hb⟩ := regularLocalization_has_numerator k 1 f₁
+  have hab : (regularFirstColumn k 1)^m * a = (regularFirstColumn k 0)^n * b := by
+    apply regularTorusRestriction_injective k
+    funext g
+    change ((regularFirstColumn k 1).val g.val)^m * a.val g.val =
+      ((regularFirstColumn k 0).val g.val)^n * b.val g.val
+    rw [regularFirstColumn_apply, regularFirstColumn_apply, ← ha g, ← hb g, h₀, h₁]
+    ring
+  obtain ⟨f,hf,-⟩ := coprime_denominator_glue (regularFirstColumns_coprime k) n m a b hab
+  refine ⟨f,funext fun g => ?_⟩
+  apply mul_left_cancel₀ (pow_ne_zero n (g.property 0))
+  have h := congrArg (fun a : regularSL2Functions k => a.val g.val) hf
+  change ((regularFirstColumn k 0).val g.val)^n * f.val g.val = a.val g.val at h
+  rw [regularFirstColumn_apply, ← ha g, h₀] at h
+  exact h
+
+omit [Infinite k] in
+lemma subalgebra_polynomial_mem {Ω σ : Type*} (S : Subalgebra k (Ω → k))
+    (x : σ → Ω → k) (hx : ∀ i, x i ∈ S) (P : MvPolynomial σ k) :
+    (fun g => MvPolynomial.eval (fun i => x i g) P) ∈ S := by
+  induction P using MvPolynomial.induction_on with
+  | C c =>
+    convert S.algebraMap_mem c using 1
+    ext g
+    simp
+  | add P Q hP hQ =>
+    convert S.add_mem hP hQ using 1
+    ext g
+    simp
+  | mul_X P i hP =>
+    convert S.mul_mem hP (hx i) using 1
+    ext g
+    simp
+
+omit [Infinite k] in
+lemma regularSL2_pullback_mem (φ : SL2 k → SL2 k)
+    (A : Matrix (Fin 2) (Fin 2) (regularSL2Functions k))
+    (hA : ∀ g i j, (A i j).val g = φ g i j) (f : regularSL2Functions k) :
+    (fun g => f.val (φ g)) ∈ regularSL2Functions k := by
+  obtain ⟨P,hP⟩ := f.property
+  have h := subalgebra_polynomial_mem k (regularSL2Functions k)
+    (fun ij : Fin 2 × Fin 2 => (A ij.1 ij.2).val) (fun ij => (A ij.1 ij.2).property) P
+  have he : (fun g => MvPolynomial.eval (fun ij => (A ij.1 ij.2).val g) P) =
+      (fun g => f.val (φ g)) := by
+    funext g
+    simp only [hA]
+    exact (coordinateEvaluation_apply k P (φ g)).symm.trans (congrFun hP (φ g))
+  exact he ▸ h
+
+noncomputable def regularRightTranslation (h : SL2 k) (f : regularSL2Functions k) :
+    regularSL2Functions k :=
+  ⟨fun g => f.val (g*h), regularSL2_pullback_mem k (fun g => g*h)
+    (fun i j => ∑ l : Fin 2, (h l j) • regularEntry k i l) (by
+      intro g i j
+      rw [Fin.sum_univ_two]
+      change h 0 j * (regularEntry k i 0).val g + h 1 j * (regularEntry k i 1).val g =
+        ((g : Matrix (Fin 2) (Fin 2) k) * (h : Matrix (Fin 2) (Fin 2) k)) i j
+      rw [regularEntry_apply, regularEntry_apply, Matrix.mul_apply, Fin.sum_univ_two]
+      ring) f⟩
+
+omit [Infinite k] in
+lemma regularRightTranslation_apply (h g : SL2 k) (f : regularSL2Functions k) :
+    (regularRightTranslation k h f).val g = f.val (g*h) := rfl
+
+end FiberFunctorProof
+end
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RelativeTrace.lean

@@ -1,49 +1,49 @@
-import Mathlib
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory Representation
-universe u v
-variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
-variable {V W U : Type u} [AddCommGroup V] [Module k V]
-  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
-
- 
-noncomputable def relativeTrace (ρ : Representation k G V) (σ : Representation k G W) :
-    (V →ₗ[k] W) →ₗ[k] (V →ₗ[k] W) := (Representation.linHom ρ σ).norm
-
-lemma relativeTrace_apply (ρ : Representation k G V) (σ : Representation k G W)
-    (t : V →ₗ[k] W) (v : V) :
-    relativeTrace ρ σ t v = ∑ g : G, σ g (t (ρ g⁻¹ v)) := by
-  simp [relativeTrace, Representation.norm, LinearMap.sum_apply]
-
-noncomputable def relativeTraceHom (ρ : Representation k G V) (σ : Representation k G W)
-    (t : V →ₗ[k] W) : ρ.IntertwiningMap σ where
-  toLinearMap := relativeTrace ρ σ t
-  isIntertwining' g := by
-    have h := (Representation.linHom ρ σ).self_norm_apply g t
-    have hh := congrArg (fun f : V →ₗ[k] W => f.comp (ρ g)) h
-    simpa only [Representation.linHom_apply, LinearMap.comp_assoc,
-      ← Module.End.mul_eq_comp, ← map_mul, inv_mul_cancel, map_one, Module.End.one_eq_id, LinearMap.comp_id, relativeTrace]
-      using hh.symm
-
-lemma relativeTrace_precomp (ρ : Representation k G V) (σ : Representation k G W)
-    (τ : Representation k G U) (a : ρ.IntertwiningMap σ) (t : W →ₗ[k] U) :
-    relativeTrace ρ τ (t.comp a.toLinearMap) =
-      (relativeTrace σ τ t).comp a.toLinearMap := by
-  ext v
-  simp only [relativeTrace_apply, LinearMap.comp_apply, IntertwiningMap.toLinearMap_apply,
-    a.isIntertwining]
-
-lemma relativeTrace_postcomp (ρ : Representation k G V) (σ : Representation k G W)
-    (τ : Representation k G U) (b : σ.IntertwiningMap τ) (t : V →ₗ[k] W) :
-    relativeTrace ρ τ (b.toLinearMap.comp t) =
-      b.toLinearMap.comp (relativeTrace ρ σ t) := by
-  ext v
-  simp only [relativeTrace_apply, LinearMap.comp_apply, IntertwiningMap.toLinearMap_apply,
-    map_sum, b.isIntertwining]
-
-end FiberFunctorProof
-
-end OAI
+import Mathlib
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory Representation
+universe u v
+variable {k : Type u} [Field k] {G : Type v} [Group G] [Fintype G]
+variable {V W U : Type u} [AddCommGroup V] [Module k V]
+  [AddCommGroup W] [Module k W] [AddCommGroup U] [Module k U]
+
+ 
+noncomputable def relativeTrace (ρ : Representation k G V) (σ : Representation k G W) :
+    (V →ₗ[k] W) →ₗ[k] (V →ₗ[k] W) := (Representation.linHom ρ σ).norm
+
+lemma relativeTrace_apply (ρ : Representation k G V) (σ : Representation k G W)
+    (t : V →ₗ[k] W) (v : V) :
+    relativeTrace ρ σ t v = ∑ g : G, σ g (t (ρ g⁻¹ v)) := by
+  simp [relativeTrace, Representation.norm, LinearMap.sum_apply]
+
+noncomputable def relativeTraceHom (ρ : Representation k G V) (σ : Representation k G W)
+    (t : V →ₗ[k] W) : ρ.IntertwiningMap σ where
+  toLinearMap := relativeTrace ρ σ t
+  isIntertwining' g := by
+    have h := (Representation.linHom ρ σ).self_norm_apply g t
+    have hh := congrArg (fun f : V →ₗ[k] W => f.comp (ρ g)) h
+    simpa only [Representation.linHom_apply, LinearMap.comp_assoc,
+      ← Module.End.mul_eq_comp, ← map_mul, inv_mul_cancel, map_one, Module.End.one_eq_id, LinearMap.comp_id, relativeTrace]
+      using hh.symm
+
+lemma relativeTrace_precomp (ρ : Representation k G V) (σ : Representation k G W)
+    (τ : Representation k G U) (a : ρ.IntertwiningMap σ) (t : W →ₗ[k] U) :
+    relativeTrace ρ τ (t.comp a.toLinearMap) =
+      (relativeTrace σ τ t).comp a.toLinearMap := by
+  ext v
+  simp only [relativeTrace_apply, LinearMap.comp_apply, IntertwiningMap.toLinearMap_apply,
+    a.isIntertwining]
+
+lemma relativeTrace_postcomp (ρ : Representation k G V) (σ : Representation k G W)
+    (τ : Representation k G U) (b : σ.IntertwiningMap τ) (t : V →ₗ[k] W) :
+    relativeTrace ρ τ (b.toLinearMap.comp t) =
+      b.toLinearMap.comp (relativeTrace ρ σ t) := by
+  ext v
+  simp only [relativeTrace_apply, LinearMap.comp_apply, IntertwiningMap.toLinearMap_apply,
+    map_sum, b.isIntertwining]
+
+end FiberFunctorProof
+
+end OAI

lean/OAI/RepresentationTheory/RestrictedTilting/RepProducts.lean

@@ -1,52 +1,52 @@
-import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
-
-namespace OAI
-
-namespace FiberFunctorProof
-open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
-universe u
-variable (k : Type u) [Field k]
-variable {G : Type u} [Group G]
-
-noncomputable def repProduct (A B : FDRep k G) : FDRep k G :=
-  FDRep.of (Representation.prod A.ρ B.ρ)
-
-noncomputable def repInl (A B : FDRep k G) : A ⟶ repProduct k A B :=
-  fdrepHom k (LinearMap.inl k A B) (by
-    intro g v
-    change (A.ρ g v, (0 : B)) = (A.ρ g v, B.ρ g 0)
-    rw [map_zero])
-noncomputable def repInr (A B : FDRep k G) : B ⟶ repProduct k A B :=
-  fdrepHom k (LinearMap.inr k A B) (by
-    intro g v
-    change ((0 : A), B.ρ g v) = (A.ρ g 0, B.ρ g v)
-    rw [map_zero])
-noncomputable def repFst (A B : FDRep k G) : repProduct k A B ⟶ A :=
-  fdrepHom k (LinearMap.fst k A B) (by intros; rfl)
-noncomputable def repSnd (A B : FDRep k G) : repProduct k A B ⟶ B :=
-  fdrepHom k (LinearMap.snd k A B) (by intros; rfl)
-
-lemma repProduct_shortExact (A B : FDRep k G) :
-    (ShortComplex.mk (repInl k A B) (repSnd k A B) (by
-      apply fdrep_hom_ext k; intro x; rfl)).ShortExact := by
-  apply fdrep_shortExact k _ (by intro a b h; exact congrArg Prod.fst h)
-    (by intro b; exact ⟨(0,b), rfl⟩)
-  ext x
-  constructor
-  · rintro ⟨a,rfl⟩; rfl
-  · intro h
-    exact ⟨x.1, Prod.ext rfl h.symm⟩
-
-lemma repProduct_decomposition (A B : FDRep k G) :
-    repFst k A B ≫ repInl k A B + repSnd k A B ≫ repInr k A B = 𝟙 _ := by
-  apply fdrep_hom_ext k
-  intro x
-  change (x.1, 0) + (0, x.2) = x
-  exact Prod.ext (add_zero _) (zero_add _)
-
-lemma IsTilting.product {A B : FDRep k (SL2 k)} (hA : IsTilting k A)
-    (hB : IsTilting k B) : IsTilting k (repProduct k A B) :=
-  hA.extension k hB (hA.1.prod k hB.1) _ _ _ (repProduct_shortExact k A B)
-end FiberFunctorProof
-
-end OAI
+import OAI.RepresentationTheory.RestrictedTilting.CompatibleJets
+
+namespace OAI
+
+namespace FiberFunctorProof
+open CategoryTheory CategoryTheory.MonoidalCategory CategoryTheory.Limits
+universe u
+variable (k : Type u) [Field k]
+variable {G : Type u} [Group G]
+
+noncomputable def repProduct (A B : FDRep k G) : FDRep k G :=
+  FDRep.of (Representation.prod A.ρ B.ρ)
+
+noncomputable def repInl (A B : FDRep k G) : A ⟶ repProduct k A B :=
+  fdrepHom k (LinearMap.inl k A B) (by
+    intro g v
+    change (A.ρ g v, (0 : B)) = (A.ρ g v, B.ρ g 0)
+    rw [map_zero])
+noncomputable def repInr (A B : FDRep k G) : B ⟶ repProduct k A B :=
+  fdrepHom k (LinearMap.inr k A B) (by
+    intro g v
+    change ((0 : A), B.ρ g v) = (A.ρ g 0, B.ρ g v)
+    rw [map_zero])
+noncomputable def repFst (A B : FDRep k G) : repProduct k A B ⟶ A :=
+  fdrepHom k (LinearMap.fst k A B) (by intros; rfl)
+noncomputable def repSnd (A B : FDRep k G) : repProduct k A B ⟶ B :=
+  fdrepHom k (LinearMap.snd k A B) (by intros; rfl)
+
+lemma repProduct_shortExact (A B : FDRep k G) :
+    (ShortComplex.mk (repInl k A B) (repSnd k A B) (by
+      apply fdrep_hom_ext k; intro x; rfl)).ShortExact := by
+  apply fdrep_shortExact k _ (by intro a b h; exact congrArg Prod.fst h)
+    (by intro b; exact ⟨(0,b), rfl⟩)
+  ext x
+  constructor
+  · rintro ⟨a,rfl⟩; rfl
+  · intro h
+    exact ⟨x.1, Prod.ext rfl h.symm⟩
+
+lemma repProduct_decomposition (A B : FDRep k G) :
+    repFst k A B ≫ repInl k A B + repSnd k A B ≫ repInr k A B = 𝟙 _ := by
+  apply fdrep_hom_ext k
+  intro x
+  change (x.1, 0) + (0, x.2) = x
+  exact Prod.ext (add_zero _) (zero_add _)
+
+lemma IsTilting.product {A B : FDRep k (SL2 k)} (hA : IsTilting k A)
+    (hB : IsTilting k B) : IsTilting k (repProduct k A B) :=
+  hA.extension k hB (hA.1.prod k hB.1) _ _ _ (repProduct_shortExact k A B)
+end FiberFunctorProof
+
+end OAI