ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MvPolynomial.pderiv_mul
theorem pderiv_mul {i : σ} {f g : MvPolynomial σ R} :
    pderiv i (f * g) = pderiv i f * g + f * pderiv i g 
Arguments: {R : Type u} {σ : Type v} [CommSemiring R] {i : σ} {f g : MvPolynomial σ R}
Goal: (MvPolynomial.pderiv i) (f * g) = (MvPolynomial.pderiv i) f * g + f * (MvPolynomial.pderiv i) g
-- MvPolynomial.pderiv_pow
theorem pderiv_pow {i : σ} {f : MvPolynomial σ R} {n : ℕ} :
    pderiv i (f ^ n) = n * f ^ (n - 1) * pderiv i f 
Arguments: {R : Type u} {σ : Type v} [CommSemiring R] {i : σ} {f : MvPolynomial σ R} {n : ℕ}
Goal: (MvPolynomial.pderiv i) (f ^ n) = ↑n * f ^ (n - 1) * (MvPolynomial.pderiv i) f
-- MvPolynomial.pderiv_C_mul
theorem pderiv_C_mul {f : MvPolynomial σ R} {i : σ} : pderiv i (C a * f) = C a * pderiv i f 
Arguments: {R : Type u} {σ : Type v} {a : R} [CommSemiring R] {f : MvPolynomial σ R} {i : σ}
Goal: (MvPolynomial.pderiv i) (MvPolynomial.C a * f) = MvPolynomial.C a * (MvPolynomial.pderiv i) f
-- MvPolynomial.pderiv_map
theorem pderiv_map {S} [CommSemiring S] {φ : R →+* S} {f : MvPolynomial σ R} {i : σ} :
    pderiv i (map φ f) = map φ (pderiv i f) 
Arguments: {R : Type u} {σ : Type v} [CommSemiring R] {S : Type u_1} [CommSemiring S] {φ : R →+* S} {f : MvPolynomial σ R} {i : σ}
Goal: (MvPolynomial.pderiv i) ((MvPolynomial.map φ) f) = (MvPolynomial.map φ) ((MvPolynomial.pderiv i) f)
-- LinearEquiv.restrictScalars_apply
@[simps]
def restrictScalars (f : M ≃ₗ[S] M₂) : M ≃ₗ[R] M₂ 
Arguments: (R : Type u_1) {S : Type u_7} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring S] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Module S M] [Module S M₂] [LinearMap.CompatibleSMul M M₂ R S] (f : M ≃ₗ[S] M₂) (a : M)
Goal: (LinearEquiv.restrictScalars R f) a = f a
-- LinearEquiv.restrictScalars_symm_apply
@[simps]
def restrictScalars (f : M ≃ₗ[S] M₂) : M ≃ₗ[R] M₂ 
Arguments: (R : Type u_1) {S : Type u_7} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring S] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Module S M] [Module S M₂] [LinearMap.CompatibleSMul M M₂ R S] (f : M ≃ₗ[S] M₂) (a : M₂)
Goal: (LinearEquiv.restrictScalars R f).symm a = f.symm a
-- LinearEquiv.restrictScalars_injective
theorem restrictScalars_injective :
    Function.Injective (restrictScalars R : (M ≃ₗ[S] M₂) → M ≃ₗ[R] M₂) 
Arguments: (R : Type u_1) {S : Type u_7} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring S] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Module S M] [Module S M₂] [LinearMap.CompatibleSMul M M₂ R S]
Goal: Function.Injective (LinearEquiv.restrictScalars R)
-- LinearEquiv.restrictScalars_inj
@[simp]
theorem restrictScalars_inj (f g : M ≃ₗ[S] M₂) :
    f.restrictScalars R = g.restrictScalars R ↔ f = g 
