File size: 5,725 Bytes
ae00908 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 | 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
|