ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- CoxeterSystem.exists_leftDescent_of_ne_one
theorem exists_leftDescent_of_ne_one {w : W} (hw : w ≠ 1) : ∃ i : B, cs.IsLeftDescent w i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} (hw : w ≠ 1)
Goal: ∃ i, cs.IsLeftDescent w i
-- CoxeterSystem.exists_rightDescent_of_ne_one
theorem exists_rightDescent_of_ne_one {w : W} (hw : w ≠ 1) : ∃ i : B, cs.IsRightDescent w i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} (hw : w ≠ 1)
Goal: ∃ i, cs.IsRightDescent w i
-- CoxeterSystem.isLeftDescent_iff
theorem isLeftDescent_iff {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ℓ (s i * w) + 1 = ℓ w 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: cs.IsLeftDescent w i ↔ cs.length (cs.simple i * w) + 1 = cs.length w
-- CoxeterSystem.not_isLeftDescent_iff
theorem not_isLeftDescent_iff {w : W} {i : B} :
    ¬cs.IsLeftDescent w i ↔ ℓ (s i * w) = ℓ w + 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: ¬cs.IsLeftDescent w i ↔ cs.length (cs.simple i * w) = cs.length w + 1
-- CoxeterSystem.isRightDescent_iff
theorem isRightDescent_iff {w : W} {i : B} :
    cs.IsRightDescent w i ↔ ℓ (w * s i) + 1 = ℓ w 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) + 1 = cs.length w
-- CoxeterSystem.not_isRightDescent_iff
theorem not_isRightDescent_iff {w : W} {i : B} :
    ¬cs.IsRightDescent w i ↔ ℓ (w * s i) = ℓ w + 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: ¬cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) = cs.length w + 1
-- CoxeterSystem.isLeftDescent_iff_not_isLeftDescent_mul
theorem isLeftDescent_iff_not_isLeftDescent_mul {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (s i * w) i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (cs.simple i * w) i
-- CoxeterSystem.isRightDescent_iff_not_isRightDescent_mul
theorem isRightDescent_iff_not_isRightDescent_mul {w : W} {i : B} :
    cs.IsRightDescent w i ↔ ¬cs.IsRightDescent (w * s i) i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W} {i : B}
Goal: cs.IsRightDescent w i ↔ ¬cs.IsRightDescent (w * cs.simple i) i
-- Equiv.optionCongr_one
@[simp]
theorem Equiv.optionCongr_one {α : Type*} : (1 : Perm α).optionCongr = 1 
Arguments: {α : Type u_1}
Goal: Equiv.optionCongr 1 = 1
-- Equiv.optionCongr_swap
@[simp]
theorem Equiv.optionCongr_swap {α : Type*} [DecidableEq α] (x y : α) :
    optionCongr (swap x y) = swap (some x) (some y) 
Arguments: {α : Type u_1} [DecidableEq α] (x y : α)
Goal: Equiv.optionCongr (Equiv.swap x y) = Equiv.swap (some x) (some y)
-- Equiv.optionCongr_sign
@[simp]
theorem Equiv.optionCongr_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
    Perm.sign e.optionCongr = Perm.sign e 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (e : Equiv.Perm α)
Goal: Equiv.Perm.sign (Equiv.optionCongr e) = Equiv.Perm.sign e
-- map_equiv_removeNone
@[simp]
theorem map_equiv_removeNone {α : Type*} [DecidableEq α] (σ : Perm (Option α)) :
    (removeNone σ).optionCongr = swap none (σ none) * σ 
Arguments: {α : Type u_1} [DecidableEq α] (σ : Equiv.Perm (Option α))
Goal: (Equiv.removeNone σ).optionCongr = Equiv.swap none (σ none) * σ
-- Equiv.Perm.decomposeOption_symm_apply
@[simps]
def Equiv.Perm.decomposeOption {α : Type*} [DecidableEq α] :
    Perm (Option α) ≃ Option α × Perm α 