Arguments: (R : Type u_1) {S : Type u_7} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring S] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Module S M] [Module S M₂] [LinearMap.CompatibleSMul M M₂ R S] (f g : M ≃ₗ[S] M₂)
Goal: LinearEquiv.restrictScalars R f = LinearEquiv.restrictScalars R g ↔ f = g
-- Module.End_isUnit_iff
theorem _root_.Module.End_isUnit_iff [Module R M] (f : Module.End R M) :
    IsUnit f ↔ Function.Bijective f 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] (f : Module.End R M)
Goal: IsUnit f ↔ Function.Bijective ⇑f
-- LinearEquiv.coe_one
@[simp]
lemma coe_one : ↑(1 : M ≃ₗ[R] M) = id 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ⇑1 = id
-- LinearEquiv.coe_toLinearMap_one
@[simp]
lemma coe_toLinearMap_one : (↑(1 : M ≃ₗ[R] M) : M →ₗ[R] M) = LinearMap.id 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M]
Goal: ↑1 = LinearMap.id
-- LinearEquiv.coe_toLinearMap_mul
@[simp]
lemma coe_toLinearMap_mul {e₁ e₂ : M ≃ₗ[R] M} :
    (↑(e₁ * e₂) : M →ₗ[R] M) = (e₁ : M →ₗ[R] M) * (e₂ : M →ₗ[R] M) 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] {e₁ e₂ : M ≃ₗ[R] M}
Goal: ↑(e₁ * e₂) = ↑e₁ * ↑e₂
-- LinearEquiv.coe_pow
theorem coe_pow (e : M ≃ₗ[R] M) (n : ℕ) : ⇑(e ^ n) = e^[n] 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] (e : M ≃ₗ[R] M) (n : ℕ)
Goal: ⇑(e ^ n) = (⇑e)^[n]
-- LinearEquiv.pow_apply
theorem pow_apply (e : M ≃ₗ[R] M) (n : ℕ) (m : M) : (e ^ n) m = e^[n] m 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] (e : M ≃ₗ[R] M) (n : ℕ) (m : M)
Goal: (e ^ n) m = (⇑e)^[n] m
-- LinearEquiv.automorphismGroup.toLinearMapMonoidHom_apply
@[simps]
def automorphismGroup.toLinearMapMonoidHom : (M ≃ₗ[R] M) →* M →ₗ[R] M 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] (e : M ≃ₗ[R] M)
Goal: LinearEquiv.automorphismGroup.toLinearMapMonoidHom e = ↑e
-- LinearEquiv.smul_def
@[simp]
protected theorem smul_def (f : M ≃ₗ[R] M) (a : M) : f • a = f a 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommMonoid M] [Module R M] (f : M ≃ₗ[R] M) (a : M)
Goal: f • a = f a
-- LinearEquiv.ofSubsingleton_symm_apply
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂ 
Arguments: {R : Type u_1} (M : Type u_8) (M₂ : Type u_10) [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Subsingleton M] [Subsingleton M₂]
Goal: ∀ (x : M₂), (LinearEquiv.ofSubsingleton M M₂).symm x = 0
-- LinearEquiv.ofSubsingleton_apply
@[simps]
def ofSubsingleton : M ≃ₗ[R] M₂ 
Arguments: {R : Type u_1} (M : Type u_8) (M₂ : Type u_10) [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] [Subsingleton M] [Subsingleton M₂]
Goal: ∀ (x : M), (LinearEquiv.ofSubsingleton M M₂) x = 0
-- LinearEquiv.ofSubsingleton_self
@[simp]
theorem ofSubsingleton_self : ofSubsingleton M M = refl R M 
Arguments: {R : Type u_1} (M : Type u_8) [Semiring R] [AddCommMonoid M] [Module R M] [Subsingleton M]
Goal: LinearEquiv.ofSubsingleton M M = LinearEquiv.refl R M
-- Module.compHom.toLinearEquiv_apply
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S 
Arguments: {R : Type u_17} {S : Type u_18} [Semiring R] [Semiring S] (g : R ≃+* S) (a : R)
Goal: (Module.compHom.toLinearEquiv g) a = g a
-- Module.compHom.toLinearEquiv_symm_apply
@[simps]
def compHom.toLinearEquiv {R S : Type*} [Semiring R] [Semiring S] (g : R ≃+* S) :
    haveI := compHom S (↑g : R →+* S)
    R ≃ₗ[R] S 
