Download data/lean/OAI/Algebra/AuslanderReiten/Tensor/EnvelopingBalancedRegular.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.22 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/AuslanderReiten/Tensor/EnvelopingBalancedRegular.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Algebra/AuslanderReiten/Tensor/EnvelopingBalancedRegular.lean
-
curl -L -o EnvelopingBalancedRegular.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Algebra/AuslanderReiten/Tensor/EnvelopingBalancedRegular.lean
6.22 kB
| 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 | |