Arguments: {α : Type u_1} [DecidableEq α] (i : Option α × Equiv.Perm α)
Goal: Equiv.Perm.decomposeOption.symm i = Equiv.swap none i.1 * Equiv.optionCongr i.2
-- Equiv.Perm.decomposeOption_apply
@[simps]
def Equiv.Perm.decomposeOption {α : Type*} [DecidableEq α] :
    Perm (Option α) ≃ Option α × Perm α 
Arguments: {α : Type u_1} [DecidableEq α] (σ : Equiv.Perm (Option α))
Goal: Equiv.Perm.decomposeOption σ = (σ none, Equiv.removeNone σ)
-- Equiv.Perm.decomposeOption_symm_of_none_apply
theorem Equiv.Perm.decomposeOption_symm_of_none_apply {α : Type*} [DecidableEq α] (e : Perm α)
    (i : Option α) : Equiv.Perm.decomposeOption.symm (none, e) i = i.map e 
Arguments: {α : Type u_1} [DecidableEq α] (e : Equiv.Perm α) (i : Option α)
Goal: (Equiv.Perm.decomposeOption.symm (none, e)) i = Option.map (⇑e) i
-- Equiv.Perm.decomposeOption_symm_sign
theorem Equiv.Perm.decomposeOption_symm_sign {α : Type*} [DecidableEq α] [Fintype α] (e : Perm α) :
    Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Perm.sign e 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (e : Equiv.Perm α)
Goal: Equiv.Perm.sign (Equiv.Perm.decomposeOption.symm (none, e)) = Equiv.Perm.sign e
-- Finset.univ_perm_option
theorem Finset.univ_perm_option {α : Type*} [DecidableEq α] [Fintype α] :
    @Finset.univ (Perm <| Option α) _ =
      (Finset.univ : Finset <| Option α × Perm α).map Equiv.Perm.decomposeOption.symm.toEmbedding 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: Finset.univ = Finset.map Equiv.Perm.decomposeOption.symm.toEmbedding Finset.univ
-- Equiv.Perm.exists_with_cycleType_iff
theorem Equiv.Perm.exists_with_cycleType_iff {m : Multiset ℕ} :
    (∃ g : Equiv.Perm α, g.cycleType = m) ↔
      (m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a) 
Arguments: (α : Type u_1) [DecidableEq α] [Fintype α] {m : Multiset ℕ}
Goal: (∃ g, g.cycleType = m) ↔ m.sum ≤ Fintype.card α ∧ ∀ a ∈ m, 2 ≤ a
-- Equiv.Perm.decomposeFin_symm_of_refl
@[simp]
theorem Equiv.Perm.decomposeFin_symm_of_refl {n : ℕ} (p : Fin (n + 1)) :
    Equiv.Perm.decomposeFin.symm (p, Equiv.refl _) = swap 0 p 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: Equiv.Perm.decomposeFin.symm (p, Equiv.refl (Fin n)) = Equiv.swap 0 p
-- Equiv.Perm.decomposeFin_symm_of_one
@[simp]
theorem Equiv.Perm.decomposeFin_symm_of_one {n : ℕ} (p : Fin (n + 1)) :
    Equiv.Perm.decomposeFin.symm (p, 1) = swap 0 p 
Arguments: {n : ℕ} (p : Fin (n + 1))
Goal: Equiv.Perm.decomposeFin.symm (p, 1) = Equiv.swap 0 p
-- Equiv.Perm.decomposeFin_symm_apply_zero
@[simp]
theorem Equiv.Perm.decomposeFin_symm_apply_zero {n : ℕ} (p : Fin (n + 1)) (e : Perm (Fin n)) :
    Equiv.Perm.decomposeFin.symm (p, e) 0 = p 
