ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AffineEquiv.constVAdd_nsmul
theorem constVAdd_nsmul (n : ℕ) (v : V₁) : constVAdd k P₁ (n • v) = constVAdd k P₁ v ^ n 
Arguments: (k : Type u_1) (P₁ : Type u_2) {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (n : ℕ) (v : V₁)
Goal: AffineEquiv.constVAdd k P₁ (n • v) = AffineEquiv.constVAdd k P₁ v ^ n
-- AffineEquiv.constVAdd_zsmul
theorem constVAdd_zsmul (z : ℤ) (v : V₁) : constVAdd k P₁ (z • v) = constVAdd k P₁ v ^ z 
Arguments: (k : Type u_1) (P₁ : Type u_2) {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (z : ℤ) (v : V₁)
Goal: AffineEquiv.constVAdd k P₁ (z • v) = AffineEquiv.constVAdd k P₁ v ^ z
-- AffineEquiv.coe_homothetyUnitsMulHom_apply
@[simp]
theorem coe_homothetyUnitsMulHom_apply (p : P) (t : Rˣ) :
    (homothetyUnitsMulHom p t : P → P) = AffineMap.homothety p (t : R) 
Arguments: {R : Type u_10} {V : Type u_11} {P : Type u_12} [CommRing R] [AddCommGroup V] [Module R V] [AffineSpace V P] (p : P) (t : Rˣ)
Goal: ⇑((AffineEquiv.homothetyUnitsMulHom p) t) = ⇑(AffineMap.homothety p ↑t)
-- AffineEquiv.coe_homothetyUnitsMulHom_apply_symm
@[simp]
theorem coe_homothetyUnitsMulHom_apply_symm (p : P) (t : Rˣ) :
    ((homothetyUnitsMulHom p t).symm : P → P) = AffineMap.homothety p (↑t⁻¹ : R) 
Arguments: {R : Type u_10} {V : Type u_11} {P : Type u_12} [CommRing R] [AddCommGroup V] [Module R V] [AffineSpace V P] (p : P) (t : Rˣ)
Goal: ⇑((AffineEquiv.homothetyUnitsMulHom p) t).symm = ⇑(AffineMap.homothety p ↑t⁻¹)
-- AffineEquiv.coe_homothetyUnitsMulHom_eq_homothetyHom_coe
@[simp]
theorem coe_homothetyUnitsMulHom_eq_homothetyHom_coe (p : P) :
    ((↑) : (P ≃ᵃ[R] P) → P →ᵃ[R] P) ∘ homothetyUnitsMulHom p =
      AffineMap.homothetyHom p ∘ ((↑) : Rˣ → R) 
Arguments: {R : Type u_10} {V : Type u_11} {P : Type u_12} [CommRing R] [AddCommGroup V] [Module R V] [AffineSpace V P] (p : P)
Goal: AffineEquiv.toAffineMap ∘ ⇑(AffineEquiv.homothetyUnitsMulHom p) = ⇑(AffineMap.homothetyHom p) ∘ Units.val
-- AffineEquiv.pointReflection_apply
theorem pointReflection_apply (x y : P₁) : pointReflection k x y = x -ᵥ y +ᵥ x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (x y : P₁)
Goal: (AffineEquiv.pointReflection k x) y = x -ᵥ y +ᵥ x
-- AffineEquiv.pointReflection_symm
@[simp]
theorem pointReflection_symm (x : P₁) : (pointReflection k x).symm = pointReflection k x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (x : P₁)
Goal: (AffineEquiv.pointReflection k x).symm = AffineEquiv.pointReflection k x
-- AffineEquiv.toEquiv_pointReflection
@[simp]
theorem toEquiv_pointReflection (x : P₁) :
    (pointReflection k x).toEquiv = Equiv.pointReflection x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (x : P₁)
Goal: (AffineEquiv.pointReflection k x).toEquiv = Equiv.pointReflection x
-- AffineEquiv.pointReflection_self
@[simp]
theorem pointReflection_self (x : P₁) : pointReflection k x x = x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (x : P₁)
Goal: (AffineEquiv.pointReflection k x) x = x
-- AffineEquiv.pointReflection_involutive
theorem pointReflection_involutive (x : P₁) : Involutive (pointReflection k x : P₁ → P₁) 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (x : P₁)
Goal: Function.Involutive ⇑(AffineEquiv.pointReflection k x)
-- AffineEquiv.pointReflection_fixed_iff_of_injective_bit0
theorem pointReflection_fixed_iff_of_injective_bit0 {x y : P₁} (h : Injective (2 • · : V₁ → V₁)) :
    pointReflection k x y = y ↔ y = x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] {x y : P₁} (h : Function.Injective fun x => 2 • x)
Goal: (AffineEquiv.pointReflection k x) y = y ↔ y = x
-- AffineEquiv.injective_pointReflection_left_of_injective_bit0
theorem injective_pointReflection_left_of_injective_bit0
    (h : Injective (2 • · : V₁ → V₁)) (y : P₁) :
    Injective fun x : P₁ => pointReflection k x y 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (h : Function.Injective fun x => 2 • x) (y : P₁)
Goal: Function.Injective fun x => (AffineEquiv.pointReflection k x) y
-- AffineEquiv.injective_pointReflection_left_of_module
theorem injective_pointReflection_left_of_module [Invertible (2 : k)] :
    ∀ y, Injective fun x : P₁ => pointReflection k x y 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] [Invertible 2] (y : P₁)
