| import OAI.Algebra.AuslanderReiten.Tensor.EnvelopingBalancedMap |
|
|
| 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] |
|
|
| abbrev regularObject : ModuleCat.{u} (R ⊗[k] Rᵐᵒᵖ) := |
| ModuleCat.of (R ⊗[k] Rᵐᵒᵖ) (R ⊗[k] Rᵐᵒᵖ) |
|
|
| private def unopAction : Rᵐᵒᵖ →ₗ[k] X →ₗ[k] X where |
| toFun b := |
| { toFun := fun x => b.unop • x |
| map_add' := smul_add b.unop |
| map_smul' := by intros; exact smul_comm _ _ _ } |
| map_add' b c := by ext x; exact add_smul b.unop c.unop x |
| map_smul' c b := by |
| ext x |
| change (c • b.unop) • x = c • (b.unop • x) |
| exact smul_assoc c b.unop x |
|
|
| private def regularRaw : (R ⊗[k] Rᵐᵒᵖ) →ₗ[k] X →ₗ[k] (R ⊗[k] X) := |
| TensorProduct.lift |
| { toFun := fun a => |
| { toFun := fun b => (TensorProduct.mk k R X a).comp (unopAction k R X b) |
| map_add' := by intros; ext x; simp [unopAction, add_smul, TensorProduct.tmul_add] |
| map_smul' := by intros; ext x; simp [unopAction] } |
| map_add' := by intros; ext b x; simp |
| map_smul' := by intros; ext b x; simp } |
|
|
| @[simp] private theorem regularRaw_tmul (a : R) (b : Rᵐᵒᵖ) (x : X) : |
| regularRaw k R X (a ⊗ₜ[k] b) x = a ⊗ₜ[k] (b.unop • x) := rfl |
|
|
| private def regularBilinear : EnvelopingBimodule k R (regularObject k R) →ₗ[k] |
| X →ₗ[k] (R ⊗[k] X) := |
| (regularRaw k R X).comp (scalarEquiv (regularObject k R)).toLinearMap |
|
|
| private theorem regularBilinear_balance |
| (f : EnvelopingBimodule k R (regularObject k R)) (r : R) (x : X) : |
| regularBilinear k R X (MulOpposite.op r • f) x = |
| regularBilinear k R X f (r • x) := by |
| rcases f with ⟨f⟩ |
| induction f using TensorProduct.inductionOn with |
| | add f g hf hg => |
| change regularRaw k R X (((1 : R) ⊗ₜ[k] MulOpposite.op r) * (f + g)) x = |
| regularRaw k R X (f + g) (r • x) |
| simp only [mul_add, _root_.map_add, LinearMap.add_apply] at * |
| exact congrArg₂ (· + ·) hf hg |
| | tmul a b => |
| change regularRaw k R X (((1 : R) ⊗ₜ[k] MulOpposite.op r) * (a ⊗ₜ[k] b)) x = |
| regularRaw k R X (a ⊗ₜ[k] b) (r • x) |
| simp only [Algebra.TensorProduct.tmul_mul_tmul, one_mul, regularRaw_tmul, |
| MulOpposite.unop_mul, MulOpposite.unop_op, mul_smul] |
|
|
| private theorem regularBilinear_left |
| (r : R) (f : EnvelopingBimodule k R (regularObject k R)) (x : X) : |
| regularBilinear k R X (r • f) x = r • regularBilinear k R X f x := by |
| rcases f with ⟨f⟩ |
| induction f using TensorProduct.inductionOn with |
| | add f g hf hg => |
| change regularRaw k R X ((r ⊗ₜ[k] (1 : Rᵐᵒᵖ)) * (f + g)) x = |
| r • regularRaw k R X (f + g) x |
| simp only [mul_add, _root_.map_add, LinearMap.add_apply, smul_add] at * |
| exact congrArg₂ (· + ·) hf hg |
| | tmul a b => |
| change regularRaw k R X ((r ⊗ₜ[k] (1 : Rᵐᵒᵖ)) * (a ⊗ₜ[k] b)) x = |
| r • regularRaw k R X (a ⊗ₜ[k] b) x |
| simp only [Algebra.TensorProduct.tmul_mul_tmul, one_mul, regularRaw_tmul, |
| TensorProduct.smul_tmul', smul_eq_mul] |
|
|
| def regularEvaluation : |
| BalancedTensor k R (EnvelopingBimodule k R (regularObject k R)) X →ₗ[R] |
| R ⊗[k] X := |
| BalancedTensor.liftLeft (regularBilinear k R X) |
| (regularBilinear_balance k R X) (regularBilinear_left k R X) |
|
|
| @[simp] theorem regularEvaluation_tmul (a : R) (b : Rᵐᵒᵖ) (x : X) : |
| regularEvaluation k R X (BalancedTensor.tmul ⟨a ⊗ₜ[k] b⟩ x) = |
| a ⊗ₜ[k] (b.unop • x) := rfl |
|
|
| private def regularInclusion : R →ₗ[k] EnvelopingBimodule k R (regularObject k R) where |
| toFun a := ⟨a ⊗ₜ[k] (1 : Rᵐᵒᵖ)⟩ |
| map_add' a b := by ext; exact TensorProduct.add_tmul a b 1 |
| map_smul' c a := by ext; exact TensorProduct.smul_tmul' c a 1 |
|
|
| private def regularInverse : R ⊗[k] X →ₗ[k] |
| BalancedTensor k R (EnvelopingBimodule k R (regularObject k R)) X := |
| TensorProduct.lift ((BalancedTensor.mk (k := k) (R := R)).comp (regularInclusion k R)) |
|
|
| omit [IsScalarTower k R X] in |
| @[simp] private theorem regularInverse_tmul (a : R) (x : X) : |
| regularInverse k R X (a ⊗ₜ[k] x) = |
| BalancedTensor.tmul (⟨a ⊗ₜ[k] (1 : Rᵐᵒᵖ)⟩ : EnvelopingBimodule k R (regularObject k R)) x := rfl |
|
|
| private theorem regularInverse_evaluation |
| (z : BalancedTensor k R (EnvelopingBimodule k R (regularObject k R)) X) : |
| regularInverse k R X (regularEvaluation k R X z) = z := by |
| 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 => |
| rcases f with ⟨f⟩ |
| induction f using TensorProduct.inductionOn with |
| | add f g hf hg => |
| change regularInverse k R X (regularEvaluation k R X |
| (BalancedTensor.tmul ((⟨f⟩ : EnvelopingBimodule k R (regularObject k R)) + ⟨g⟩) x)) = |
| BalancedTensor.tmul ((⟨f⟩ : EnvelopingBimodule k R (regularObject k R)) + ⟨g⟩) x |
| simpa only [BalancedTensor.add_tmul, _root_.map_add] using congrArg₂ (· + ·) hf hg |
| | tmul a b => |
| rw [regularEvaluation_tmul, regularInverse_tmul, ← BalancedTensor.balance] |
| congr 1 |
| apply EnvelopingBimodule.ext |
| change (((1 : R) ⊗ₜ[k] MulOpposite.op b.unop) * (a ⊗ₜ[k] (1 : Rᵐᵒᵖ))) = a ⊗ₜ[k] b |
| simp only [MulOpposite.op_unop, Algebra.TensorProduct.tmul_mul_tmul, one_mul, mul_one] |
|
|
| private theorem regularEvaluation_inverse (z : R ⊗[k] X) : |
| regularEvaluation k R X (regularInverse k R X z) = z := by |
| induction z using TensorProduct.inductionOn with |
| | add z w hz hw => simp only [_root_.map_add, hz, hw] |
| | tmul a x => simp only [regularInverse_tmul, regularEvaluation_tmul, MulOpposite.unop_one, one_smul] |
|
|
| def regularEquiv : |
| BalancedTensor k R (EnvelopingBimodule k R (regularObject k R)) X ≃ₗ[R] R ⊗[k] X where |
| __ := regularEvaluation k R X |
| invFun := regularInverse k R X |
| left_inv := regularInverse_evaluation k R X |
| right_inv := regularEvaluation_inverse k R X |
|
|
| end ArExplicit.EnvelopingBimodule |
|
|
| end |
|
|
| end OAI |
|
|