Arguments: {n : ℕ} (p : Fin (n + 1)) (e : Equiv.Perm (Fin n))
Goal: (Equiv.Perm.decomposeFin.symm (p, e)) 0 = p
-- Equiv.Perm.decomposeFin_symm_apply_succ
@[simp]
theorem Equiv.Perm.decomposeFin_symm_apply_succ {n : ℕ} (e : Perm (Fin n)) (p : Fin (n + 1))
    (x : Fin n) : Equiv.Perm.decomposeFin.symm (p, e) x.succ = swap 0 p (e x).succ 
Arguments: {n : ℕ} (e : Equiv.Perm (Fin n)) (p : Fin (n + 1)) (x : Fin n)
Goal: (Equiv.Perm.decomposeFin.symm (p, e)) x.succ = (Equiv.swap 0 p) (e x).succ
-- Equiv.Perm.decomposeFin_symm_apply_one
@[simp]
theorem Equiv.Perm.decomposeFin_symm_apply_one {n : ℕ} (e : Perm (Fin (n + 1))) (p : Fin (n + 2)) :
    Equiv.Perm.decomposeFin.symm (p, e) 1 = swap 0 p (e 0).succ 
Arguments: {n : ℕ} (e : Equiv.Perm (Fin (n + 1))) (p : Fin (n + 2))
Goal: (Equiv.Perm.decomposeFin.symm (p, e)) 1 = (Equiv.swap 0 p) (e 0).succ
-- Equiv.Perm.decomposeFin.symm_sign
@[simp]
theorem Equiv.Perm.decomposeFin.symm_sign {n : ℕ} (p : Fin (n + 1)) (e : Perm (Fin n)) :
    Perm.sign (Equiv.Perm.decomposeFin.symm (p, e)) = ite (p = 0) 1 (-1) * Perm.sign e 
Arguments: {n : ℕ} (p : Fin (n + 1)) (e : Equiv.Perm (Fin n))
Goal: Equiv.Perm.sign (Equiv.Perm.decomposeFin.symm (p, e)) = (if p = 0 then 1 else -1) * Equiv.Perm.sign e
-- Finset.univ_perm_fin_succ
theorem Finset.univ_perm_fin_succ {n : ℕ} :
    @Finset.univ (Perm <| Fin n.succ) _ =
      (Finset.univ : Finset <| Fin n.succ × Perm (Fin n)).map
        Equiv.Perm.decomposeFin.symm.toEmbedding 
Arguments: {n : ℕ}
Goal: Finset.univ = Finset.map Equiv.Perm.decomposeFin.symm.toEmbedding Finset.univ
-- finRotate_succ_eq_decomposeFin
theorem finRotate_succ_eq_decomposeFin {n : ℕ} :
    finRotate n.succ = decomposeFin.symm (1, finRotate n) 
Arguments: {n : ℕ}
Goal: finRotate n.succ = Equiv.Perm.decomposeFin.symm (1, finRotate n)
-- sign_finRotate
@[simp]
theorem sign_finRotate (n : ℕ) : Perm.sign (finRotate (n + 1)) = (-1) ^ n 
Arguments: (n : ℕ)
Goal: Equiv.Perm.sign (finRotate (n + 1)) = (-1) ^ n
-- support_finRotate
@[simp]
theorem support_finRotate {n : ℕ} : support (finRotate (n + 2)) = Finset.univ 
Arguments: {n : ℕ}
Goal: (finRotate (n + 2)).support = Finset.univ
-- support_finRotate_of_le
theorem support_finRotate_of_le {n : ℕ} (h : 2 ≤ n) : support (finRotate n) = Finset.univ 
Arguments: {n : ℕ} (h : 2 ≤ n)
Goal: (finRotate n).support = Finset.univ
-- isCycle_finRotate
theorem isCycle_finRotate {n : ℕ} : IsCycle (finRotate (n + 2)) 
Arguments: {n : ℕ}
Goal: (finRotate (n + 2)).IsCycle
-- isCycle_finRotate_of_le
theorem isCycle_finRotate_of_le {n : ℕ} (h : 2 ≤ n) : IsCycle (finRotate n) 
Arguments: {n : ℕ} (h : 2 ≤ n)
Goal: (finRotate n).IsCycle
-- cycleType_finRotate
@[simp]
theorem cycleType_finRotate {n : ℕ} : cycleType (finRotate (n + 2)) = {n + 2} 
Arguments: {n : ℕ}
Goal: (finRotate (n + 2)).cycleType = {n + 2}
-- cycleType_finRotate_of_le
theorem cycleType_finRotate_of_le {n : ℕ} (h : 2 ≤ n) : cycleType (finRotate n) = {n} 
Arguments: {n : ℕ} (h : 2 ≤ n)
Goal: (finRotate n).cycleType = {n}
-- Fin.cycleRange_of_gt
theorem cycleRange_of_gt {n : ℕ} {i j : Fin n.succ} (h : i < j) : cycleRange i j = j 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : i < j)
Goal: i.cycleRange j = j
-- Fin.cycleRange_of_le
theorem cycleRange_of_le {n : ℕ} {i j : Fin n.succ} (h : j ≤ i) :
    cycleRange i j = if j = i then 0 else j + 1 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : j ≤ i)
