| import OAI.Algebra.AuslanderReiten.Tensor.BalancedTensorMap |
|
|
| namespace OAI |
|
|
| namespace ArExplicit.BalancedTensor |
|
|
| variable {k R : Type*} [CommRing k] [Ring R] [Algebra k R] |
|
|
| section Left |
|
|
| variable {M : Type*} [AddCommGroup M] [Module k M] [Module R M] |
| variable [IsScalarTower k R M] |
|
|
| def leftAction : R →ₗ[k] M →ₗ[k] M where |
| toFun r := |
| { toFun := fun m => r • m |
| map_add' := smul_add r |
| map_smul' := fun c m => smul_comm r c m } |
| map_add' r s := by ext m; exact add_smul r s m |
| map_smul' c r := by ext m; exact smul_assoc c r m |
|
|
| def lunitMap : BalancedTensor k R R M →ₗ[R] M := |
| liftLeft leftAction (by intro x r m; exact mul_smul x r m) |
| (by intro s r m; exact mul_smul s r m) |
|
|
| @[simp] theorem lunitMap_tmul (r : R) (m : M) : |
| lunitMap (tmul r m : BalancedTensor k R R M) = r • m := rfl |
|
|
| def lunitInv : M →ₗ[R] BalancedTensor k R R M where |
| toFun m := tmul 1 m |
| map_add' := tmul_add 1 |
| map_smul' r m := by |
| change tmul (k := k) (R := R) 1 (r • m) = tmul (r * 1) m |
| rw [mul_one] |
| simpa using (balance (k := k) (R := R) (1 : R) r m).symm |
|
|
| def lunit : BalancedTensor k R R M ≃ₗ[R] M where |
| __ := lunitMap (k := k) (R := R) (M := M) |
| invFun := lunitInv |
| right_inv m := by simp [lunitInv] |
| left_inv z := by |
| change lunitInv (lunitMap z) = z |
| induction z using induction_on with |
| | zero => simp |
| | tmul r m => |
| change tmul (k := k) (R := R) 1 (r • m) = tmul r m |
| simpa using (balance (k := k) (R := R) (1 : R) r m).symm |
| | add x y hx hy => simp only [map_add, hx, hy] |
|
|
| @[simp] theorem lunit_tmul (r : R) (m : M) : |
| lunit (tmul r m : BalancedTensor k R R M) = r • m := rfl |
|
|
| end Left |
|
|
| section Right |
|
|
| variable {F : Type*} [AddCommGroup F] [Module k F] [Module Rᵐᵒᵖ F] |
| variable [IsScalarTower k Rᵐᵒᵖ F] |
|
|
| def rightAction : F →ₗ[k] R →ₗ[k] F where |
| toFun f := |
| { toFun := fun r => MulOpposite.op r • f |
| map_add' r s := by simp [add_smul] |
| map_smul' c r := by simp [MulOpposite.op_smul, smul_assoc] } |
| map_add' f g := by ext r; exact smul_add _ _ _ |
| map_smul' c f := by ext r; exact smul_comm _ _ _ |
|
|
| def runitMap : BalancedTensor k R F R →ₗ[k] F := |
| lift rightAction (by |
| intro f r s |
| change MulOpposite.op s • MulOpposite.op r • f = MulOpposite.op (r * s) • f |
| rw [MulOpposite.op_mul, mul_smul]) |
|
|
| @[simp] theorem runitMap_tmul (f : F) (r : R) : |
| runitMap (tmul f r : BalancedTensor k R F R) = MulOpposite.op r • f := rfl |
|
|
| def runit : BalancedTensor k R F R ≃ₗ[k] F where |
| __ := runitMap (k := k) (R := R) (F := F) |
| invFun f := tmul f 1 |
| right_inv f := by simp [runitMap_tmul] |
| left_inv z := by |
| change tmul (runitMap z) 1 = z |
| induction z using induction_on with |
| | zero => simp |
| | tmul f r => simpa using (balance (k := k) (R := R) f r (1 : R)) |
| | add x y hx hy => simpa only [map_add, add_tmul] using congrArg₂ (· + ·) hx hy |
|
|
| @[simp] theorem runit_tmul (f : F) (r : R) : |
| runit (tmul f r : BalancedTensor k R F R) = MulOpposite.op r • f := rfl |
|
|
| variable {S : Type*} [Ring S] [Module S F] |
| variable [SMulCommClass k S F] [SMulCommClass S Rᵐᵒᵖ F] |
|
|
| def runitLeft : BalancedTensor k R F R ≃ₗ[S] F where |
| __ := (runit (k := k) (R := R) (F := F)).toAddEquiv |
| map_smul' s z := by |
| change runit (s • z) = s • runit z |
| induction z using induction_on with |
| | zero => simp |
| | tmul f r => simpa only [smul_tmul, runit_tmul] using (smul_comm s (MulOpposite.op r) f).symm |
| | add x y hx hy => simp only [smul_add, map_add] at *; rw [hx, hy] |
|
|
| end Right |
|
|
| end ArExplicit.BalancedTensor |
|
|
| end OAI |
|
|
