| import OAI.Algebra.Finitistic.Bar.TwoSided | |
| import Mathlib.LinearAlgebra.Quotient.Basic | |
| namespace OAI | |
| open scoped TensorProduct | |
| open TensorProduct CategoryTheory | |
| noncomputable section | |
| namespace DerivedBar.Balanced | |
| universe u | |
| variable {k A D : Type u} [Field k] [Ring A] [Algebra k A] [Ring D] [Algebra k D] | |
| variable (f : A →ₐ[k] D) | |
| variable (V : Type u) [AddCommGroup V] [Module k V] [Module A V] [IsScalarTower k A V] | |
| /-- The balancing relations for the right A-action d·a = d*f(a). -/ | |
| def relations : Submodule D (D ⊗[k] V) := | |
| Submodule.span D {z | ∃ (d : D) (a : A) (v : V), | |
| z = (d * f a) ⊗ₜ[k] v - d ⊗ₜ[k] (a • v)} | |
| /-- Noncommutative balanced tensor D ⊗_A V, presented using tensors over the field. -/ | |
| abbrev tensor := (D ⊗[k] V) ⧸ relations f V | |
| /-- Its canonical D-linear quotient map. -/ | |
| def quotient : D ⊗[k] V →ₗ[D] tensor f V := (relations f V).mkQ | |
| omit [IsScalarTower k A V] in | |
| /-- The defining balanced relation, as an equality in the actual quotient module. -/ | |
| theorem balanced (d : D) (a : A) (v : V) : | |
| quotient f V ((d*f a) ⊗ₜ[k] v) = quotient f V (d ⊗ₜ[k] (a • v)) := by | |
| apply sub_eq_zero.mp | |
| rw [← map_sub] | |
| exact (Submodule.Quotient.mk_eq_zero _).mpr (Submodule.subset_span ⟨d, a, v, rfl⟩) | |
| section Maps | |
| variable (W U : Type u) [AddCommGroup W] [Module k W] [Module A W] [IsScalarTower k A W] | |
| [AddCommGroup U] [Module k U] [Module A U] [IsScalarTower k A U] | |
| /-- Balanced tensor acts on all A-linear maps. -/ | |
| theorem map_relations (h : V →ₗ[A] W) : relations f V ≤ | |
| ((quotient f W).comp (AlgebraTensorModule.lTensor D D (h.restrictScalars k))).ker := by | |
| apply Submodule.span_le.mpr | |
| rintro z ⟨d, a, v, rfl⟩ | |
| change quotient f W ((AlgebraTensorModule.lTensor D D (h.restrictScalars k)) | |
| ((d*f a) ⊗ₜ[k] v - d ⊗ₜ[k] (a • v))) = 0 | |
| simp only [map_sub, AlgebraTensorModule.lTensor_tmul, LinearMap.coe_restrictScalars, | |
| LinearMap.map_smul] | |
| rw [balanced, sub_self] | |
| def map (h : V →ₗ[A] W) : tensor f V →ₗ[D] tensor f W := | |
| (relations f V).liftQ | |
| ((quotient f W).comp (AlgebraTensorModule.lTensor D D (h.restrictScalars k))) | |
| (map_relations f V W h) | |
| @[simp] theorem map_quotient_tmul (h : V →ₗ[A] W) (d : D) (v : V) : | |
| map f V W h (quotient f V (d ⊗ₜ[k] v)) = quotient f W (d ⊗ₜ[k] h v) := rfl | |
| /-- Composition preservation for the actual balanced tensor, proved from its quotient presentation. -/ | |
| theorem map_comp (h : V →ₗ[A] W) (g : W →ₗ[A] U) : | |
| map f V U (g.comp h) = (map f W U g).comp (map f V W h) := by | |
| apply (relations f V).linearMap_qext | |
| apply AlgebraTensorModule.ext | |
| intro d v | |
| rfl | |
| @[simp] theorem map_zero : map f V W 0 = 0 := by | |
| apply (relations f V).linearMap_qext | |
| apply AlgebraTensorModule.ext | |
| intro d v | |
| change quotient f W (d ⊗ₜ[k] (0 : W)) = 0 | |
| rw [TensorProduct.tmul_zero, _root_.map_zero] | |
| @[simp] theorem map_id : map f V V LinearMap.id = LinearMap.id := by | |
| apply (relations f V).linearMap_qext | |
| apply AlgebraTensorModule.ext | |
| intro d v | |
| rfl | |
| end Maps | |
| variable (W : Type u) [AddCommGroup W] [Module k W] | |
| /-- Evaluation of D ⊗_k (A ⊗_k W) on the two leading coefficients. -/ | |
| def collapse : D ⊗[k] (A ⊗[k] W) →ₗ[D] D ⊗[k] W := | |
| (DerivedBar.action k D (D ⊗[k] W)).comp | |
| (AlgebraTensorModule.lTensor D D (FreeBaseChange.coefficient f W)) | |
| @[simp] theorem collapse_tmul (d : D) (z : A ⊗[k] W) : | |
| collapse f W (d ⊗ₜ[k] z) = d • FreeBaseChange.coefficient f W z := rfl | |
| /-- The evaluation kills all balancing relations, without commutativity of A or D. -/ | |
| theorem relations_le_ker_collapse : relations f (A ⊗[k] W) ≤ (collapse f W).ker := by | |
| apply Submodule.span_le.mpr | |
| rintro z ⟨d, a, v, rfl⟩ | |
| change collapse f W ((d*f a) ⊗ₜ[k] v - d ⊗ₜ[k] (a • v)) = 0 | |
| rw [map_sub, collapse_tmul, collapse_tmul, FreeBaseChange.coefficient_smul, | |
| mul_smul, sub_self] | |
| /-- Descent of coefficient evaluation to the balanced tensor. -/ | |
| def descend : tensor f (A ⊗[k] W) →ₗ[D] D ⊗[k] W := | |
| (relations f (A ⊗[k] W)).liftQ (collapse f W) (relations_le_ker_collapse f W) | |
| /-- The inverse inserts a unit A coefficient before taking the balanced quotient. -/ | |
| def insert : D ⊗[k] W →ₗ[D] tensor f (A ⊗[k] W) := | |
| (quotient f (A ⊗[k] W)).comp | |
| (AlgebraTensorModule.lTensor D D (TensorProduct.mk k A W 1)) | |
| @[simp] theorem descend_quotient (z : D ⊗[k] (A ⊗[k] W)) : | |
| descend f W (quotient f (A ⊗[k] W) z) = collapse f W z := rfl | |
| @[simp] theorem insert_tmul (d : D) (w : W) : | |
| insert f W (d ⊗ₜ[k] w) = quotient f (A ⊗[k] W) (d ⊗ₜ[k] (1 ⊗ₜ[k] w)) := rfl | |
| /-- One inverse identity of the actual balanced free-module tensor equivalence. -/ | |
| theorem descend_insert : (descend f W).comp (insert f W) = LinearMap.id := by | |
| apply AlgebraTensorModule.ext | |
| intro d w | |
| simp [LinearMap.comp_apply, TensorProduct.smul_tmul'] | |
| /-- The other inverse identity follows from balancing, not from flatness. -/ | |
| theorem insert_descend : (insert f W).comp (descend f W) = LinearMap.id := by | |
| apply (relations f (A ⊗[k] W)).linearMap_qext | |
| apply AlgebraTensorModule.ext | |
| intro d z | |
| induction z using TensorProduct.inductionOn with | |
| | add x y hx hy => simp_all [TensorProduct.tmul_add] | |
| | tmul a w => | |
| change insert f W (collapse f W (d ⊗ₜ[k] (a ⊗ₜ[k] w))) = | |
| quotient f (A ⊗[k] W) (d ⊗ₜ[k] (a ⊗ₜ[k] w)) | |
| rw [collapse_tmul, FreeBaseChange.coefficient_tmul, TensorProduct.smul_tmul', | |
| smul_eq_mul, insert_tmul, balanced] | |
| simp [TensorProduct.smul_tmul'] | |
| /-- The standard identification D ⊗_A (A ⊗_k W) ≅ D ⊗_k W for arbitrary algebras. -/ | |
| def freeEquiv : tensor f (A ⊗[k] W) ≃ₗ[D] D ⊗[k] W := | |
| LinearEquiv.ofLinearMap (descend f W) (insert f W) (descend_insert f W) (insert_descend f W) | |
| end DerivedBar.Balanced | |
| end | |
| end OAI | |