Goal: i.cycleRange j = if j = i then 0 else j + 1
-- Fin.coe_cycleRange_of_le
theorem coe_cycleRange_of_le {n : ℕ} {i j : Fin n.succ} (h : j ≤ i) :
    (cycleRange i j : ℕ) = if j = i then 0 else (j : ℕ) + 1 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : j ≤ i)
Goal: ↑(i.cycleRange j) = if j = i then 0 else ↑j + 1
-- Fin.cycleRange_of_lt
theorem cycleRange_of_lt {n : ℕ} {i j : Fin n.succ} (h : j < i) : cycleRange i j = j + 1 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : j < i)
Goal: i.cycleRange j = j + 1
-- Fin.coe_cycleRange_of_lt
theorem coe_cycleRange_of_lt {n : ℕ} {i j : Fin n.succ} (h : j < i) :
    (cycleRange i j : ℕ) = j + 1 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : j < i)
Goal: ↑(i.cycleRange j) = ↑j + 1
-- Fin.cycleRange_of_eq
theorem cycleRange_of_eq {n : ℕ} {i j : Fin n.succ} (h : j = i) : cycleRange i j = 0 
Arguments: {n : ℕ} {i j : Fin n.succ} (h : j = i)
Goal: i.cycleRange j = 0
-- Fin.cycleRange_self
@[simp]
theorem cycleRange_self {n : ℕ} (i : Fin n.succ) : cycleRange i i = 0 
Arguments: {n : ℕ} (i : Fin n.succ)
Goal: i.cycleRange i = 0
-- Fin.cycleRange_apply
theorem cycleRange_apply {n : ℕ} (i j : Fin n.succ) :
    cycleRange i j = if j < i then j + 1 else if j = i then 0 else j 
Arguments: {n : ℕ} (i j : Fin n.succ)
Goal: i.cycleRange j = if j < i then j + 1 else if j = i then 0 else j
-- Fin.cycleRange_zero
@[simp]
theorem cycleRange_zero (n : ℕ) : cycleRange (0 : Fin n.succ) = 1 
Arguments: (n : ℕ)
Goal: Fin.cycleRange 0 = 1
-- Fin.cycleRange_last
@[simp]
theorem cycleRange_last (n : ℕ) : cycleRange (last n) = finRotate (n + 1) 
Arguments: (n : ℕ)
Goal: (Fin.last n).cycleRange = finRotate (n + 1)
-- Fin.cycleRange_zero'
@[simp]
theorem cycleRange_zero' {n : ℕ} (h : 0 < n) : cycleRange ⟨0, h⟩ = 1 
Arguments: {n : ℕ} (h : 0 < n)
Goal: ⟨0, h⟩.cycleRange = 1
-- Fin.sign_cycleRange
@[simp]
theorem sign_cycleRange {n : ℕ} (i : Fin n) : Perm.sign (cycleRange i) = (-1) ^ (i : ℕ) 
Arguments: {n : ℕ} (i : Fin n)
Goal: Equiv.Perm.sign i.cycleRange = (-1) ^ ↑i
-- Fin.succAbove_cycleRange
@[simp]
theorem succAbove_cycleRange {n : ℕ} (i j : Fin n) :
    i.succ.succAbove (i.cycleRange j) = swap 0 i.succ j.succ 