Arguments: {R : Type u_17} {S : Type u_18} [Semiring R] [Semiring S] (g : R ≃+* S) (a : S)
Goal: (Module.compHom.toLinearEquiv g).symm a = g.symm a
-- DistribMulAction.toLinearEquiv_symm_apply
@[simps!]
def toLinearEquiv (s : S) : M ≃ₗ[R] M 
Arguments: (R : Type u_1) {S : Type u_7} (M : Type u_8) [Semiring R] [AddCommMonoid M] [Module R M] [Group S] [DistribMulAction S M] [SMulCommClass S R M] (s : S)
Goal: ∀ (a : M), (DistribMulAction.toLinearEquiv R M s).symm a = s⁻¹ • a
-- DistribMulAction.toLinearEquiv_apply
@[simps!]
def toLinearEquiv (s : S) : M ≃ₗ[R] M 
Arguments: (R : Type u_1) {S : Type u_7} (M : Type u_8) [Semiring R] [AddCommMonoid M] [Module R M] [Group S] [DistribMulAction S M] [SMulCommClass S R M] (s : S)
Goal: ∀ (a : M), (DistribMulAction.toLinearEquiv R M s) a = s • a
-- DistribMulAction.toModuleAut_apply
@[simps]
def toModuleAut : S →* M ≃ₗ[R] M 
Arguments: (R : Type u_1) {S : Type u_7} (M : Type u_8) [Semiring R] [AddCommMonoid M] [Module R M] [Group S] [DistribMulAction S M] [SMulCommClass S R M] (s : S)
Goal: (DistribMulAction.toModuleAut R M) s = DistribMulAction.toLinearEquiv R M s
-- AddEquiv.coe_toLinearEquiv
@[simp]
theorem coe_toLinearEquiv (h : ∀ (c : R) (x), e (c • x) = c • e x) : ⇑(e.toLinearEquiv h) = e 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃+ M₂) (h : ∀ (c : R) (x : M), e (c • x) = c • e x)
Goal: ⇑(e.toLinearEquiv h) = ⇑e
-- AddEquiv.coe_toLinearEquiv_symm
@[simp]
theorem coe_toLinearEquiv_symm (h : ∀ (c : R) (x), e (c • x) = c • e x) :
    ⇑(e.toLinearEquiv h).symm = e.symm 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃+ M₂) (h : ∀ (c : R) (x : M), e (c • x) = c • e x)
Goal: ⇑(e.toLinearEquiv h).symm = ⇑e.symm
-- AddEquiv.coe_toNatLinearEquiv
@[simp]
theorem coe_toNatLinearEquiv : ⇑e.toNatLinearEquiv = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommMonoid M] [AddCommMonoid M₂] (e : M ≃+ M₂)
Goal: ⇑e.toNatLinearEquiv = ⇑e
-- AddEquiv.toNatLinearEquiv_toAddEquiv
@[simp]
theorem toNatLinearEquiv_toAddEquiv : ↑e.toNatLinearEquiv = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommMonoid M] [AddCommMonoid M₂] (e : M ≃+ M₂)
Goal: ↑e.toNatLinearEquiv = e
-- LinearEquiv.toAddEquiv_toNatLinearEquiv
@[simp]
theorem _root_.LinearEquiv.toAddEquiv_toNatLinearEquiv (e : M ≃ₗ[ℕ] M₂) :
    AddEquiv.toNatLinearEquiv ↑e = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommMonoid M] [AddCommMonoid M₂] (e : M ≃ₗ[ℕ] M₂)