Goal: Function.Injective fun x => (AffineEquiv.pointReflection k x) y
-- AffineEquiv.pointReflection_fixed_iff_of_module
theorem pointReflection_fixed_iff_of_module [Invertible (2 : k)] {x y : P₁} :
    pointReflection k x y = y ↔ y = x 
Arguments: (k : Type u_1) {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] [Invertible 2] {x y : P₁}
Goal: (AffineEquiv.pointReflection k x) y = y ↔ y = x
-- LinearEquiv.coe_toAffineEquiv
@[simp]
theorem coe_toAffineEquiv (e : V₁ ≃ₗ[k] V₂) : ⇑e.toAffineEquiv = e 
Arguments: {k : Type u_1} {V₁ : Type u_6} {V₂ : Type u_7} [Ring k] [AddCommGroup V₁] [Module k V₁] [AddCommGroup V₂] [Module k V₂] (e : V₁ ≃ₗ[k] V₂)
Goal: ⇑e.toAffineEquiv = ⇑e
-- AffineMap.lineMap_vadd
theorem lineMap_vadd (v v' : V₁) (p : P₁) (c : k) :
    lineMap v v' c +ᵥ p = lineMap (v +ᵥ p) (v' +ᵥ p) c 
Arguments: {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (v v' : V₁) (p : P₁) (c : k)
Goal: (AffineMap.lineMap v v') c +ᵥ p = (AffineMap.lineMap (v +ᵥ p) (v' +ᵥ p)) c
-- AffineMap.lineMap_vsub
theorem lineMap_vsub (p₁ p₂ p₃ : P₁) (c : k) :
    lineMap p₁ p₂ c -ᵥ p₃ = lineMap (p₁ -ᵥ p₃) (p₂ -ᵥ p₃) c 
Arguments: {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (p₁ p₂ p₃ : P₁) (c : k)
Goal: (AffineMap.lineMap p₁ p₂) c -ᵥ p₃ = (AffineMap.lineMap (p₁ -ᵥ p₃) (p₂ -ᵥ p₃)) c
-- AffineMap.vsub_lineMap
theorem vsub_lineMap (p₁ p₂ p₃ : P₁) (c : k) :
    p₁ -ᵥ lineMap p₂ p₃ c = lineMap (p₁ -ᵥ p₂) (p₁ -ᵥ p₃) c 
Arguments: {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (p₁ p₂ p₃ : P₁) (c : k)
Goal: p₁ -ᵥ (AffineMap.lineMap p₂ p₃) c = (AffineMap.lineMap (p₁ -ᵥ p₂) (p₁ -ᵥ p₃)) c
-- AffineMap.vadd_lineMap
theorem vadd_lineMap (v : V₁) (p₁ p₂ : P₁) (c : k) :
    v +ᵥ lineMap p₁ p₂ c = lineMap (v +ᵥ p₁) (v +ᵥ p₂) c 
Arguments: {k : Type u_1} {P₁ : Type u_2} {V₁ : Type u_6} [Ring k] [AddCommGroup V₁] [Module k V₁] [AffineSpace V₁ P₁] (v : V₁) (p₁ p₂ : P₁) (c : k)
Goal: v +ᵥ (AffineMap.lineMap p₁ p₂) c = (AffineMap.lineMap (v +ᵥ p₁) (v +ᵥ p₂)) c
-- AffineMap.homothety_neg_one_apply
theorem homothety_neg_one_apply (c p : P₁) : homothety c (-1 : R') p = pointReflection R' c p 
Arguments: {P₁ : Type u_2} {V₁ : Type u_6} [AddCommGroup V₁] [AffineSpace V₁ P₁] {R' : Type u_10} [CommRing R'] [Module R' V₁] (c p : P₁)
Goal: (AffineMap.homothety c (-1)) p = (AffineEquiv.pointReflection R' c) p
-- PiTensorProduct.gradedMonoid_eq_of_reindex_cast
@[ext]
theorem gradedMonoid_eq_of_reindex_cast {ιι : Type*} {ι : ιι → Type*} :
    ∀ {a b : GradedMonoid fun ii => ⨂[R] _ : ι ii, M} (h : a.fst = b.fst),
      reindex R (fun _ ↦ M) (Equiv.cast <| congr_arg ι h) a.snd = b.snd → a = b
  
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {ιι : Type u_3} {ι : ιι → Type u_4} {a b : GradedMonoid fun ii => ⨂[R] (x : ι ii), M} (h : a.fst = b.fst)
Goal: (PiTensorProduct.reindex R (fun x => M) (Equiv.cast ⋯)) a.snd = b.snd → a = b
-- TensorPower.gOne_def
theorem gOne_def : ₜ1 = tprod R (@Fin.elim0 M) 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M]
Goal: GradedMonoid.GOne.one = (PiTensorProduct.tprod R) Fin.elim0
-- TensorPower.gMul_def
theorem gMul_def {i j} (a : ⨂[R]^i M) (b : (⨂[R]^j) M) :
    a ₜ* b = @mulEquiv R M _ _ _ i j (a ⊗ₜ b) 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {i j : ℕ} (a : ⨂[R]^i M) (b : ⨂[R]^j M)
Goal: GradedMonoid.GMul.mul a b = TensorPower.mulEquiv (a ⊗ₜ[R] b)
-- TensorPower.gMul_eq_coe_linearMap
theorem gMul_eq_coe_linearMap {i j} (a : ⨂[R]^i M) (b : (⨂[R]^j) M) :
    a ₜ* b = ((TensorProduct.mk R _ _).compr₂ ↑(mulEquiv : _ ≃ₗ[R] (⨂[R]^(i + j)) M) :
      ⨂[R]^i M →ₗ[R] (⨂[R]^j) M →ₗ[R] (⨂[R]^(i + j)) M) a b 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {i j : ℕ} (a : ⨂[R]^i M) (b : ⨂[R]^j M)
Goal: GradedMonoid.GMul.mul a b = (((TensorProduct.mk R (⨂[R]^i M) (⨂[R]^j M)).compr₂ ↑TensorPower.mulEquiv) a) b
-- TensorPower.cast_tprod
theorem cast_tprod {i j} (h : i = j) (a : Fin i → M) :
    cast R M h (tprod R a) = tprod R (a ∘ Fin.cast h.symm) 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] {i j : ℕ} (h : i = j) (a : Fin i → M)
Goal: (TensorPower.cast R M h) ((PiTensorProduct.tprod R) a) = (PiTensorProduct.tprod R) (a ∘ Fin.cast ⋯)
-- TensorPower.cast_refl
@[simp]
theorem cast_refl {i} (h : i = i) : cast R M h = LinearEquiv.refl _ _ 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] {i : ℕ} (h : i = i)
Goal: TensorPower.cast R M h = LinearEquiv.refl R (⨂[R]^i M)
-- TensorPower.cast_symm
@[simp]
theorem cast_symm {i j} (h : i = j) : (cast R M h).symm = cast R M h.symm 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] {i j : ℕ} (h : i = j)
Goal: (TensorPower.cast R M h).symm = TensorPower.cast R M ⋯
-- TensorPower.cast_trans
@[simp]
theorem cast_trans {i j k} (h : i = j) (h' : j = k) :
    (cast R M h).trans (cast R M h') = cast R M (h.trans h') 
Arguments: (R : Type u_1) (M : Type u_2) [CommSemiring R] [AddCommMonoid M] [Module R M] {i j k : ℕ} (h : i = j) (h' : j = k)
Goal: TensorPower.cast R M h ≪≫ₗ TensorPower.cast R M h' = TensorPower.cast R M ⋯
-- TensorPower.cast_cast
@[simp]
theorem cast_cast {i j k} (h : i = j) (h' : j = k) (a : ⨂[R]^i M) :
    cast R M h' (cast R M h a) = cast R M (h.trans h') a 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {i j k : ℕ} (h : i = j) (h' : j = k) (a : ⨂[R]^i M)
Goal: (TensorPower.cast R M h') ((TensorPower.cast R M h) a) = (TensorPower.cast R M ⋯) a
-- TensorPower.gradedMonoid_eq_of_cast
@[ext]
theorem gradedMonoid_eq_of_cast {a b : GradedMonoid fun n => ⨂[R] _ : Fin n, M} (h : a.fst = b.fst)
    (h2 : cast R M h a.snd = b.snd) : a = b 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {a b : GradedMonoid fun n => ⨂[R] (x : Fin n), M} (h : a.fst = b.fst) (h2 : (TensorPower.cast R M h) a.snd = b.snd)
Goal: a = b
-- TensorPower.cast_eq_cast
theorem cast_eq_cast {i j} (h : i = j) :
    ⇑(cast R M h) = _root_.cast (congrArg (fun i => ⨂[R]^i M) h) 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {i j : ℕ} (h : i = j)
Goal: ⇑(TensorPower.cast R M h) = cast ⋯
-- TensorPower.tprod_mul_tprod
theorem tprod_mul_tprod {na nb} (a : Fin na → M) (b : Fin nb → M) :
    tprod R a ₜ* tprod R b = tprod R (Fin.append a b) 
Arguments: (R : Type u_1) {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {na nb : ℕ} (a : Fin na → M) (b : Fin nb → M)
Goal: GradedMonoid.GMul.mul ((PiTensorProduct.tprod R) a) ((PiTensorProduct.tprod R) b) =
  (PiTensorProduct.tprod R) (Fin.append a b)
-- TensorPower.one_mul
theorem one_mul {n} (a : ⨂[R]^n M) : cast R M (zero_add n) (ₜ1 ₜ* a) = a 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {n : ℕ} (a : ⨂[R]^n M)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul GradedMonoid.GOne.one a) = a
-- TensorPower.mul_one
theorem mul_one {n} (a : ⨂[R]^n M) : cast R M (add_zero _) (a ₜ* ₜ1) = a 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {n : ℕ} (a : ⨂[R]^n M)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul a GradedMonoid.GOne.one) = a
-- TensorPower.mul_assoc
theorem mul_assoc {na nb nc} (a : (⨂[R]^na) M) (b : (⨂[R]^nb) M) (c : (⨂[R]^nc) M) :
    cast R M (add_assoc _ _ _) (a ₜ* b ₜ* c) = a ₜ* (b ₜ* c) 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {na nb nc : ℕ} (a : ⨂[R]^na M) (b : ⨂[R]^nb M) (c : ⨂[R]^nc M)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul (GradedMonoid.GMul.mul a b) c) =
  GradedMonoid.GMul.mul a (GradedMonoid.GMul.mul b c)
-- TensorPower.algebraMap₀_eq_smul_one
theorem algebraMap₀_eq_smul_one (r : R) : (algebraMap₀ r : (⨂[R]^0) M) = r • ₜ1 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] (r : R)
Goal: TensorPower.algebraMap₀ r = r • GradedMonoid.GOne.one
-- TensorPower.algebraMap₀_one
theorem algebraMap₀_one : (algebraMap₀ 1 : (⨂[R]^0) M) = ₜ1 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M]
Goal: TensorPower.algebraMap₀ 1 = GradedMonoid.GOne.one
-- TensorPower.algebraMap₀_mul
theorem algebraMap₀_mul {n} (r : R) (a : ⨂[R]^n M) :
    cast R M (zero_add _) (algebraMap₀ r ₜ* a) = r • a 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {n : ℕ} (r : R) (a : ⨂[R]^n M)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul (TensorPower.algebraMap₀ r) a) = r • a
-- TensorPower.mul_algebraMap₀
theorem mul_algebraMap₀ {n} (r : R) (a : ⨂[R]^n M) :
    cast R M (add_zero _) (a ₜ* algebraMap₀ r) = r • a 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] {n : ℕ} (r : R) (a : ⨂[R]^n M)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul a (TensorPower.algebraMap₀ r)) = r • a