Arguments: {n : ℕ} (i j : Fin n)
Goal: i.succ.succAbove (i.cycleRange j) = (Equiv.swap 0 i.succ) j.succ
-- Fin.cycleRange_succAbove
@[simp]
theorem cycleRange_succAbove {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :
    i.cycleRange (i.succAbove j) = j.succ 
Arguments: {n : ℕ} (i : Fin (n + 1)) (j : Fin n)
Goal: i.cycleRange (i.succAbove j) = j.succ
-- Fin.cycleRange_symm_zero
@[simp]
theorem cycleRange_symm_zero {n : ℕ} (i : Fin (n + 1)) : i.cycleRange.symm 0 = i 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: (Equiv.symm i.cycleRange) 0 = i
-- Fin.cycleRange_symm_succ
@[simp]
theorem cycleRange_symm_succ {n : ℕ} (i : Fin (n + 1)) (j : Fin n) :
    i.cycleRange.symm j.succ = i.succAbove j 
Arguments: {n : ℕ} (i : Fin (n + 1)) (j : Fin n)
Goal: (Equiv.symm i.cycleRange) j.succ = i.succAbove j
-- Fin.isCycle_cycleRange
theorem isCycle_cycleRange {n : ℕ} {i : Fin (n + 1)} (h0 : i ≠ 0) : IsCycle (cycleRange i) 
Arguments: {n : ℕ} {i : Fin (n + 1)} (h0 : i ≠ 0)
Goal: i.cycleRange.IsCycle
-- Fin.cycleType_cycleRange
@[simp]
theorem cycleType_cycleRange {n : ℕ} {i : Fin (n + 1)} (h0 : i ≠ 0) :
    cycleType (cycleRange i) = {(i + 1 : ℕ)} 
Arguments: {n : ℕ} {i : Fin (n + 1)} (h0 : i ≠ 0)
Goal: i.cycleRange.cycleType = {↑i + 1}
-- Fin.isThreeCycle_cycleRange_two
theorem isThreeCycle_cycleRange_two {n : ℕ} : IsThreeCycle (cycleRange 2 : Perm (Fin (n + 3))) 
Arguments: {n : ℕ}
Goal: (Fin.cycleRange 2).IsThreeCycle
-- MulActionHom.map_smul'
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_nonempty_instance]
structure MulActionHom where
    protected toFun : X → Y
    protected map_smul' : ∀ (m : M) (x : X), toFun (m • x) = (φ m) • toFun x
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] (self : X →ₑ[φ] Y) (m : M) (x : X)
Goal: self.toFun (m • x) = φ m • self.toFun x
-- MulActionSemiHomClass.map_smulₛₗ
class MulActionSemiHomClass (F : Type*)
    {M N : outParam Type*} (φ : outParam (M → N))
    (X Y : outParam Type*) [SMul M X] [SMul N Y] [FunLike F X Y] : Prop where
    map_smulₛₗ : ∀ (f : F) (c : M) (x : X), f (c • x) = (φ c) • (f x)
Arguments: {F : Type u_8} {M : outParam (Type u_9)} {N : outParam (Type u_10)} {φ : outParam (M → N)} {X : outParam (Type u_11)} {Y : outParam (Type u_12)} [SMul M X] [SMul N Y] [FunLike F X Y] [self : MulActionSemiHomClass F φ X Y] (f : F) (c : M) (x : X)
Goal: f (c • x) = φ c • f x
-- map_smul
@[simp]
theorem map_smul {F M X Y : Type*} [SMul M X] [SMul M Y]
    [FunLike F X Y] [MulActionHomClass F M X Y]
    (f : F) (c : M) (x : X) : f (c • x) = c • f x 