Goal: (↑e).toNatLinearEquiv = e
-- AddEquiv.toNatLinearEquiv_symm
@[simp]
theorem toNatLinearEquiv_symm : e.toNatLinearEquiv.symm = e.symm.toNatLinearEquiv 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommMonoid M] [AddCommMonoid M₂] (e : M ≃+ M₂)
Goal: e.toNatLinearEquiv.symm = e.symm.toNatLinearEquiv
-- AddEquiv.toNatLinearEquiv_refl
@[simp]
theorem toNatLinearEquiv_refl : (AddEquiv.refl M).toNatLinearEquiv = LinearEquiv.refl ℕ M 
Arguments: {M : Type u_8} [AddCommMonoid M]
Goal: (AddEquiv.refl M).toNatLinearEquiv = LinearEquiv.refl ℕ M
-- AddEquiv.toNatLinearEquiv_trans
@[simp]
theorem toNatLinearEquiv_trans (e₂ : M₂ ≃+ M₃) :
    e.toNatLinearEquiv.trans e₂.toNatLinearEquiv = (e.trans e₂).toNatLinearEquiv 
Arguments: {M : Type u_8} {M₂ : Type u_10} {M₃ : Type u_11} [AddCommMonoid M] [AddCommMonoid M₂] [AddCommMonoid M₃] (e : M ≃+ M₂) (e₂ : M₂ ≃+ M₃)
Goal: e.toNatLinearEquiv ≪≫ₗ e₂.toNatLinearEquiv = (e.trans e₂).toNatLinearEquiv
-- AddEquiv.coe_toIntLinearEquiv
@[simp]
theorem coe_toIntLinearEquiv : ⇑e.toIntLinearEquiv = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommGroup M] [AddCommGroup M₂] (e : M ≃+ M₂)
Goal: ⇑e.toIntLinearEquiv = ⇑e
-- AddEquiv.toIntLinearEquiv_toAddEquiv
@[simp]
theorem toIntLinearEquiv_toAddEquiv : ↑e.toIntLinearEquiv = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommGroup M] [AddCommGroup M₂] (e : M ≃+ M₂)
Goal: ↑e.toIntLinearEquiv = e
-- LinearEquiv.toAddEquiv_toIntLinearEquiv
@[simp]
theorem _root_.LinearEquiv.toAddEquiv_toIntLinearEquiv (e : M ≃ₗ[ℤ] M₂) :
    AddEquiv.toIntLinearEquiv (e : M ≃+ M₂) = e 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommGroup M] [AddCommGroup M₂] (e : M ≃ₗ[ℤ] M₂)