-- TensorPower.algebraMap₀_mul_algebraMap₀
theorem algebraMap₀_mul_algebraMap₀ (r s : R) :
    cast R M (add_zero _) (algebraMap₀ r ₜ* algebraMap₀ s) = algebraMap₀ (r * s) 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] (r s : R)
Goal: (TensorPower.cast R M ⋯) (GradedMonoid.GMul.mul (TensorPower.algebraMap₀ r) (TensorPower.algebraMap₀ s)) =
  TensorPower.algebraMap₀ (r * s)
-- TensorPower.galgebra_toFun_def
theorem galgebra_toFun_def (r : R) :
    @DirectSum.GAlgebra.toFun ℕ R (fun i => ⨂[R]^i M) _ _ _ _ _ _ _ r = algebraMap₀ r 
Arguments: {R : Type u_1} {M : Type u_2} [CommSemiring R] [AddCommMonoid M] [Module R M] (r : R)
Goal: DirectSum.GAlgebra.toFun r = TensorPower.algebraMap₀ r
-- TensorProduct.toMatrix_map
theorem TensorProduct.toMatrix_map (f : M →ₗ[R] M') (g : N →ₗ[R] N') :
    toMatrix (bM.tensorProduct bN) (bM'.tensorProduct bN') (TensorProduct.map f g) =
      toMatrix bM bM' f ⊗ₖ toMatrix bN bN' g 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} {M' : Type u_5} {N' : Type u_6} {ι : Type u_7} {κ : Type u_8} {ι' : Type u_10} {κ' : Type u_11} [DecidableEq ι] [DecidableEq κ] [Fintype ι] [Fintype κ] [Finite ι'] [Finite κ'] [CommRing R] [AddCommGroup M] [AddCommGroup N] [AddCommGroup M'] [AddCommGroup N'] [Module R M] [Module R N] [Module R M'] [Module R N'] (bM : Basis ι R M) (bN : Basis κ R N) (bM' : Basis ι' R M') (bN' : Basis κ' R N') (f : M →ₗ[R] M') (g : N →ₗ[R] N')