Arguments: {F : Type u_8} {M : Type u_9} {X : Type u_10} {Y : Type u_11} [SMul M X] [SMul M Y] [FunLike F X Y] [MulActionHomClass F M X Y] (f : F) (c : M) (x : X)
Goal: f (c • x) = c • f x
-- IsScalarTower.smulHomClass
theorem _root_.IsScalarTower.smulHomClass [MulOneClass X] [SMul X Y] [IsScalarTower M' X Y]
    [MulActionHomClass F X X Y] : MulActionHomClass F M' X Y 
Arguments: (M' : Type u_1) (X : Type u_5) [SMul M' X] (Y : Type u_6) [SMul M' Y] (F : Type u_8) [FunLike F X Y] [MulOneClass X] [SMul X Y] [IsScalarTower M' X Y] [MulActionHomClass F X X Y]
Goal: MulActionHomClass F M' X Y
-- MulActionHom.map_smul
protected theorem map_smul (f : X →[M'] Y) (m : M') (x : X) : f (m • x) = m • f x 
Arguments: {M' : Type u_1} {X : Type u_5} [SMul M' X] {Y : Type u_6} [SMul M' Y] (f : X →ₑ[id] Y) (m : M') (x : X)
Goal: f (m • x) = m • f x
-- MulActionHom.ext
@[ext]
theorem ext {f g : X →ₑ[φ] Y} :
    (∀ x, f x = g x) → f = g 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {f g : X →ₑ[φ] Y}
Goal: (∀ (x : X), f x = g x) → f = g
-- MulActionHom.ext_iff
protected theorem ext_iff  {f g : X →ₑ[φ] Y} :
    f = g ↔ ∀ x, f x = g x 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {f g : X →ₑ[φ] Y}
Goal: f = g ↔ ∀ (x : X), f x = g x
-- MulActionHom.congr_fun
protected theorem congr_fun {f g : X →ₑ[φ] Y} (h : f = g) (x : X) :
    f x = g x 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {f g : X →ₑ[φ] Y} (h : f = g) (x : X)
Goal: f x = g x
-- MulActionHom.ofEq_coe
@[simp]
theorem ofEq_coe {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) :
    (f.ofEq h).toFun = f.toFun 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y)
Goal: (MulActionHom.ofEq h f).toFun = f.toFun
-- MulActionHom.ofEq_apply
@[simp]
theorem ofEq_apply {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) (a : X) :
    (f.ofEq h) a = f a 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : M → N} (h : φ = φ') (f : X →ₑ[φ] Y) (a : X)
Goal: (MulActionHom.ofEq h f) a = f a
-- MulActionHom.id_apply
@[simp]
theorem id_apply (x : X) :
    MulActionHom.id M x = x 
Arguments: {M : Type u_2} {X : Type u_5} [SMul M X] (x : X)
Goal: (MulActionHom.id M) x = x
-- MulActionHom.comp_apply
@[simp]
theorem comp_apply
    (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y) [CompTriple φ ψ χ] (x : X) :
    g.comp f x = g (f x) 
Arguments: {M : Type u_2} {N : Type u_3} {P : Type u_4} {φ : M → N} {ψ : N → P} {χ : M → P} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {Z : Type u_7} [SMul P Z] (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y) [CompTriple φ ψ χ] (x : X)
Goal: (g.comp f) x = g (f x)
-- MulActionHom.id_comp
@[simp]
theorem id_comp (f : X →ₑ[φ] Y) :
    (MulActionHom.id N).comp f = f 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] (f : X →ₑ[φ] Y)
Goal: (MulActionHom.id N).comp f = f
-- MulActionHom.comp_id
@[simp]
theorem comp_id (f : X →ₑ[φ] Y) :
    f.comp (MulActionHom.id M) = f 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] (f : X →ₑ[φ] Y)
