openAI-math-dataset / lean /OAI /Algebra /AuslanderReiten /Tensor /EnvelopingBalancedProjective.lean
| import OAI.Algebra.AuslanderReiten.Tensor.EnvelopingBalancedRegular | |
| import Mathlib.LinearAlgebra.TensorProduct.Basis | |
| import Mathlib.Algebra.Module.Projective | |
| import Mathlib.LinearAlgebra.Pi | |
| import Mathlib.RingTheory.Finiteness.Cardinality | |
| namespace OAI | |
| noncomputable section | |
| open CategoryTheory | |
| open scoped TensorProduct ModuleCat.Algebra | |
| namespace ArExplicit.EnvelopingBimodule | |
| universe u | |
| variable {k R : Type u} [Field k] [Ring R] [Algebra k R] | |
| variable (X : ModuleCat.{u} R) [Module k X] [IsScalarTower k R X] | |
| private instance finitePiProjective {V : Type u} [AddCommGroup V] [Module R V] | |
| [Module.Projective R V] (n : ℕ) : Module.Projective R (Fin n → V) := | |
| Module.Projective.of_equiv (DFinsupp.linearEquivFunOnFintype : | |
| (Π₀ _ : Fin n, V) ≃ₗ[R] (Fin n → V)) | |
| instance regular_projective : | |
| Module.Projective R (BalancedTensor k R (EnvelopingBimodule k R (regularObject k R)) X) := | |
| Module.Projective.of_equiv (regularEquiv k R X).symm | |
| variable (M : ModuleCat.{u} (R ⊗[k] Rᵐᵒᵖ)) | |
| variable [Module k M] [IsScalarTower k (R ⊗[k] Rᵐᵒᵖ) M] | |
| abbrev piObject (n : ℕ) : ModuleCat.{u} (R ⊗[k] Rᵐᵒᵖ) := | |
| ModuleCat.of (R ⊗[k] Rᵐᵒᵖ) (Fin n → M) | |
| def piProjection (n : ℕ) (i : Fin n) : piObject M n ⟶ M := | |
| ModuleCat.ofHom (LinearMap.proj i) | |
| def piInclusion (n : ℕ) (i : Fin n) : M ⟶ piObject M n := | |
| ModuleCat.ofHom (LinearMap.single (R ⊗[k] Rᵐᵒᵖ) (fun _ : Fin n => M) i) | |
| def tensorPiCoordinates (n : ℕ) : | |
| BalancedTensor k R (EnvelopingBimodule k R (piObject M n)) X →ₗ[R] | |
| (Fin n → BalancedTensor k R (EnvelopingBimodule k R M) X) := | |
| LinearMap.pi fun i => tensorMap X (piProjection M n i) | |
| def tensorPiRecombine (n : ℕ) : | |
| (Fin n → BalancedTensor k R (EnvelopingBimodule k R M) X) →ₗ[R] | |
| BalancedTensor k R (EnvelopingBimodule k R (piObject M n)) X := | |
| ∑ i, (tensorMap X (piInclusion M n i)).comp (LinearMap.proj i) | |
| omit [IsScalarTower k R X] in | |
| @[simp] theorem tensorPiRecombine_apply (n : ℕ) | |
| (v : Fin n → BalancedTensor k R (EnvelopingBimodule k R M) X) : | |
| tensorPiRecombine X M n v = ∑ i, tensorMap X (piInclusion M n i) (v i) := by | |
| simp only [tensorPiRecombine, LinearMap.sum_apply, LinearMap.comp_apply, LinearMap.proj_apply] | |
| private theorem pi_reconstruct (n : ℕ) (f : EnvelopingBimodule k R (piObject M n)) : | |
| ∑ i, map (piInclusion M n i) (map (piProjection M n i) f) = f := by | |
| apply EnvelopingBimodule.ext | |
| change (scalarEquiv (piObject M n)) (∑ i, map (piInclusion M n i) (map (piProjection M n i) f)) = f.value | |
| rw [_root_.map_sum] | |
| change (∑ i, Pi.single i (f.value i)) = f.value | |
| exact Finset.univ_sum_single f.value | |
| omit [IsScalarTower k R X] in | |
| theorem tensorPi_retraction (n : ℕ) : | |
| (tensorPiRecombine X M n).comp (tensorPiCoordinates X M n) = LinearMap.id := by | |
| apply LinearMap.ext | |
| intro z | |
| change tensorPiRecombine X M n (tensorPiCoordinates X M n z) = z | |
| induction z using BalancedTensor.induction_on with | |
| | zero => simp only [_root_.map_zero] | |
| | add z w hz hw => simp only [_root_.map_add, hz, hw] | |
| | tmul f x => | |
| rw [tensorPiRecombine_apply] | |
| change (∑ i, tensorMap X (piInclusion M n i) | |
| (tensorMap X (piProjection M n i) (BalancedTensor.tmul f x))) = BalancedTensor.tmul f x | |
| simp only [tensorMap_tmul] | |
| change (∑ i, ((BalancedTensor.mk (k := k) (R := R)).flip x) | |
| (map (piInclusion M n i) (map (piProjection M n i) f))) = _ | |
| rw [← _root_.map_sum, pi_reconstruct] | |
| rfl | |
| omit [IsScalarTower k R X] in | |
| theorem tensorPi_projective | |
| [Module.Projective R (BalancedTensor k R (EnvelopingBimodule k R M) X)] (n : ℕ) : | |
| Module.Projective R (BalancedTensor k R (EnvelopingBimodule k R (piObject M n)) X) := | |
| Module.Projective.of_split (R := R) (tensorPiCoordinates X M n) (tensorPiRecombine X M n) | |
| (tensorPi_retraction X M n) | |
| theorem tensor_projective [Module.Finite (R ⊗[k] Rᵐᵒᵖ) M] | |
| [Module.Projective (R ⊗[k] Rᵐᵒᵖ) M] : | |
| Module.Projective R (BalancedTensor k R (EnvelopingBimodule k R M) X) := by | |
| obtain ⟨n, p, hp⟩ := Module.Finite.exists_fin' (R ⊗[k] Rᵐᵒᵖ) M | |
| obtain ⟨s, hs⟩ := Module.projective_lifting_property p | |
| (LinearMap.id : M →ₗ[R ⊗[k] Rᵐᵒᵖ] M) hp | |
| let := regular_projective (k := k) (R := R) X | |
| let : Module.Projective R (BalancedTensor k R | |
| (EnvelopingBimodule k R (piObject (regularObject k R) n)) X) := | |
| tensorPi_projective X (regularObject k R) n | |
| apply Module.Projective.of_split (tensorMap X (ModuleCat.ofHom s)) | |
| (tensorMap X (ModuleCat.ofHom p)) | |
| rw [← tensorMap_comp] | |
| have hsp : ModuleCat.ofHom s ≫ ModuleCat.ofHom p = 𝟙 M := by | |
| apply ModuleCat.hom_ext | |
| exact hs | |
| rw [hsp, tensorMap_id] | |
| end ArExplicit.EnvelopingBimodule | |
| end | |
| end OAI | |