openAI-math-dataset / lean /OAI /AlgebraicGeometry /CharacterVarieties /Foundation /BoundaryNormalization.lean
| import OAI.AlgebraicGeometry.CharacterVarieties.Foundation.GaugeEquivalences | |
| namespace OAI | |
| noncomputable section | |
| open scoped Classical Matrix | |
| namespace IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| open scoped Classical Matrix | |
| open OccurrenceIncidence MatrixExpression SurfaceSurgery | |
| variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A] | |
| variable (D : Diagram F S V arity) (φ : R →+* A) | |
| variable (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ) | |
| /-- The explicit inverse prefix product at every boundary corner. -/ | |
| def normalizingBoundaryBases : D.BoundaryBases (A:=A) := fun f b i => | |
| MatrixIso.unit (prefixBasis (fun j => (D.boundaryEdgeWord f b j).eval φ g) i) | |
| def normalizingCorners : D.CornerBases (R:=A) := | |
| D.cornerBasesOfBoundary (D.normalizingBoundaryBases φ g) | |
| lemma normalizingCorners_based : CornerBases.Based D (D.normalizingCorners φ g) := by | |
| apply D.cornerBasesOfBoundary_based | |
| intro f b | |
| dsimp only [normalizingBoundaryBases] | |
| rw [prefixBasis_zero] | |
| apply MatrixIso.ext <;> ext i j <;> simp [MatrixIso.unit,MatrixIso.refl,Matrix.one_apply] | |
| /-- This changes all side and frame coordinates, so it respects every named quotient at every | |
| vertex, not just a list of boundary conjugacy classes. -/ | |
| def normalizeBoundaryGenerators := D.cornerGaugeGenerators (D.normalizingCorners φ g) g | |
| lemma normalized_boundaryEdge (f : F) (b : Fin (D.boundaryCount f)) | |
| (i : Fin (D.boundaryLength f b)) : | |
| (D.boundaryEdgeWord f b i).eval φ (D.normalizeBoundaryGenerators φ g)= | |
| if i.val+1<D.boundaryLength f b then 1 else (D.boundaryWord f b).eval φ g := by | |
| unfold normalizeBoundaryGenerators | |
| rw [D.boundaryEdge_cornerGauge] | |
| simp only [normalizingCorners,D.boundaryBasis_ofBoundary,normalizingBoundaryBases, | |
| MatrixIso.toUnit_unit] | |
| rw [prefix_gauge (D.boundaryPositive f b)] | |
| rw [D.boundaryWord_eval_raw] | |
| variable [Algebra R A] | |
| /-- A full solution in canonical boundary path coordinates. It is constructed from any old solution, | |
| uniformly over the full coefficient ring. -/ | |
| def normalizeBoundarySolution (P : D.Punctures R) (x : D.Solution P A) : D.Solution P A := | |
| D.basedCornerSolution (D.normalizingCorners (algebraMap R A) x.val.val) | |
| (D.normalizingCorners_based (algebraMap R A) x.val.val) P x | |
| /-- Exact forward coverage in the original full solution variety. -/ | |
| theorem normalizeBoundary_reconstruct (P : D.Punctures R) (x : D.Solution P A) : | |
| D.basedCornerSolution (fun a => (D.normalizingCorners (algebraMap R A) x.val.val a).symm) | |
| (D.basedCorner_inverse _ (D.normalizingCorners_based (algebraMap R A) x.val.val)) P | |
| (D.normalizeBoundarySolution P x)=x := by | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| exact D.cornerGaugeGenerators_inverse _ x.val.val | |
| theorem normalizeBoundarySolution_edge (P : D.Punctures R) (x : D.Solution P A) | |
| (f : F) (b : Fin (D.boundaryCount f)) (i : Fin (D.boundaryLength f b)) : | |
| (D.boundaryEdgeWord f b i).eval (algebraMap R A) (D.normalizeBoundarySolution P x).val.val= | |
| if i.val+1<D.boundaryLength f b then 1 else (D.boundaryWord f b).eval (algebraMap R A) x.val.val := | |
| D.normalized_boundaryEdge (algebraMap R A) x.val.val f b i | |
| end IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| namespace IntegralCharacterVarieties.SurfaceSurgery | |
| variable {G : Type*} [Group G] | |
| /-- The based normalization matrices are FORCED by the edge maps. There is no extra monodromy | |
| equation hidden in the last interval. -/ | |
| lemma prefixBasis_unique {n : ℕ} (hn : 0<n) (e C : Fin n → G) | |
| (h0 : C ⟨0,hn⟩=1) | |
| (hC : ∀ i : Fin n,i.val+1<n → | |
| C ⟨(i.val+1)%n,Nat.mod_lt _ hn⟩*e i*(C i)⁻¹=1) : | |
| C=prefixBasis e := by | |
| have hh : ∀ k : ℕ,∀ hk : k<n,C ⟨k,hk⟩=(prefixProduct (cycleEdge e) k)⁻¹ := by | |
| intro k | |
| induction k with | |
| | zero => intro hk; simpa using h0 | |
| | succ k ih => | |
| intro hk | |
| have hk' : k<n := by omega | |
| have hc := hC ⟨k,hk'⟩ hk | |
| simp only [Nat.mod_eq_of_lt hk] at hc | |
| have hd : C ⟨k+1,hk⟩*e ⟨k,hk'⟩=C ⟨k,hk'⟩ := mul_inv_eq_one.mp hc | |
| calc | |
| C ⟨k+1,hk⟩=(C ⟨k+1,hk⟩*e ⟨k,hk'⟩)*(e ⟨k,hk'⟩)⁻¹ := by simp [mul_assoc] | |
| _=C ⟨k,hk'⟩*(e ⟨k,hk'⟩)⁻¹ := by rw [hd] | |
| _=(prefixProduct (cycleEdge e) (k+1))⁻¹ := by | |
| rw [ih hk',prefixProduct_succ,←cycleEdge_at e ⟨k,hk'⟩,mul_inv_rev] | |
| funext i | |
| exact hh i.val i.isLt | |
| end IntegralCharacterVarieties.SurfaceSurgery | |
| namespace IntegralCharacterVarieties.MatrixIso | |
| open scoped Classical Matrix | |
| variable {R : Type*} [CommRing R] | |
| variable {α β γ δ : Type*} [Fintype α] [Fintype β] [Fintype γ] [Fintype δ] | |
| lemma reindex_injective (e : γ ≃ α) (f : δ ≃ β) : | |
| Function.Injective (fun x : MatrixIso R α β => x.reindex e f) := by | |
| intro x y h | |
| apply ext | |
| · ext i j | |
| simpa only [reindex,Matrix.submatrix_apply,Equiv.apply_symm_apply] using | |
| congrArg (fun z => z.val (f.symm i) (e.symm j)) h | |
| · ext i j | |
| simpa only [reindex,Matrix.submatrix_apply,Equiv.apply_symm_apply] using | |
| congrArg (fun z => z.inv (e.symm i) (f.symm j)) h | |
| end IntegralCharacterVarieties.MatrixIso | |
| namespace IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| open scoped Classical Matrix | |
| open OccurrenceIncidence MatrixExpression SurfaceSurgery | |
| variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A] | |
| variable (D : Diagram F S V arity) (φ : R →+* A) | |
| lemma boundaryCornerBasis_injective : | |
| Function.Injective (fun G : D.CornerBases (R:=A) => D.boundaryCornerBasis G) := by | |
| intro G H h | |
| funext a | |
| obtain ⟨⟨f,b,i⟩,rfl⟩ := D.boundarySide.surjective a | |
| have hh := congrFun (congrFun (congrFun h f) b) i | |
| exact MatrixIso.reindex_injective _ _ hh | |
| def IsBoundaryNormalized | |
| (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ) : Prop := | |
| ∀ f b (i : Fin (D.boundaryLength f b)),i.val+1<D.boundaryLength f b → | |
| (D.boundaryEdgeWord f b i).eval φ g=1 | |
| lemma normalize_isBoundaryNormalized | |
| (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ) : | |
| D.IsBoundaryNormalized φ (D.normalizeBoundaryGenerators φ g) := by | |
| intro f b i hi | |
| rw [D.normalized_boundaryEdge,ite_eq_left hi] | |
| lemma normalizingCorners_unique | |
| (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ) | |
| (G : D.CornerBases (R:=A)) (hG : CornerBases.Based D G) | |
| (hC : D.IsBoundaryNormalized φ (D.cornerGaugeGenerators G g)) : | |
| D.normalizingCorners φ g=G := by | |
| apply D.boundaryCornerBasis_injective | |
| funext f b i | |
| have hh := prefixBasis_unique (D.boundaryPositive f b) | |
| (fun j => (D.boundaryEdgeWord f b j).eval φ g) | |
| (fun j => (D.boundaryCornerBasis G f b j).toUnit) | |
| (by rw [hG f b]; apply Units.ext; ext j k; simp [MatrixIso.toUnit,MatrixIso.refl,Matrix.one_apply]) | |
| (by intro j hj; rw [←D.boundaryEdge_cornerGauge]; exact hC f b j hj) | |
| have hi := congrArg MatrixIso.unit (congrFun hh i) | |
| erw [MatrixIso.unit_toUnit] at hi | |
| simp only [normalizingCorners,D.boundaryBasis_ofBoundary,normalizingBoundaryBases] | |
| exact hi.symm | |
| variable [Algebra R A] | |
| /-- The canonical locus is a subtype of the full solution, retaining all old equations, all ordered | |
| vertices and all quotient identifications. -/ | |
| abbrev NormalizedSolution (P : D.Punctures R) (A : Type) [CommRing A] [Algebra R A] := | |
| {x : D.Solution P A // D.IsBoundaryNormalized (algebraMap R A) x.val.val} | |
| abbrev BasedCorners (A : Type) [CommRing A] := | |
| {G : D.CornerBases (R:=A) // CornerBases.Based D G} | |
| /-- Unique normalized full solution plus all independent based corner matrices. This is one global | |
| path-coordinate chart, not the missing cutting map. -/ | |
| def boundaryChart (P : D.Punctures R) : | |
| D.Solution P A ≃ D.NormalizedSolution P A × D.BasedCorners A where | |
| toFun x := (⟨D.normalizeBoundarySolution P x, | |
| D.normalize_isBoundaryNormalized (algebraMap R A) x.val.val⟩, | |
| ⟨D.normalizingCorners (algebraMap R A) x.val.val, | |
| D.normalizingCorners_based (algebraMap R A) x.val.val⟩) | |
| invFun z := D.basedCornerSolution (fun a => (z.2.val a).symm) | |
| (D.basedCorner_inverse z.2.val z.2.property) P z.1.val | |
| left_inv x := D.normalizeBoundary_reconstruct P x | |
| right_inv z := by | |
| let x := D.basedCornerSolution (fun a => (z.2.val a).symm) | |
| (D.basedCorner_inverse z.2.val z.2.property) P z.1.val | |
| have hx : D.basedCornerSolution z.2.val z.2.property P x=z.1.val := by | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| change D.cornerGaugeGenerators z.2.val | |
| (D.cornerGaugeGenerators (fun a => (z.2.val a).symm) z.1.val.val.val)=_ | |
| have hh := D.cornerGaugeGenerators_inverse (fun a => (z.2.val a).symm) z.1.val.val.val | |
| simpa only [MatrixIso.symm_symm_eq] using hh | |
| have hc : D.normalizingCorners (algebraMap R A) x.val.val=z.2.val := by | |
| apply D.normalizingCorners_unique (algebraMap R A) x.val.val z.2.val z.2.property | |
| change D.IsBoundaryNormalized (algebraMap R A) | |
| (D.basedCornerSolution z.2.val z.2.property P x).val.val | |
| rw [hx] | |
| exact z.1.property | |
| apply Prod.ext | |
| · apply Subtype.ext | |
| change D.normalizeBoundarySolution P x=z.1.val | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| change D.cornerGaugeGenerators (D.normalizingCorners (algebraMap R A) x.val.val) x.val.val=_ | |
| rw [hc] | |
| exact congrArg (fun y : D.Solution P A => y.val.val) hx | |
| · apply Subtype.ext | |
| exact hc | |
| end IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| end | |
| end OAI | |