Goal: f.comp (MulActionHom.id M) = f
-- MulActionHom.comp_assoc
@[simp]
theorem comp_assoc {Q T : Type*} [SMul Q T]
    {η : P → Q} {θ : M → Q} {ζ : N → Q}
    (h : Z →ₑ[η] T) (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y)
    [CompTriple φ ψ χ] [CompTriple χ η θ]
    [CompTriple ψ η ζ] [CompTriple φ ζ θ] :
    h.comp (g.comp f) = (h.comp g).comp f 
Arguments: {M : Type u_2} {N : Type u_3} {P : Type u_4} {φ : M → N} {ψ : N → P} {χ : M → P} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {Z : Type u_7} [SMul P Z] {Q : Type u_8} {T : Type u_9} [SMul Q T] {η : P → Q} {θ : M → Q} {ζ : N → Q} (h : Z →ₑ[η] T) (g : Y →ₑ[ψ] Z) (f : X →ₑ[φ] Y) [CompTriple φ ψ χ] [CompTriple χ η θ] [CompTriple ψ η ζ] [CompTriple φ ζ θ]
Goal: h.comp (g.comp f) = (h.comp g).comp f
-- MulActionHom.inverse_apply
@[simps]
def inverse (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) : Y₁ →[M] X 
Arguments: {M : Type u_2} {X : Type u_5} [SMul M X] {Y₁ : Type u_8} [SMul M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : Y₁), (f.inverse g h₁ h₂) a = g a
-- MulActionHom.inverse'_apply
@[simps]
def inverse' (f : X →ₑ[φ] Y) (g : Y → X) (k : Function.RightInverse φ' φ)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
    Y →ₑ[φ'] X 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : N → M} (f : X →ₑ[φ] Y) (g : Y → X) (k : Function.RightInverse φ' φ) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: ∀ (a : Y), (f.inverse' g k h₁ h₂) a = g a
-- MulActionHom.inverse_eq_inverse'
lemma inverse_eq_inverse' (f : X →[M] Y₁) (g : Y₁ → X)
    (h₁ : Function.LeftInverse g f) (h₂ : Function.RightInverse g f) :
  inverse f g h₁ h₂ =  inverse' f g (congrFun rfl) h₁ h₂ 
Arguments: {M : Type u_2} {X : Type u_5} [SMul M X] {Y₁ : Type u_8} [SMul M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X) (h₁ : Function.LeftInverse g ⇑f) (h₂ : Function.RightInverse g ⇑f)
Goal: f.inverse g h₁ h₂ = f.inverse' g ⋯ h₁ h₂
-- MulActionHom.inverse'_inverse'
theorem inverse'_inverse'
    {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    inverse' (inverse' f g k₂ h₁ h₂) f k₁ h₂ h₁ = f 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ} {h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}
