| import OAI.Algebra.Finitistic.Ordinary.OrdinaryFreeTensorExactness | |
| namespace OAI | |
| noncomputable section | |
| namespace LittleFinitistic.BalancedTensor.FreeLeft | |
| universe u | |
| variable {k A : Type u} [Field k] [Ring A] [Algebra k A] | |
| variable (I M : Type u) [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M] | |
| [IsScalarTower k Aᵐᵒᵖ M] | |
| /-- A coefficient of a free left module acts on the right tensor factor. -/ | |
| def coefficientAction : A →ₗ[k] M →ₗ[k] M := | |
| (Algebra.lsmul k k M).toLinearMap.comp (MulOpposite.opLinearEquiv k).toLinearMap | |
| def evaluateBilinear : M →ₗ[k] (I →₀ A) →ₗ[k] (I →₀ M) := | |
| (Finsupp.lsum k (fun i => | |
| (coefficientAction (k := k) (A := A) M).compr₂ (Finsupp.lsingle i))).flip | |
| @[simp] theorem evaluateBilinear_single (i : I) (a : A) (m : M) : | |
| evaluateBilinear (k := k) I M m (Finsupp.single i a) = | |
| Finsupp.single i (MulOpposite.op a • m) := by | |
| simp only [evaluateBilinear,LinearMap.flip_apply,Finsupp.lsum_single] | |
| rfl | |
| def evaluation : Tensor k A M (I →₀ A) →ₗ[k] (I →₀ M) := | |
| lift (evaluateBilinear (k := k) I M) (by | |
| intro a m n | |
| induction n using Finsupp.induction_linear with | |
| | zero => simp only [smul_zero,map_zero] | |
| | add x y hx hy => simp only [smul_add,map_add,hx,hy] | |
| | single i x => | |
| rw [Finsupp.smul_single,evaluateBilinear_single,evaluateBilinear_single] | |
| change Finsupp.single i (MulOpposite.op x • (MulOpposite.op a • m)) = | |
| Finsupp.single i (MulOpposite.op (a*x) • m) | |
| rw [← mul_smul,MulOpposite.op_mul]) | |
| @[simp] theorem evaluation_single (i : I) (a : A) (m : M) : | |
| evaluation (k := k) I M (mk k A M (I →₀ A) m (Finsupp.single i a)) = | |
| Finsupp.single i (MulOpposite.op a • m) := evaluateBilinear_single I M i a m | |
| def insertion : (I →₀ M) →ₗ[k] Tensor k A M (I →₀ A) := | |
| Finsupp.lsum k (fun i => (mk k A M (I →₀ A)).flip (Finsupp.single i 1)) | |
| omit [IsScalarTower k Aᵐᵒᵖ M] in | |
| @[simp] theorem insertion_single (i : I) (m : M) : | |
| insertion (k := k) (A := A) I M (Finsupp.single i m) = | |
| mk k A M (I →₀ A) m (Finsupp.single i 1) := by | |
| simp only [insertion,Finsupp.lsum_single,LinearMap.flip_apply] | |
| theorem evaluation_insertion (z : I →₀ M) : | |
| evaluation (k := k) (A := A) I M (insertion I M z) = z := by | |
| induction z using Finsupp.induction_linear with | |
| | zero => simp only [map_zero] | |
| | add x y hx hy => simp only [map_add,hx,hy] | |
| | single i m => rw [insertion_single,evaluation_single,MulOpposite.op_one,one_smul] | |
| theorem insertion_evaluation (z : Tensor k A M (I →₀ A)) : | |
| insertion I M (evaluation (k := k) I M z) = z := by | |
| induction z using BalancedTensor.induction_on with | |
| | hz => simp only [map_zero] | |
| | ht m n => | |
| induction n using Finsupp.induction_linear with | |
| | zero => simp only [map_zero] | |
| | add x y hx hy => simp only [map_add,hx,hy] | |
| | single i a => | |
| rw [evaluation_single,insertion_single,balance] | |
| congr 1 | |
| rw [Finsupp.smul_single,smul_eq_mul,mul_one] | |
| | ha x y hx hy => simp only [map_add,hx,hy] | |
| /-- Tensor with an arbitrary free left module is the direct sum of the right module. -/ | |
| def equivalence : Tensor k A M (I →₀ A) ≃ₗ[k] (I →₀ M) where | |
| __ := evaluation (k := k) I M | |
| invFun := insertion I M | |
| left_inv := insertion_evaluation I M | |
| right_inv := evaluation_insertion I M | |
| variable {M} {M' M'' : Type u} | |
| variable [AddCommGroup M'] [Module k M'] [Module Aᵐᵒᵖ M'] [IsScalarTower k Aᵐᵒᵖ M'] | |
| variable [AddCommGroup M''] [Module k M''] [Module Aᵐᵒᵖ M''] [IsScalarTower k Aᵐᵒᵖ M''] | |
| theorem evaluation_naturality (f : M →ₗ[Aᵐᵒᵖ] M') (z : Tensor k A M (I →₀ A)) : | |
| evaluation (k := k) I M' (mapLeft (I →₀ A) f z) = | |
| Finsupp.mapRange.linearMap (f.restrictScalars k) (evaluation (k := k) I M z) := by | |
| induction z using BalancedTensor.induction_on with | |
| | hz => simp only [map_zero] | |
| | ht m n => | |
| induction n using Finsupp.induction_linear with | |
| | zero => simp only [map_zero] | |
| | add x y hx hy => simp only [map_add,hx,hy] | |
| | single i a => | |
| simp only [mapLeft_mk,evaluation_single] | |
| ext j | |
| change (Finsupp.single i (MulOpposite.op a • f m)) j = | |
| (Finsupp.mapRange f f.map_zero (Finsupp.single i (MulOpposite.op a • m))) j | |
| rw [Finsupp.mapRange_single, f.map_smul] | |
| | ha x y hx hy => simp only [map_add,hx,hy] | |
| /-- Free left tensor preserves exact sequences of right modules. -/ | |
| theorem tensor_exact (f : M →ₗ[Aᵐᵒᵖ] M') (g : M' →ₗ[Aᵐᵒᵖ] M'') | |
| (h : Function.Exact f g) : | |
| Function.Exact (mapLeft (k := k) (I →₀ A) f) (mapLeft (k := k) (I →₀ A) g) := by | |
| intro z | |
| constructor | |
| · intro hz | |
| have hz' : Finsupp.mapRange.linearMap (g.restrictScalars k) (evaluation (k := k) I M' z) = 0 := by | |
| rw [← evaluation_naturality,hz,map_zero] | |
| obtain ⟨y,hy⟩ := (Free.finsupp_exact (k := k) I f g h _).mp hz' | |
| refine ⟨(equivalence (k := k) (A := A) I M).symm y, ?_⟩ | |
| apply (equivalence (k := k) (A := A) I M').injective | |
| change evaluation (k := k) I M' (mapLeft (I →₀ A) f | |
| ((equivalence (k := k) (A := A) I M).symm y)) = _ | |
| rw [evaluation_naturality] | |
| change Finsupp.mapRange.linearMap (f.restrictScalars k) | |
| ((equivalence (k := k) (A := A) I M) ((equivalence (k := k) (A := A) I M).symm y)) = _ | |
| rw [LinearEquiv.apply_symm_apply] | |
| exact hy | |
| · rintro ⟨y,rfl⟩ | |
| induction y using BalancedTensor.induction_on with | |
| | hz => simp only [map_zero] | |
| | ht m n => | |
| rw [mapLeft_mk,mapLeft_mk,(h (f m)).mpr ⟨m,rfl⟩,map_zero,LinearMap.zero_apply] | |
| | ha x y hx hy => simp only [map_add,hx,hy,add_zero] | |
| end LittleFinitistic.BalancedTensor.FreeLeft | |
| end | |
| end OAI | |