Goal: (LinearMap.toMatrix (bM.tensorProduct bN) (bM'.tensorProduct bN')) (TensorProduct.map f g) =
  Matrix.kroneckerMap (fun x x_1 => x * x_1) ((LinearMap.toMatrix bM bM') f) ((LinearMap.toMatrix bN bN') g)
-- Matrix.toLin_kronecker
theorem Matrix.toLin_kronecker (A : Matrix ι' ι R) (B : Matrix κ' κ R) :
    toLin (bM.tensorProduct bN) (bM'.tensorProduct bN') (A ⊗ₖ B) =
      TensorProduct.map (toLin bM bM' A) (toLin bN bN' B) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} {M' : Type u_5} {N' : Type u_6} {ι : Type u_7} {κ : Type u_8} {ι' : Type u_10} {κ' : Type u_11} [DecidableEq ι] [DecidableEq κ] [Fintype ι] [Fintype κ] [Finite ι'] [Finite κ'] [CommRing R] [AddCommGroup M] [AddCommGroup N] [AddCommGroup M'] [AddCommGroup N'] [Module R M] [Module R N] [Module R M'] [Module R N'] (bM : Basis ι R M) (bN : Basis κ R N) (bM' : Basis ι' R M') (bN' : Basis κ' R N') (A : Matrix ι' ι R) (B : Matrix κ' κ R)