Goal: (f.inverse' g k₂ h₁ h₂).inverse' (⇑f) k₁ h₂ h₁ = f
-- MulActionHom.comp_inverse'
theorem comp_inverse' {f : X →ₑ[φ] Y} {g : Y → X}
    {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    (inverse' f g k₂ h₁ h₂).comp f (κ := CompTriple.comp_inv k₁)
      = MulActionHom.id M 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₁ : Function.LeftInverse φ' φ} {k₂ : Function.RightInverse φ' φ} {h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}
Goal: (f.inverse' g k₂ h₁ h₂).comp f = MulActionHom.id M
-- MulActionHom.inverse'_comp
theorem inverse'_comp {f : X →ₑ[φ] Y} {g : Y → X}
    {k₂ : Function.RightInverse φ' φ}
    {h₁ : Function.LeftInverse g f} {h₂ : Function.RightInverse g f} :
    f.comp (inverse' f g k₂ h₁ h₂) (κ := CompTriple.comp_inv k₂) = MulActionHom.id N 
Arguments: {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [SMul M X] {Y : Type u_6} [SMul N Y] {φ' : N → M} {f : X →ₑ[φ] Y} {g : Y → X} {k₂ : Function.RightInverse φ' φ} {h₁ : Function.LeftInverse g ⇑f} {h₂ : Function.RightInverse g ⇑f}
Goal: f.comp (f.inverse' g k₂ h₁ h₂) = MulActionHom.id N
-- SMulCommClass.toMulActionHom_apply
@[simps]
def _root_.SMulCommClass.toMulActionHom {M} (N α : Type*)
    [SMul M α] [SMul N α] [SMulCommClass M N α] (c : M) :
    α →[N] α 
Arguments: {M : Type u_11} (N : Type u_9) (α : Type u_10) [SMul M α] [SMul N α] [SMulCommClass M N α] (c : M)
Goal: ∀ (x : α), (SMulCommClass.toMulActionHom N α c) x = c • x
-- SMulCommClass.toDistribMulActionHom_toFun
@[simps]
def _root_.SMulCommClass.toDistribMulActionHom {M} (N A : Type*) [Monoid N] [AddMonoid A]
    [DistribSMul M A] [DistribMulAction N A] [SMulCommClass M N A] (c : M) : A →+[N] A 
Arguments: {M : Type u_13} (N : Type u_11) (A : Type u_12) [Monoid N] [AddMonoid A] [DistribSMul M A] [DistribMulAction N A] [SMulCommClass M N A] (c : M)
Goal: ∀ (x : A), (SMulCommClass.toDistribMulActionHom N A c) x = c • x
-- DistribMulActionHom.toFun_eq_coe
@[simp]
theorem toFun_eq_coe (f : A →ₑ+[φ] B) : f.toFun = f 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_2} [Monoid N] {φ : M →* N} {A : Type u_4} [AddMonoid A] [DistribMulAction M A] {B : Type u_5} [AddMonoid B] [DistribMulAction N B] (f : A →ₑ+[φ] B)
Goal: f.toFun = ⇑f
-- DistribMulActionHom.coe_fn_coe
@[norm_cast]
theorem coe_fn_coe (f : A →ₑ+[φ] B) : ⇑(f : A →+ B) = f 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_2} [Monoid N] {φ : M →* N} {A : Type u_4} [AddMonoid A] [DistribMulAction M A] {B : Type u_5} [AddMonoid B] [DistribMulAction N B] (f : A →ₑ+[φ] B)
Goal: ⇑↑f = ⇑f
-- DistribMulActionHom.coe_fn_coe'
@[norm_cast]
theorem coe_fn_coe' (f : A →ₑ+[φ] B) : ⇑(f : A →ₑ[φ] B) = f 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_2} [Monoid N] {φ : M →* N} {A : Type u_4} [AddMonoid A] [DistribMulAction M A] {B : Type u_5} [AddMonoid B] [DistribMulAction N B] (f : A →ₑ+[φ] B)
Goal: ⇑↑f = ⇑f
-- DistribMulActionHom.ext
@[ext]
theorem ext {f g : A →ₑ+[φ] B} : (∀ x, f x = g x) → f = g 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_2} [Monoid N] {φ : M →* N} {A : Type u_4} [AddMonoid A] [DistribMulAction M A] {B : Type u_5} [AddMonoid B] [DistribMulAction N B] {f g : A →ₑ+[φ] B}
Goal: (∀ (x : A), f x = g x) → f = g
-- DistribMulActionHom.ext_iff
theorem ext_iff {f g : A →ₑ+[φ] B} : f = g ↔ ∀ x, f x = g x 
Arguments: {M : Type u_1} [Monoid M] {N : Type u_2} [Monoid N] {φ : M →* N} {A : Type u_4} [AddMonoid A] [DistribMulAction M A] {B : Type u_5} [AddMonoid B] [DistribMulAction N B] {f g : A →ₑ+[φ] B}
Goal: f = g ↔ ∀ (x : A), f x = g x