Download data/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryCompression.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 3.78 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryCompression.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryCompression.lean
-
curl -L -o OrdinaryCompression.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/Finitistic/Ordinary/OrdinaryCompression.lean
3.78 kB
| import OAI.Algebra.Finitistic.Ordinary.OrdinaryCochain | |
| import Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | |
| import Mathlib.Algebra.Homology.Additive | |
| import Mathlib.RingTheory.TensorProduct.Maps | |
| namespace OAI | |
| noncomputable section | |
| open CategoryTheory | |
| open scoped TensorProduct | |
| namespace LittleFinitistic.OrdinarySimulation | |
| universe u | |
| variable {k A : Type u} [Field k] [Ring A] [Algebra k A] | |
| /-- Forgetting to k uses the actual restriction-of-scalars functor on complexes. -/ | |
| abbrev underlyingComplex (P : CochainComplex (ModuleCat.{u} A) β€) : | |
| CochainComplex (ModuleCat.{u} k) β€ := | |
| ((ModuleCat.restrictScalars (algebraMap k A)).mapHomologicalComplex (.up β€)).obj P | |
| /-- Ordinary finite compression of the actual dg A-module P on [a,a+l]. | |
| Take A=B tensor Bα΅α΅α΅ for a genuine dg B-bimodule. -/ | |
| def Compression (P : CochainComplex (ModuleCat.{u} A) β€) (a : β€) (l : β) := | |
| β i : Fin (l+1), P.X (a + (i.val : β€)) | |
| namespace Compression | |
| variable (P : CochainComplex (ModuleCat.{u} A) β€) (a : β€) (l : β) | |
| instance : AddCommGroup (Compression P a l) := | |
| inferInstanceAs (AddCommGroup (β i : Fin (l+1), P.X (a + (i.val : β€)))) | |
| instance : Module k (Compression P a l) := | |
| inferInstanceAs (Module k (OrdinaryTerms (intervalTerms (underlyingComplex (k := k) P) a l))) | |
| instance : Module A (Compression P a l) := | |
| inferInstanceAs (Module A (β i : Fin (l+1), P.X (a + (i.val : β€)))) | |
| instance : Module (ChainAlgebra k l) (Compression P a l) := | |
| cochainModule (underlyingComplex (k := k) P) a l | |
| instance : IsScalarTower k (ChainAlgebra k l) (Compression P a l) := | |
| OrdinaryTerms.scalarTower _ _ (intervalDifferential_square (underlyingComplex (k := k) P) a l) | |
| instance scalarTowerA : IsScalarTower k A (Compression P a l) where | |
| smul_assoc c r v := by | |
| funext i | |
| change (c β’ r) β’ v i = (algebraMap k A c) β’ r β’ v i | |
| rw [Algebra.smul_def, mul_smul] | |
| instance : SMulCommClass (ChainAlgebra k l) A (Compression P a l) where | |
| smul_comm x r v := by | |
| let (n : β€) : Module k (P.X n) := Module.compHom _ (algebraMap k A) | |
| let (n : β€) : IsScalarTower k A (P.X n) := IsScalarTower.of_compHom k A (P.X n) | |
| let (i : Fin (l+1)) : Module A (intervalTerms (underlyingComplex (k := k) P) a l i) := inferInstanceAs (Module A (P.X (a + (i.val : β€)))) | |
| let (i : Fin (l+1)) : SMulCommClass k A (intervalTerms (underlyingComplex (k := k) P) a l i) := inferInstanceAs (SMulCommClass k A (P.X (a + (i.val : β€)))) | |
| change OrdinaryTerms.action (intervalTerms (underlyingComplex (k := k) P) a l) (intervalDifferential (underlyingComplex (k := k) P) a l) x (r β’ v) = r β’ OrdinaryTerms.action (intervalTerms (underlyingComplex (k := k) P) a l) (intervalDifferential (underlyingComplex (k := k) P) a l) x v | |
| apply OrdinaryTerms.action_commutes | |
| intro i j r v | |
| exact (P.d (a + (i.val : β€)) (a + (j.val : β€))).hom.map_smul r v | |
| /-- The commuting actions give the actual tensor-algebra representation. -/ | |
| def tensorAction : (A β[k] ChainAlgebra k l) ββ[k] Module.End k (Compression P a l) := | |
| Algebra.TensorProduct.lift (Algebra.lsmul k k (Compression P a l)) | |
| (Algebra.lsmul k k (Compression P a l)) (by | |
| intro r x | |
| ext v | |
| change r β’ (x β’ v) = x β’ (r β’ v) | |
| exact (smul_comm x r v).symm) | |
| @[simp] theorem tensorAction_tmul (r : A) (x : ChainAlgebra k l) (v : Compression P a l) : | |
| tensorAction (k := k) P a l (r ββ[k] x) v = r β’ (x β’ v) := rfl | |
| instance finiteDimensional [β n, FiniteDimensional k ((underlyingComplex (k := k) P).X n)] : | |
| FiniteDimensional k (Compression P a l) := | |
| inferInstanceAs (FiniteDimensional k (β i : Fin (l+1), (underlyingComplex (k := k) P).X (a+(i.val:β€)))) | |
| end Compression | |
| end LittleFinitistic.OrdinarySimulation | |
| end | |
| end OAI | |