Goal: (↑e).toIntLinearEquiv = e
-- AddEquiv.toIntLinearEquiv_symm
@[simp]
theorem toIntLinearEquiv_symm : e.toIntLinearEquiv.symm = e.symm.toIntLinearEquiv 
Arguments: {M : Type u_8} {M₂ : Type u_10} [AddCommGroup M] [AddCommGroup M₂] (e : M ≃+ M₂)
Goal: e.toIntLinearEquiv.symm = e.symm.toIntLinearEquiv
-- AddEquiv.toIntLinearEquiv_refl
@[simp]
theorem toIntLinearEquiv_refl : (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M 
Arguments: {M : Type u_8} [AddCommGroup M]
Goal: (AddEquiv.refl M).toIntLinearEquiv = LinearEquiv.refl ℤ M
-- AddEquiv.toIntLinearEquiv_trans
@[simp]
theorem toIntLinearEquiv_trans (e₂ : M₂ ≃+ M₃) :
    e.toIntLinearEquiv.trans e₂.toIntLinearEquiv = (e.trans e₂).toIntLinearEquiv 
Arguments: {M : Type u_8} {M₂ : Type u_10} {M₃ : Type u_11} [AddCommGroup M] [AddCommGroup M₂] [AddCommGroup M₃] (e : M ≃+ M₂) (e₂ : M₂ ≃+ M₃)
Goal: e.toIntLinearEquiv ≪≫ₗ e₂.toIntLinearEquiv = (e.trans e₂).toIntLinearEquiv
-- LinearMap.ringLmapEquivSelf_apply
@[simps]
def ringLmapEquivSelf [Module S M] [SMulCommClass R S M] : (R →ₗ[R] M) ≃ₗ[S] M 
Arguments: (R : Type u_1) (S : Type u_7) (M : Type u_8) [Semiring R] [Semiring S] [AddCommMonoid M] [Module R M] [Module S M] [SMulCommClass R S M] (f : R →ₗ[R] M)
Goal: (LinearMap.ringLmapEquivSelf R S M) f = f 1
-- LinearMap.ringLmapEquivSelf_symm_apply
@[simps]
def ringLmapEquivSelf [Module S M] [SMulCommClass R S M] : (R →ₗ[R] M) ≃ₗ[S] M 
Arguments: (R : Type u_1) (S : Type u_7) (M : Type u_8) [Semiring R] [Semiring S] [AddCommMonoid M] [Module R M] [Module S M] [SMulCommClass R S M] (x : M)
Goal: (LinearMap.ringLmapEquivSelf R S M).symm x = LinearMap.smulRight 1 x
-- addMonoidHomLequivNat_apply
@[simps]
def addMonoidHomLequivNat {A B : Type*} (R : Type*) [Semiring R] [AddCommMonoid A]
    [AddCommMonoid B] [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B
    
Arguments: {A : Type u_17} {B : Type u_18} (R : Type u_19) [Semiring R] [AddCommMonoid A] [AddCommMonoid B] [Module R B] (f : A →+ B)
Goal: (addMonoidHomLequivNat R) f = f.toNatLinearMap
-- addMonoidHomLequivNat_symm_apply
@[simps]
def addMonoidHomLequivNat {A B : Type*} (R : Type*) [Semiring R] [AddCommMonoid A]
    [AddCommMonoid B] [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℕ] B
    
Arguments: {A : Type u_17} {B : Type u_18} (R : Type u_19) [Semiring R] [AddCommMonoid A] [AddCommMonoid B] [Module R B] (f : A →ₗ[ℕ] B)
Goal: (addMonoidHomLequivNat R).symm f = f.toAddMonoidHom
-- addMonoidHomLequivInt_symm_apply
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    
Arguments: {A : Type u_17} {B : Type u_18} (R : Type u_19) [Semiring R] [AddCommGroup A] [AddCommGroup B] [Module R B] (f : A →ₗ[ℤ] B)
Goal: (addMonoidHomLequivInt R).symm f = f.toAddMonoidHom
-- addMonoidHomLequivInt_apply
@[simps]
def addMonoidHomLequivInt {A B : Type*} (R : Type*) [Semiring R] [AddCommGroup A] [AddCommGroup B]
    [Module R B] : (A →+ B) ≃ₗ[R] A →ₗ[ℤ] B
    
Arguments: {A : Type u_17} {B : Type u_18} (R : Type u_19) [Semiring R] [AddCommGroup A] [AddCommGroup B] [Module R B] (f : A →+ B)
Goal: (addMonoidHomLequivInt R) f = f.toIntLinearMap
-- addMonoidEndRingEquivInt_apply
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A 
Arguments: (A : Type u_17) [AddCommGroup A]
Goal: ∀ (a : A →+ A), (addMonoidEndRingEquivInt A) a = (↑(addMonoidHomLequivInt ℤ)).toFun a
-- addMonoidEndRingEquivInt_symm_apply
@[simps] def addMonoidEndRingEquivInt (A : Type*) [AddCommGroup A] :
    AddMonoid.End A ≃+* Module.End ℤ A 
Arguments: (A : Type u_17) [AddCommGroup A]
Goal: ∀ (a : A →ₗ[ℤ] A), (addMonoidEndRingEquivInt A).symm a = (addMonoidHomLequivInt ℤ).invFun a
-- LinearEquiv.zero_symm
@[simp]
theorem zero_symm : (0 : M ≃ₛₗ[σ₁₂] M₂).symm = 0 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂] [Subsingleton M] [Subsingleton M₂]
Goal: LinearEquiv.symm 0 = 0
-- LinearEquiv.coe_zero
@[simp]
theorem coe_zero : ⇑(0 : M ≃ₛₗ[σ₁₂] M₂) = 0 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂] [Subsingleton M] [Subsingleton M₂]
Goal: ⇑0 = 0
-- LinearEquiv.zero_apply
theorem zero_apply (x : M) : (0 : M ≃ₛₗ[σ₁₂] M₂) x = 0 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [RingHomInvPair σ₁₂ σ₂₁] [RingHomInvPair σ₂₁ σ₁₂] [Subsingleton M] [Subsingleton M₂] (x : M)
Goal: 0 x = 0
-- LinearEquiv.coe_curry
@[simp]
theorem coe_curry : ⇑(LinearEquiv.curry R V V₂) = curry 
Arguments: (R : Type u_1) [Semiring R] (V : Type u_18) (V₂ : Type u_17)
Goal: ⇑(LinearEquiv.curry R V V₂) = Function.curry
-- LinearEquiv.coe_curry_symm
@[simp]
theorem coe_curry_symm : ⇑(LinearEquiv.curry R V V₂).symm = uncurry 
Arguments: (R : Type u_1) [Semiring R] (V : Type u_18) (V₂ : Type u_17)
Goal: ⇑(LinearEquiv.curry R V V₂).symm = Function.uncurry
-- LinearEquiv.ofLinear_apply
@[simp]
theorem ofLinear_apply {h₁ h₂} (x : M) : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂) x = f x 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₁] M) {h₁ : f.comp g = LinearMap.id} {h₂ : g.comp f = LinearMap.id} (x : M)
Goal: (LinearEquiv.ofLinear f g h₁ h₂) x = f x
-- LinearEquiv.ofLinear_symm_apply
@[simp]
theorem ofLinear_symm_apply {h₁ h₂} (x : M₂) : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂).symm x = g x 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₁] M) {h₁ : f.comp g = LinearMap.id} {h₂ : g.comp f = LinearMap.id} (x : M₂)
Goal: (LinearEquiv.ofLinear f g h₁ h₂).symm x = g x
-- LinearEquiv.ofLinear_toLinearMap
@[simp]
theorem ofLinear_toLinearMap {h₁ h₂} : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂) = f 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₁] M) {h₁ : f.comp g = LinearMap.id} {h₂ : g.comp f = LinearMap.id}
Goal: ↑(LinearEquiv.ofLinear f g h₁ h₂) = f
-- LinearEquiv.ofLinear_symm_toLinearMap
@[simp]
theorem ofLinear_symm_toLinearMap {h₁ h₂} : (ofLinear f g h₁ h₂ : M ≃ₛₗ[σ₁₂] M₂).symm = g 
Arguments: {R : Type u_1} {R₂ : Type u_3} {M : Type u_8} {M₂ : Type u_10} [Semiring R] [Semiring R₂] [AddCommMonoid M] [AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂} {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (f : M →ₛₗ[σ₁₂] M₂) (g : M₂ →ₛₗ[σ₂₁] M) {h₁ : f.comp g = LinearMap.id} {h₂ : g.comp f = LinearMap.id}
Goal: ↑(LinearEquiv.ofLinear f g h₁ h₂).symm = g
-- LinearEquiv.coe_neg
@[simp]
theorem coe_neg : ⇑(neg R : M ≃ₗ[R] M) = -id 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommGroup M] [Module R M]
Goal: ⇑(LinearEquiv.neg R) = -id
-- LinearEquiv.neg_apply
theorem neg_apply (x : M) : neg R x = -x 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommGroup M] [Module R M] (x : M)
Goal: (LinearEquiv.neg R) x = -x
-- LinearEquiv.symm_neg
@[simp]
theorem symm_neg : (neg R : M ≃ₗ[R] M).symm = neg R 
Arguments: {R : Type u_1} {M : Type u_8} [Semiring R] [AddCommGroup M] [Module R M]
Goal: (LinearEquiv.neg R).symm = LinearEquiv.neg R
-- LinearEquiv.arrowCongr_apply
@[simp]
theorem arrowCongr_apply {R M₁ M₂ M₂₁ M₂₂ : Sort _} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂]
    [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₁ →ₗ[R] M₂₁)
    (x : M₂) : arrowCongr e₁ e₂ f x = e₂ (f (e₁.symm x)) 