Goal: (Matrix.toLin (bM.tensorProduct bN) (bM'.tensorProduct bN')) (Matrix.kroneckerMap (fun x x_1 => x * x_1) A B) =
  TensorProduct.map ((Matrix.toLin bM bM') A) ((Matrix.toLin bN bN') B)
-- TensorProduct.toMatrix_comm
theorem TensorProduct.toMatrix_comm :
    toMatrix (bM.tensorProduct bN) (bN.tensorProduct bM) (TensorProduct.comm R M N) =
      (1 : Matrix (ι × κ) (ι × κ) R).submatrix Prod.swap _root_.id 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_7} {κ : Type u_8} [DecidableEq ι] [DecidableEq κ] [Fintype ι] [Fintype κ] [CommRing R] [AddCommGroup M] [AddCommGroup N] [Module R M] [Module R N] (bM : Basis ι R M) (bN : Basis κ R N)
Goal: (LinearMap.toMatrix (bM.tensorProduct bN) (bN.tensorProduct bM)) ↑(TensorProduct.comm R M N) =
  Matrix.submatrix 1 Prod.swap id
-- TensorProduct.toMatrix_assoc
theorem TensorProduct.toMatrix_assoc :
    toMatrix ((bM.tensorProduct bN).tensorProduct bP) (bM.tensorProduct (bN.tensorProduct bP))
        (TensorProduct.assoc R M N P) =
      (1 : Matrix (ι × κ × τ) (ι × κ × τ) R).submatrix _root_.id (Equiv.prodAssoc _ _ _) 
