openAI-math-dataset / lean /OAI /AlgebraicGeometry /CharacterVarieties /Foundation /ReorderedSolutions.lean
| import OAI.AlgebraicGeometry.CharacterVarieties.Foundation.Hurwitz | |
| namespace OAI | |
| noncomputable section | |
| open scoped Classical Matrix | |
| namespace IntegralCharacterVarieties.MatrixIso | |
| open scoped Classical Matrix | |
| variable {A : Type*} [CommRing A] {n : ℕ} | |
| lemma unit_injective : Function.Injective (unit (R:=A) (α:=Fin n)) := by | |
| intro x y h | |
| apply Units.ext | |
| exact congrArg MatrixIso.val h | |
| end IntegralCharacterVarieties.MatrixIso | |
| namespace IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| open scoped Classical Matrix | |
| open HomTransport OccurrenceIncidence MatrixExpression | |
| variable {F S V R A : Type} {arity : S → ℕ} [CommRing R] [CommRing A] | |
| variable (D : Diagram F S V arity) (σ : ∀ f,Equiv.Perm (Fin (D.boundaryCount f))) | |
| variable (φ : R →+* A) | |
| variable (g : (e : D.Generator) → (Matrix (Fin (D.generatorRank e)) (Fin (D.generatorRank e)) A)ˣ) | |
| /-- Puncture scalars and genus are not changed by the re-basing. -/ | |
| def reorderPunctures (P : D.Punctures R) : (D.reorderBoundary σ).Punctures R := | |
| ⟨P.count,P.scalar⟩ | |
| lemma reorder_boundaryEdge_eval (f : F) (b : Fin (D.boundaryCount f)) | |
| (i : Fin (D.boundaryLength f (σ f b))) : | |
| ((D.reorderBoundary σ).boundaryEdgeWord f b i).eval φ (D.reorderGenerators σ g)= | |
| (D.boundaryEdgeWord f (σ f b) i).eval φ g := by | |
| apply MatrixIso.unit_injective | |
| erw [(D.reorderBoundary σ).boundaryEdge_iso,D.boundaryEdge_iso] | |
| rfl | |
| lemma reorder_boundaryWord_eval (f : F) (b : Fin (D.boundaryCount f)) : | |
| ((D.reorderBoundary σ).boundaryWord f b).eval φ (D.reorderGenerators σ g)= | |
| (D.boundaryWord f (σ f b)).eval φ g := by | |
| erw [(D.reorderBoundary σ).boundaryWord_eval_raw,D.boundaryWord_eval_raw] | |
| exact congrArg (fun x : Fin (D.boundaryLength f (σ f b)) → | |
| (Matrix (Fin (D.rank f)) (Fin (D.rank f)) A)ˣ => (List.ofFn x).reverse.prod) | |
| (funext fun i => D.reorder_boundaryEdge_eval σ φ g f b i) | |
| lemma reorder_parentWord_eval (s : S) : | |
| ((D.reorderBoundary σ).parentWord s).eval φ (D.reorderGenerators σ g)= | |
| (D.parentWord s).eval φ g := by | |
| apply MatrixIso.unit_injective | |
| unfold parentWord | |
| erw [Term.eval_cast_iso φ (D.reorderGenerators σ g) ((D.reorderBoundary σ).seamRank s), | |
| Term.eval_cast_iso φ g (D.seamRank s)] | |
| rfl | |
| lemma reorder_seamLeft_eval (s : S) : | |
| ((D.reorderBoundary σ).seamLeft s).eval φ (D.reorderGenerators σ g)= | |
| (D.seamLeft s).eval φ g := by | |
| simp only [seamLeft,Term.eval,D.reorder_parentWord_eval] | |
| rfl | |
| lemma reorder_seamRight_eval (s : S) : | |
| ((D.reorderBoundary σ).seamRight s).eval φ (D.reorderGenerators σ g)= | |
| (D.seamRight s).eval φ g := rfl | |
| lemma reorder_surfaceTarget_eval (P : D.Punctures R) (f : F) : | |
| ((D.reorderBoundary σ).surfaceTarget (D.reorderPunctures σ P) f).eval φ | |
| (D.reorderGenerators σ g)=(D.surfaceTarget P f).eval φ g := rfl | |
| lemma reorder_surfaceWord_eval (f : F) : | |
| ((D.reorderBoundary σ).surfaceWord f).eval φ (D.reorderGenerators σ g)= | |
| (List.ofFn (fun k => (D.commutatorWord f k).eval φ g)).prod* | |
| (List.ofFn (fun b => (D.boundaryWord f (σ f b)).eval φ g)).prod := by | |
| simp only [surfaceWord,Term.eval,wordProduct_eval_raw,List.map_ofFn,Function.comp_def] | |
| erw [show (fun b : Fin (D.boundaryCount f) => | |
| ((D.reorderBoundary σ).boundaryWord f b).eval φ (D.reorderGenerators σ g)) = | |
| (fun b => (D.boundaryWord f (σ f b)).eval φ g) from | |
| funext (D.reorder_boundaryWord_eval σ φ g f)] | |
| rfl | |
| /-- The choices depend only on the finite permutation, not on a solution or on a coefficient field. | |
| They are based path words. -/ | |
| def reorderPathWords (f : F) : Fin (D.boundaryCount f) → FreeGroup (Fin (D.boundaryCount f)) := | |
| (SurfaceSurgery.Hurwitz.finPresentation (σ f)).paths | |
| lemma reorderPathWords_spec (f : F) {H : Type} [Group H] | |
| (x : Fin (D.boundaryCount f) → H) : | |
| (List.ofFn (fun b => (FreeGroup.lift x) (D.reorderPathWords σ f (σ f b))*x (σ f b)* | |
| ((FreeGroup.lift x) (D.reorderPathWords σ f (σ f b)))⁻¹)).prod=(List.ofFn x).prod := | |
| SurfaceSurgery.Hurwitz.finPresentation_spec (σ f) x | |
| /-- Evaluate those same paths over an arbitrary coefficient ring. -/ | |
| def reorderCircleBases : D.CircleBases (R:=A) := fun ⟨f,b⟩ => | |
| MatrixIso.unit ((FreeGroup.lift (fun c => (D.boundaryWord f c).eval φ g)) | |
| (D.reorderPathWords σ f b)) | |
| def basedReorderGenerators := D.reorderGenerators σ | |
| (D.gaugeGenerators (D.reorderCircleBases σ φ g) g) | |
| lemma basedReorder_surfaceWord (f : F) : | |
| ((D.reorderBoundary σ).surfaceWord f).eval φ (D.basedReorderGenerators σ φ g)= | |
| (D.surfaceWord f).eval φ g := by | |
| rw [basedReorderGenerators,D.reorder_surfaceWord_eval] | |
| simp only [D.boundaryWord_gauge,reorderCircleBases,MatrixIso.toUnit_unit] | |
| rw [D.reorderPathWords_spec] | |
| simp only [surfaceWord,Term.eval,wordProduct_eval_raw,List.map_ofFn] | |
| rfl | |
| variable [Algebra R A] | |
| /-- Full sewn-diagram solution after arbitrary reordering of boundary circles. -/ | |
| def basedReorderSolution (P : D.Punctures R) (x : D.Solution P A) : | |
| (D.reorderBoundary σ).Solution (D.reorderPunctures σ P) A := by | |
| let G := D.reorderCircleBases σ (algebraMap R A) x.val.val | |
| refine ⟨⟨D.basedReorderGenerators σ (algebraMap R A) x.val.val,?_⟩,?_⟩ | |
| · intro j | |
| cases j with | |
| | inl f => | |
| change SameFramedFlag (fun _ => 0) | |
| (matrixUnitEquiv (((D.reorderBoundary σ).surfaceWord f).eval (algebraMap R A) | |
| (D.basedReorderGenerators σ (algebraMap R A) x.val.val))) | |
| (matrixUnitEquiv (((D.reorderBoundary σ).surfaceTarget (D.reorderPunctures σ P) f).eval | |
| (algebraMap R A) (D.basedReorderGenerators σ (algebraMap R A) x.val.val))) | |
| rw [D.basedReorder_surfaceWord] | |
| exact x.val.property (.inl f) | |
| | inr s => | |
| change SameFramedFlag (D.seamGrade s) | |
| (matrixUnitEquiv (((D.reorderBoundary σ).seamLeft s).eval (algebraMap R A) | |
| (D.reorderGenerators σ (D.gaugeGenerators G x.val.val)))) | |
| (matrixUnitEquiv (((D.reorderBoundary σ).seamRight s).eval (algebraMap R A) | |
| (D.reorderGenerators σ (D.gaugeGenerators G x.val.val)))) | |
| rw [D.reorder_seamLeft_eval,D.reorder_seamRight_eval] | |
| exact D.seamHolds_gauge (algebraMap R A) G x.val.val s (x.val.property (.inr s)) | |
| · intro v | |
| change ((D.reorderBoundary σ).vertexComparison | |
| (D.reorderGenerators σ (D.gaugeGenerators G x.val.val)) v).Holds | |
| rw [D.reorder_vertexComparison] | |
| exact D.vertexHolds_gauge G x.val.val x.property v | |
| end IntegralCharacterVarieties.SurfacePresentation.Diagram | |
| end | |
| end OAI | |