Arguments: {R : Type u_17} {M₁ : Type u_18} {M₂ : Type u_19} {M₂₁ : Type u_20} {M₂₂ : Type u_21} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂] [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₁ →ₗ[R] M₂₁) (x : M₂)
Goal: ((e₁.arrowCongr e₂) f) x = e₂ (f (e₁.symm x))
-- LinearEquiv.arrowCongr_symm_apply
@[simp]
theorem arrowCongr_symm_apply {R M₁ M₂ M₂₁ M₂₂ : Sort _} [CommSemiring R] [AddCommMonoid M₁]
    [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂]
    [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₂ →ₗ[R] M₂₂)
    (x : M₁) : (arrowCongr e₁ e₂).symm f x = e₂.symm (f (e₁ x)) 
Arguments: {R : Type u_17} {M₁ : Type u_18} {M₂ : Type u_19} {M₂₁ : Type u_20} {M₂₂ : Type u_21} [CommSemiring R] [AddCommMonoid M₁] [AddCommMonoid M₂] [AddCommMonoid M₂₁] [AddCommMonoid M₂₂] [Module R M₁] [Module R M₂] [Module R M₂₁] [Module R M₂₂] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : M₂₁ ≃ₗ[R] M₂₂) (f : M₂ →ₗ[R] M₂₂) (x : M₁)
Goal: ((e₁.arrowCongr e₂).symm f) x = e₂.symm (f (e₁ x))
-- LinearEquiv.arrowCongr_comp
theorem arrowCongr_comp {N N₂ N₃ : Sort _} [AddCommMonoid N] [AddCommMonoid N₂] [AddCommMonoid N₃]
    [Module R N] [Module R N₂] [Module R N₃] (e₁ : M ≃ₗ[R] N) (e₂ : M₂ ≃ₗ[R] N₂) (e₃ : M₃ ≃ₗ[R] N₃)
    (f : M →ₗ[R] M₂) (g : M₂ →ₗ[R] M₃) :
    arrowCongr e₁ e₃ (g.comp f) = (arrowCongr e₂ e₃ g).comp (arrowCongr e₁ e₂ f) 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} {M₃ : Type u_11} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommMonoid M₃] [Module R M] [Module R M₂] [Module R M₃] {N : Type u_17} {N₂ : Type u_18} {N₃ : Type u_19} [AddCommMonoid N] [AddCommMonoid N₂] [AddCommMonoid N₃] [Module R N] [Module R N₂] [Module R N₃] (e₁ : M ≃ₗ[R] N) (e₂ : M₂ ≃ₗ[R] N₂) (e₃ : M₃ ≃ₗ[R] N₃) (f : M →ₗ[R] M₂) (g : M₂ →ₗ[R] M₃)