Arguments: {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} {ι : Type u_7} {κ : Type u_8} {τ : Type u_9} [DecidableEq ι] [DecidableEq κ] [DecidableEq τ] [Fintype ι] [Fintype κ] [Fintype τ] [CommRing R] [AddCommGroup M] [AddCommGroup N] [AddCommGroup P] [Module R M] [Module R N] [Module R P] (bM : Basis ι R M) (bN : Basis κ R N) (bP : Basis τ R P)
Goal: (LinearMap.toMatrix ((bM.tensorProduct bN).tensorProduct bP) (bM.tensorProduct (bN.tensorProduct bP)))
    ↑(TensorProduct.assoc R M N P) =
  Matrix.submatrix 1 id ⇑(Equiv.prodAssoc ι κ τ)
-- Algebra.TensorProduct.opAlgEquiv_apply
theorem opAlgEquiv_apply (x : Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ) :
    opAlgEquiv R S A B x =
      op (_root_.TensorProduct.map
        (opLinearEquiv R).symm.toLinearMap (opLinearEquiv R).symm.toLinearMap x) 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [CommSemiring R] [CommSemiring S] [Semiring A] [Semiring B] [Algebra R S] [Algebra R A] [Algebra R B] [Algebra S A] [IsScalarTower R S A] (x : Aᵐᵒᵖ ⊗[R] Bᵐᵒᵖ)
Goal: (Algebra.TensorProduct.opAlgEquiv R S A B) x =
  MulOpposite.op ((TensorProduct.map ↑(MulOpposite.opLinearEquiv R).symm ↑(MulOpposite.opLinearEquiv R).symm) x)
-- Algebra.TensorProduct.opAlgEquiv_symm_apply
theorem opAlgEquiv_symm_apply (x : (A ⊗[R] B)ᵐᵒᵖ) :
    (opAlgEquiv R S A B).symm x =
      _root_.TensorProduct.map (opLinearEquiv R).toLinearMap (opLinearEquiv R).toLinearMap x.unop 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [CommSemiring R] [CommSemiring S] [Semiring A] [Semiring B] [Algebra R S] [Algebra R A] [Algebra R B] [Algebra S A] [IsScalarTower R S A] (x : (A ⊗[R] B)ᵐᵒᵖ)