Goal: (e₁.arrowCongr e₃) (g ∘ₗ f) = (e₂.arrowCongr e₃) g ∘ₗ (e₁.arrowCongr e₂) f
-- LinearEquiv.arrowCongr_trans
theorem arrowCongr_trans {M₁ M₂ M₃ N₁ N₂ N₃ : Sort _} [AddCommMonoid M₁] [Module R M₁]
    [AddCommMonoid M₂] [Module R M₂] [AddCommMonoid M₃] [Module R M₃] [AddCommMonoid N₁]
    [Module R N₁] [AddCommMonoid N₂] [Module R N₂] [AddCommMonoid N₃] [Module R N₃]
    (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : N₁ ≃ₗ[R] N₂) (e₃ : M₂ ≃ₗ[R] M₃) (e₄ : N₂ ≃ₗ[R] N₃) :
    (arrowCongr e₁ e₂).trans (arrowCongr e₃ e₄) = arrowCongr (e₁.trans e₃) (e₂.trans e₄) 
Arguments: {R : Type u_1} [CommSemiring R] {M₁ : Type u_17} {M₂ : Type u_18} {M₃ : Type u_19} {N₁ : Type u_20} {N₂ : Type u_21} {N₃ : Type u_22} [AddCommMonoid M₁] [Module R M₁] [AddCommMonoid M₂] [Module R M₂] [AddCommMonoid M₃] [Module R M₃] [AddCommMonoid N₁] [Module R N₁] [AddCommMonoid N₂] [Module R N₂] [AddCommMonoid N₃] [Module R N₃] (e₁ : M₁ ≃ₗ[R] M₂) (e₂ : N₁ ≃ₗ[R] N₂) (e₃ : M₂ ≃ₗ[R] M₃) (e₄ : N₂ ≃ₗ[R] N₃)
Goal: e₁.arrowCongr e₂ ≪≫ₗ e₃.arrowCongr e₄ = (e₁ ≪≫ₗ e₃).arrowCongr (e₂ ≪≫ₗ e₄)
-- LinearEquiv.conj_apply
theorem conj_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M) :
    e.conj f = ((↑e : M →ₗ[R] M₂).comp f).comp (e.symm : M₂ →ₗ[R] M) 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃ₗ[R] M₂) (f : Module.End R M)