Goal: (Algebra.TensorProduct.opAlgEquiv R S A B).symm x =
  (TensorProduct.map ↑(MulOpposite.opLinearEquiv R) ↑(MulOpposite.opLinearEquiv R)) (MulOpposite.unop x)
-- Algebra.TensorProduct.opAlgEquiv_tmul
@[simp]
theorem opAlgEquiv_tmul (a : Aᵐᵒᵖ) (b : Bᵐᵒᵖ) :
    opAlgEquiv R S A B (a ⊗ₜ[R] b) = op (a.unop ⊗ₜ b.unop) 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [CommSemiring R] [CommSemiring S] [Semiring A] [Semiring B] [Algebra R S] [Algebra R A] [Algebra R B] [Algebra S A] [IsScalarTower R S A] (a : Aᵐᵒᵖ) (b : Bᵐᵒᵖ)
Goal: (Algebra.TensorProduct.opAlgEquiv R S A B) (a ⊗ₜ[R] b) = MulOpposite.op (MulOpposite.unop a ⊗ₜ[R] MulOpposite.unop b)
-- Algebra.TensorProduct.opAlgEquiv_symm_tmul
@[simp]
theorem opAlgEquiv_symm_tmul (a : A) (b : B) :
    (opAlgEquiv R S A B).symm (op <| a ⊗ₜ[R] b) = op a ⊗ₜ op b 