Goal: e.conj f = (↑e ∘ₗ f) ∘ₗ ↑e.symm
-- LinearEquiv.conj_apply_apply
theorem conj_apply_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M) (x : M₂) :
    e.conj f x = e (f (e.symm x)) 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃ₗ[R] M₂) (f : Module.End R M) (x : M₂)
Goal: (e.conj f) x = e (f (e.symm x))
-- LinearEquiv.symm_conj_apply
theorem symm_conj_apply (e : M ≃ₗ[R] M₂) (f : Module.End R M₂) :
    e.symm.conj f = ((↑e.symm : M₂ →ₗ[R] M).comp f).comp (e : M →ₗ[R] M₂) 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃ₗ[R] M₂) (f : Module.End R M₂)
Goal: e.symm.conj f = (↑e.symm ∘ₗ f) ∘ₗ ↑e
-- LinearEquiv.conj_comp
theorem conj_comp (e : M ≃ₗ[R] M₂) (f g : Module.End R M) :
    e.conj (g.comp f) = (e.conj g).comp (e.conj f) 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃ₗ[R] M₂) (f g : Module.End R M)
Goal: e.conj (g ∘ₗ f) = e.conj g ∘ₗ e.conj f
-- LinearEquiv.conj_trans
theorem conj_trans (e₁ : M ≃ₗ[R] M₂) (e₂ : M₂ ≃ₗ[R] M₃) :
    e₁.conj.trans e₂.conj = (e₁.trans e₂).conj 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} {M₃ : Type u_11} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [AddCommMonoid M₃] [Module R M] [Module R M₂] [Module R M₃] (e₁ : M ≃ₗ[R] M₂) (e₂ : M₂ ≃ₗ[R] M₃)
Goal: e₁.conj ≪≫ₗ e₂.conj = (e₁ ≪≫ₗ e₂).conj
-- LinearEquiv.conj_id
@[simp]
theorem conj_id (e : M ≃ₗ[R] M₂) : e.conj LinearMap.id = LinearMap.id 
Arguments: {R : Type u_1} {M : Type u_8} {M₂ : Type u_10} [CommSemiring R] [AddCommMonoid M] [AddCommMonoid M₂] [Module R M] [Module R M₂] (e : M ≃ₗ[R] M₂)
Goal: e.conj LinearMap.id = LinearMap.id