Arguments: (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [CommSemiring R] [CommSemiring S] [Semiring A] [Semiring B] [Algebra R S] [Algebra R A] [Algebra R B] [Algebra S A] [IsScalarTower R S A] (a : A) (b : B)
Goal: (Algebra.TensorProduct.opAlgEquiv R S A B).symm (MulOpposite.op (a ⊗ₜ[R] b)) = MulOpposite.op a ⊗ₜ[R] MulOpposite.op b
-- TensorProduct.piScalarRightHom_tmul
@[simp]
lemma piScalarRightHom_tmul (x : N) (f : ι → R) :
    piScalarRightHom R S N ι (x ⊗ₜ f) = (fun j ↦ f j • x) 
Arguments: (R : Type u_1) [CommSemiring R] (S : Type u_2) [CommSemiring S] [Algebra R S] (N : Type u_3) [AddCommMonoid N] [Module R N] [Module S N] [IsScalarTower R S N] (ι : Type u_4) (x : N) (f : ι → R)
Goal: (TensorProduct.piScalarRightHom R S N ι) (x ⊗ₜ[R] f) = fun j => f j • x
-- _private.Mathlib.LinearAlgebra.TensorProduct.Pi.0.TensorProduct.piScalarRightInv_single
@[simp]
private lemma piScalarRightInv_single (x : N) (i : ι) :
    piScalarRightInv R S N ι (Pi.single i x) = x ⊗ₜ Pi.single i 1 
Arguments: (R : Type u_1) [CommSemiring R] (S : Type u_2) [CommSemiring S] [Algebra R S] (N : Type u_3) [AddCommMonoid N] [Module R N] [Module S N] [IsScalarTower R S N] (ι : Type u_4) [Fintype ι] [DecidableEq ι] (x : N) (i : ι)
Goal: (TensorProduct.piScalarRightInv R S N ι) (Pi.single i x) = x ⊗ₜ[R] Pi.single i 1
-- TensorProduct.piScalarRight_apply
@[simp]
lemma piScalarRight_apply (x : N ⊗[R] (ι → R)) :
    piScalarRight R S N ι x = piScalarRightHom R S N ι x 
Arguments: (R : Type u_1) [CommSemiring R] (S : Type u_2) [CommSemiring S] [Algebra R S] (N : Type u_3) [AddCommMonoid N] [Module R N] [Module S N] [IsScalarTower R S N] (ι : Type u_4) [Fintype ι] [DecidableEq ι] (x : TensorProduct R N (ι → R))
Goal: (TensorProduct.piScalarRight R S N ι) x = (TensorProduct.piScalarRightHom R S N ι) x
-- TensorProduct.piScalarRight_symm_single
@[simp]
lemma piScalarRight_symm_single (x : N) (i : ι) :
    (piScalarRight R S N ι).symm (Pi.single i x) = x ⊗ₜ Pi.single i 1 
Arguments: (R : Type u_1) [CommSemiring R] (S : Type u_2) [CommSemiring S] [Algebra R S] (N : Type u_3) [AddCommMonoid N] [Module R N] [Module S N] [IsScalarTower R S N] (ι : Type u_4) [Fintype ι] [DecidableEq ι] (x : N) (i : ι)
Goal: (TensorProduct.piScalarRight R S N ι).symm (Pi.single i x) = x ⊗ₜ[R] Pi.single i 1
-- Finsupp.linearIndependent_single
theorem linearIndependent_single {φ : ι → Type*} {f : ∀ ι, φ ι → M}
    (hf : ∀ i, LinearIndependent R (f i)) :
    LinearIndependent R fun ix : Σi, φ i => single ix.1 (f ix.1 ix.2) 
Arguments: {R : Type u_1} {M : Type u_2} {ι : Type u_3} [Ring R] [AddCommGroup M] [Module R M] {φ : ι → Type u_4} {f : (ι : ι) → φ ι → M} (hf : ∀ (i : ι), LinearIndependent R (f i))
Goal: LinearIndependent R fun ix => Finsupp.single ix.fst (f ix.fst ix.snd)
-- Finsupp.basis_repr
@[simp]
theorem basis_repr {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) (g : ι →₀ M) (ix) :
    (Finsupp.basis b).repr g ix = (b ix.1).repr (g ix.1) ix.2 
Arguments: {R : Type u_1} {M : Type u_2} {ι : Type u_3} [Semiring R] [AddCommMonoid M] [Module R M] {φ : ι → Type u_4} (b : (i : ι) → Basis (φ i) R M) (g : ι →₀ M) (ix : (i : ι) × φ i)
Goal: ((Finsupp.basis b).repr g) ix = ((b ix.fst).repr (g ix.fst)) ix.snd
-- Finsupp.coe_basis
@[simp]
theorem coe_basis {φ : ι → Type*} (b : ∀ i, Basis (φ i) R M) :
    ⇑(Finsupp.basis b) = fun ix : Σi, φ i => single ix.1 (b ix.1 ix.2) 
Arguments: {R : Type u_1} {M : Type u_2} {ι : Type u_3} [Semiring R] [AddCommMonoid M] [Module R M] {φ : ι → Type u_4} (b : (i : ι) → Basis (φ i) R M)
Goal: ⇑(Finsupp.basis b) = fun ix => Finsupp.single ix.fst ((b ix.fst) ix.snd)
-- Finsupp.basisSingleOne_repr
@[simps]
protected def basisSingleOne : Basis ι R (ι →₀ R) 
Arguments: {R : Type u_1} {ι : Type u_3} [Semiring R]
Goal: Finsupp.basisSingleOne.repr = LinearEquiv.refl R (ι →₀ R)
-- Finsupp.coe_basisSingleOne
@[simp]
theorem coe_basisSingleOne : (Finsupp.basisSingleOne : ι → ι →₀ R) = fun i => Finsupp.single i 1 
Arguments: {R : Type u_1} {ι : Type u_3} [Semiring R]
Goal: ⇑Finsupp.basisSingleOne = fun i => Finsupp.single i 1
-- Finset.sum_single_ite
theorem _root_.Finset.sum_single_ite [Fintype n] (a : R) (i : n) :
    (∑ x : n, Finsupp.single x (if i = x then a else 0)) = Finsupp.single i a 
Arguments: {R : Type u_1} {n : Type u_3} [DecidableEq n] [Semiring R] [Fintype n] (a : R) (i : n)
Goal: ∑ x : n, Finsupp.single x (if i = x then a else 0) = Finsupp.single i a