ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Array.all_def
theorem all_def {p : α → Bool} (as : Array α) : as.all p = as.data.all p 
Arguments: {α : Type u_1} {p : α → Bool} (as : Array α)
Goal: as.all p 0 = as.data.all p
-- Array.all_eq_true_iff_forall_mem
theorem all_eq_true_iff_forall_mem {l : Array α} : l.all p ↔ ∀ x, x ∈ l → p x 
Arguments: {α : Type u_1} {p : α → Bool} {l : Array α}
Goal: l.all p 0 = true ↔ ∀ (x : α), x ∈ l → p x = true
-- Array.contains_def
theorem contains_def [DecidableEq α] {a : α} {as : Array α} : as.contains a ↔ a ∈ as 
Arguments: {α : Type u_1} [DecidableEq α] {a : α} {as : Array α}
Goal: as.contains a = true ↔ a ∈ as
-- Array.get_swap_right
@[simp] theorem get_swap_right (a : Array α) {i j : Fin a.size} : (a.swap i j)[j.val] = a[i] 
Arguments: {α : Type u_1} (a : Array α) {i j : Fin a.size}
Goal: (a.swap i j)[↑j] = a[i]
-- Array.get_swap_left
@[simp] theorem get_swap_left (a : Array α) {i j : Fin a.size} : (a.swap i j)[i.val] = a[j] 
Arguments: {α : Type u_1} (a : Array α) {i j : Fin a.size}
Goal: (a.swap i j)[↑i] = a[j]
-- Array.get_swap_of_ne
@[simp] theorem get_swap_of_ne (a : Array α) {i j : Fin a.size} (hp : p < a.size)
    (hi : p ≠ i) (hj : p ≠ j) : (a.swap i j)[p]'(a.size_swap .. |>.symm ▸ hp) = a[p] 
Arguments: {α : Type u_1} {p : Nat} (a : Array α) {i j : Fin a.size} (hp : p < a.size) (hi : p ≠ ↑i) (hj : p ≠ ↑j)
Goal: (a.swap i j)[p] = a[p]
-- Array.get_swap
theorem get_swap (a : Array α) (i j : Fin a.size) (k : Nat) (hk: k < a.size) :
    (a.swap i j)[k]'(by simp_all) = if k = i then a[j] else if k = j then a[i]  else a[k] 
Arguments: {α : Type u_1} (a : Array α) (i j : Fin a.size) (k : Nat) (hk : k < a.size)
Goal: (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]
-- Array.get_swap'
theorem get_swap' (a : Array α) (i j : Fin a.size) (k : Nat) (hk' : k < (a.swap i j).size) :
    (a.swap i j)[k] = if k = i then a[j] else if k = j then a[i] else a[k]'(by simp_all) 
Arguments: {α : Type u_1} (a : Array α) (i j : Fin a.size) (k : Nat) (hk' : k < (a.swap i j).size)
Goal: (a.swap i j)[k] = if k = ↑i then a[j] else if k = ↑j then a[i] else a[k]
-- Array.swap_swap
@[simp] theorem swap_swap (a : Array α) {i j : Fin a.size} :
    (a.swap i j).swap ⟨i.1, (a.size_swap ..).symm ▸i.2⟩ ⟨j.1, (a.size_swap ..).symm ▸j.2⟩ = a 
Arguments: {α : Type u_1} (a : Array α) {i j : Fin a.size}
Goal: (a.swap i j).swap ⟨↑i, ⋯⟩ ⟨↑j, ⋯⟩ = a
-- Array.swap_comm
theorem swap_comm (a : Array α) {i j : Fin a.size} : a.swap i j = a.swap j i 
Arguments: {α : Type u_1} (a : Array α) {i j : Fin a.size}
Goal: a.swap i j = a.swap j i
-- Lean.Diff.Histogram.Entry.leftWF
structure Histogram.Entry (α : Type u) (lsize rsize : Nat) where
    leftCount : Nat
    leftIndex : Option (Fin lsize)
    leftWF : leftCount = 0 ↔ leftIndex = none
    rightCount : Nat
    rightIndex : Option (Fin rsize)
    rightWF : rightCount = 0 ↔ rightIndex = none
Arguments: {α : Type u} {lsize rsize : Nat} (self : Lean.Diff.Histogram.Entry α lsize rsize)
Goal: self.leftCount = 0 ↔ self.leftIndex = none
-- Lean.Diff.Histogram.Entry.rightWF
structure Histogram.Entry (α : Type u) (lsize rsize : Nat) where
    leftCount : Nat
    leftIndex : Option (Fin lsize)
    leftWF : leftCount = 0 ↔ leftIndex = none
    rightCount : Nat
    rightIndex : Option (Fin rsize)
    rightWF : rightCount = 0 ↔ rightIndex = none
Arguments: {α : Type u} {lsize rsize : Nat} (self : Lean.Diff.Histogram.Entry α lsize rsize)
Goal: self.rightCount = 0 ↔ self.rightIndex = none
-- Lean.HashMapBucket.size_update
@[simp] theorem HashMapBucket.size_update {α : Type u} {β : Type v} (data : HashMapBucket α β) (i : USize) (d : AssocList α β)
    (h : i.toNat < data.val.size) : (data.update i d h).val.size = data.val.size 
Arguments: {α : Type u} {β : Type v} (data : Lean.HashMapBucket α β) (i : USize) (d : Lean.AssocList α β) (h : i.toNat < data.val.size)
Goal: (data.update i d h).val.size = data.val.size
-- Lean.HashSetBucket.size_update
@[simp] theorem HashSetBucket.size_update {α : Type u} (data : HashSetBucket α) (i : USize) (d : List α) (h : i.toNat < data.val.size) :
    (data.update i d h).val.size = data.val.size 
Arguments: {α : Type u} (data : Lean.HashSetBucket α) (i : USize) (d : List α) (h : i.toNat < data.val.size)
Goal: (data.update i d h).val.size = data.val.size
-- _private.«.lake».packages.lean4.src.lean.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.size_set
private theorem size_set {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (i : Fin ks.size) (j : Fin vs.size) (k : α) (v : β)
                           : (ks.set i k).size = (vs.set j v).size 
Arguments: {α : Type u_1} {β : Type u_2} {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (i : Fin ks.size) (j : Fin vs.size) (k : α) (v : β)
Goal: (ks.set i k).size = (vs.set j v).size
-- _private.«.lake».packages.lean4.src.lean.Lean.Data.PersistentHashMap.0.Lean.PersistentHashMap.size_push
private theorem size_push {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (k : α) (v : β) : (ks.push k).size = (vs.push v).size 
Arguments: {α : Type u_1} {β : Type u_2} {ks : Array α} {vs : Array β} (h : ks.size = vs.size) (k : α) (v : β)
Goal: (ks.push k).size = (vs.push v).size
-- _private.«.lake».packages.lean4.src.lean.Lean.Meta.Tactic.Rfl.0.Lean.Meta.Rfl.rel_of_eq_and_refl
private theorem rel_of_eq_and_refl {α : Sort _} {R : α → α → Prop}
    {x y : α} (hxy : x = y) (h : R x x) : R x y 
Arguments: {α : Sort u_1} {R : α → α → Prop} {x y : α} (hxy : x = y) (h : R x x)
Goal: R x y
-- List.nonzeroMinimum_eq_zero_iff
@[simp] theorem nonzeroMinimum_eq_zero_iff {xs : List Nat} :
    xs.nonzeroMinimum = 0 ↔ ∀ x ∈ xs, x = 0 
Arguments: {xs : List Nat}
Goal: xs.nonzeroMinimum = 0 ↔ ∀ (x : Nat), x ∈ xs → x = 0
-- List.nonzeroMinimum_mem
theorem nonzeroMinimum_mem {xs : List Nat} (w : xs.nonzeroMinimum ≠ 0) :
    xs.nonzeroMinimum ∈ xs 
Arguments: {xs : List Nat} (w : xs.nonzeroMinimum ≠ 0)
Goal: xs.nonzeroMinimum ∈ xs
-- List.nonzeroMinimum_pos
theorem nonzeroMinimum_pos {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : 0 < xs.nonzeroMinimum 
Arguments: {a : Nat} {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0)
Goal: 0 < xs.nonzeroMinimum
-- List.nonzeroMinimum_le
theorem nonzeroMinimum_le {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0) : xs.nonzeroMinimum ≤ a 
Arguments: {a : Nat} {xs : List Nat} (m : a ∈ xs) (h : a ≠ 0)
Goal: xs.nonzeroMinimum ≤ a
-- List.nonzeroMinimum_eq_nonzero_iff
theorem nonzeroMinimum_eq_nonzero_iff {xs : List Nat} {y : Nat} (h : y ≠ 0) :
    xs.nonzeroMinimum = y ↔ y ∈ xs ∧ (∀ x ∈ xs, y ≤ x ∨ x = 0) 
Arguments: {xs : List Nat} {y : Nat} (h : y ≠ 0)
Goal: xs.nonzeroMinimum = y ↔ y ∈ xs ∧ ∀ (x : Nat), x ∈ xs → y ≤ x ∨ x = 0
-- List.nonzeroMinimum_eq_of_nonzero
theorem nonzeroMinimum_eq_of_nonzero {xs : List Nat} (h : xs.nonzeroMinimum ≠ 0) :
    ∃ x ∈ xs, xs.nonzeroMinimum = x 
Arguments: {xs : List Nat} (h : xs.nonzeroMinimum ≠ 0)
Goal: ∃ x, x ∈ xs ∧ xs.nonzeroMinimum = x
-- List.nonzeroMinimum_le_iff
theorem nonzeroMinimum_le_iff {xs : List Nat} {y : Nat} :
    xs.nonzeroMinimum ≤ y ↔ xs.nonzeroMinimum = 0 ∨ ∃ x ∈ xs, x ≤ y ∧ x ≠ 0 
Arguments: {xs : List Nat} {y : Nat}
Goal: xs.nonzeroMinimum ≤ y ↔ xs.nonzeroMinimum = 0 ∨ ∃ x, x ∈ xs ∧ x ≤ y ∧ x ≠ 0
-- List.nonzeroMininum_map_le_nonzeroMinimum
theorem nonzeroMininum_map_le_nonzeroMinimum (f : α → β) (p : α → Nat) (q : β → Nat) (xs : List α)
    (h : ∀ a, a ∈ xs → (p a = 0 ↔ q (f a) = 0))
    (w : ∀ a, a ∈ xs → p a ≠ 0 → q (f a) ≤ p a) :
    ((xs.map f).map q).nonzeroMinimum ≤ (xs.map p).nonzeroMinimum 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → β) (p : α → Nat) (q : β → Nat) (xs : List α) (h : ∀ (a : α), a ∈ xs → (p a = 0 ↔ q (f a) = 0)) (w : ∀ (a : α), a ∈ xs → p a ≠ 0 → q (f a) ≤ p a)
Goal: (List.map q (List.map f xs)).nonzeroMinimum ≤ (List.map p xs).nonzeroMinimum
-- List.minNatAbs_eq_zero_iff
@[simp] theorem minNatAbs_eq_zero_iff {xs : List Int} : xs.minNatAbs = 0 ↔ ∀ y ∈ xs, y = 0 
Arguments: {xs : List Int}
Goal: xs.minNatAbs = 0 ↔ ∀ (y : Int), y ∈ xs → y = 0
-- List.minNatAbs_eq_nonzero_iff
theorem minNatAbs_eq_nonzero_iff (xs : List Int) (w : z ≠ 0) :
    xs.minNatAbs = z ↔ (∃ y ∈ xs, y.natAbs = z) ∧ (∀ y ∈ xs, z ≤ y.natAbs ∨ y = 0) 
Arguments: {z : Nat} (xs : List Int) (w : z ≠ 0)
Goal: xs.minNatAbs = z ↔ (∃ y, y ∈ xs ∧ y.natAbs = z) ∧ ∀ (y : Int), y ∈ xs → z ≤ y.natAbs ∨ y = 0
-- List.minNatAbs_nil
@[simp] theorem minNatAbs_nil : ([] : List Int).minNatAbs = 0 
Goal: [].minNatAbs = 0
-- Lean.Elab.Tactic.Omega.Problem.proveFalse?_spec
structure Problem where
    assumptions : Array Proof := ∅
    numVars : Nat := 0
    constraints : HashMap Coeffs Fact := ∅
    equalities : HashSet Coeffs := ∅
    eliminations : List (Fact × Nat × Int) := []
    possible : Bool := true
    proveFalse? : Option Proof := none
    proveFalse?_spec : possible || proveFalse?.isSome := by rfl
    explanation? : Thunk String := ""
Arguments: (self : Lean.Elab.Tactic.Omega.Problem)
Goal: (self.possible || self.proveFalse?.isSome) = true
-- AddSubsemigroup.mem_center_iff
@[to_additive]
theorem mem_center_iff {z : M} : z ∈ center M ↔ ∀ g, g * z = z * g 
Arguments: {M : Type u_1} [AddSemigroup M] {z : M}
Goal: z ∈ AddSubsemigroup.center M ↔ ∀ (g : M), g + z = z + g
-- Subsemigroup.mem_center_iff
@[to_additive]
theorem mem_center_iff {z : M} : z ∈ center M ↔ ∀ g, g * z = z * g 
Arguments: {M : Type u_1} [Semigroup M] {z : M}
Goal: z ∈ Subsemigroup.center M ↔ ∀ (g : M), g * z = z * g
-- Subsemigroup.center_eq_top
@[to_additive (attr := simp)]
theorem center_eq_top : center M = ⊤ 
Arguments: (M : Type u_1) [CommSemigroup M]
Goal: Subsemigroup.center M = ⊤
-- AddSubsemigroup.center_eq_top
@[to_additive (attr := simp)]
theorem center_eq_top : center M = ⊤ 
Arguments: (M : Type u_1) [AddCommSemigroup M]
Goal: AddSubsemigroup.center M = ⊤
-- MulHom.noncommCoprod_apply
@[to_additive (attr := simps)
    "Coproduct of two `AddHom`s with the same codomain with `AddCommute` assumption:
    `f.noncommCoprod g _ (p : M × N) = f p.1 + g p.2`.
    (For the commutative case, use `AddHom.coprod`)"]
def noncommCoprod (comm : ∀ m n, Commute (f m) (g n)) : M × N →ₙ* P 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [Mul M] [Mul N] [Semigroup P] (f : M →ₙ* P) (g : N →ₙ* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) (mn : M × N)
Goal: (f.noncommCoprod g comm) mn = f mn.1 * g mn.2
-- AddHom.noncommCoprod_apply
@[to_additive (attr := simps)
    "Coproduct of two `AddHom`s with the same codomain with `AddCommute` assumption:
    `f.noncommCoprod g _ (p : M × N) = f p.1 + g p.2`.
    (For the commutative case, use `AddHom.coprod`)"]
def noncommCoprod (comm : ∀ m n, Commute (f m) (g n)) : M × N →ₙ* P 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [Add M] [Add N] [AddSemigroup P] (f : AddHom M P) (g : AddHom N P) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n)) (mn : M × N)
Goal: (f.noncommCoprod g comm) mn = f mn.1 + g mn.2
-- MulHom.comp_noncommCoprod
@[to_additive]
theorem comp_noncommCoprod {Q : Type*} [Semigroup Q] (h : P →ₙ* Q)
    (comm : ∀ m n, Commute (f m) (g n)) :
    h.comp (f.noncommCoprod g comm) =
      (h.comp f).noncommCoprod (h.comp g) (fun m n ↦ (comm m n).map h) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [Mul M] [Mul N] [Semigroup P] (f : M →ₙ* P) (g : N →ₙ* P) {Q : Type u_4} [Semigroup Q] (h : P →ₙ* Q) (comm : ∀ (m : M) (n : N), Commute (f m) (g n))
Goal: h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯
-- AddHom.comp_noncommCoprod
@[to_additive]
theorem comp_noncommCoprod {Q : Type*} [Semigroup Q] (h : P →ₙ* Q)
    (comm : ∀ m n, Commute (f m) (g n)) :
    h.comp (f.noncommCoprod g comm) =
      (h.comp f).noncommCoprod (h.comp g) (fun m n ↦ (comm m n).map h) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [Add M] [Add N] [AddSemigroup P] (f : AddHom M P) (g : AddHom N P) {Q : Type u_4} [AddSemigroup Q] (h : AddHom P Q) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n))
Goal: h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯
-- MonoidHom.noncommCoprod_apply
@[to_additive (attr := simps)
    "Coproduct of two `AddMonoidHom`s with the same codomain,
    with a commutation assumption:
    `f.noncommCoprod g (p : M × N) = f p.1 + g p.2`.
    (Noncommutative case; in the commutative case, use `AddHom.coprod`.)"]
def noncommCoprod : M × N →* P 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) (mn : M × N)
Goal: (f.noncommCoprod g comm) mn = f mn.1 * g mn.2
-- AddMonoidHom.noncommCoprod_apply
@[to_additive (attr := simps)
    "Coproduct of two `AddMonoidHom`s with the same codomain,
    with a commutation assumption:
    `f.noncommCoprod g (p : M × N) = f p.1 + g p.2`.
    (Noncommutative case; in the commutative case, use `AddHom.coprod`.)"]
def noncommCoprod : M × N →* P 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n)) (mn : M × N)
Goal: (f.noncommCoprod g comm) mn = f mn.1 + g mn.2
-- MonoidHom.noncommCoprod_comp_inl
@[to_additive (attr := simp)]
theorem noncommCoprod_comp_inl : (f.noncommCoprod g comm).comp (inl M N) = f 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n))
Goal: (f.noncommCoprod g comm).comp (MonoidHom.inl M N) = f
-- AddMonoidHom.noncommCoprod_comp_inl
@[to_additive (attr := simp)]
theorem noncommCoprod_comp_inl : (f.noncommCoprod g comm).comp (inl M N) = f 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n))
Goal: (f.noncommCoprod g comm).comp (AddMonoidHom.inl M N) = f
-- AddMonoidHom.noncommCoprod_comp_inr
@[to_additive (attr := simp)]
theorem noncommCoprod_comp_inr : (f.noncommCoprod g comm).comp (inr M N) = g 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n))
Goal: (f.noncommCoprod g comm).comp (AddMonoidHom.inr M N) = g
-- MonoidHom.noncommCoprod_comp_inr
@[to_additive (attr := simp)]
theorem noncommCoprod_comp_inr : (f.noncommCoprod g comm).comp (inr M N) = g 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n))
Goal: (f.noncommCoprod g comm).comp (MonoidHom.inr M N) = g
-- MonoidHom.noncommCoprod_unique
@[to_additive (attr := simp)]
theorem noncommCoprod_unique (f : M × N →* P) :
    (f.comp (inl M N)).noncommCoprod (f.comp (inr M N)) (fun _ _ => (commute_inl_inr _ _).map f)
      = f 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M × N →* P)
Goal: (f.comp (MonoidHom.inl M N)).noncommCoprod (f.comp (MonoidHom.inr M N)) ⋯ = f
-- AddMonoidHom.noncommCoprod_unique
@[to_additive (attr := simp)]
theorem noncommCoprod_unique (f : M × N →* P) :
    (f.comp (inl M N)).noncommCoprod (f.comp (inr M N)) (fun _ _ => (commute_inl_inr _ _).map f)
      = f 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M × N →+ P)
Goal: (f.comp (AddMonoidHom.inl M N)).noncommCoprod (f.comp (AddMonoidHom.inr M N)) ⋯ = f
-- MonoidHom.noncommCoprod_inl_inr
@[to_additive (attr := simp)]
theorem noncommCoprod_inl_inr {M N : Type*} [Monoid M] [Monoid N] :
    (inl M N).noncommCoprod (inr M N) commute_inl_inr = id (M × N) 
Arguments: {M : Type u_4} {N : Type u_5} [Monoid M] [Monoid N]
Goal: (MonoidHom.inl M N).noncommCoprod (MonoidHom.inr M N) ⋯ = MonoidHom.id (M × N)
-- AddMonoidHom.noncommCoprod_inl_inr
@[to_additive (attr := simp)]
theorem noncommCoprod_inl_inr {M N : Type*} [Monoid M] [Monoid N] :
    (inl M N).noncommCoprod (inr M N) commute_inl_inr = id (M × N) 
Arguments: {M : Type u_4} {N : Type u_5} [AddMonoid M] [AddMonoid N]
Goal: (AddMonoidHom.inl M N).noncommCoprod (AddMonoidHom.inr M N) ⋯ = AddMonoidHom.id (M × N)
-- MonoidHom.comp_noncommCoprod
@[to_additive]
theorem comp_noncommCoprod {Q : Type*} [Monoid Q] (h : P →* Q) :
    h.comp (f.noncommCoprod g comm) =
      (h.comp f).noncommCoprod (h.comp g) (fun m n ↦ (comm m n).map h) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [MulOneClass M] [MulOneClass N] [Monoid P] (f : M →* P) (g : N →* P) (comm : ∀ (m : M) (n : N), Commute (f m) (g n)) {Q : Type u_4} [Monoid Q] (h : P →* Q)
Goal: h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯
-- AddMonoidHom.comp_noncommCoprod
@[to_additive]
theorem comp_noncommCoprod {Q : Type*} [Monoid Q] (h : P →* Q) :
    h.comp (f.noncommCoprod g comm) =
      (h.comp f).noncommCoprod (h.comp g) (fun m n ↦ (comm m n).map h) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} [AddZeroClass M] [AddZeroClass N] [AddMonoid P] (f : M →+ P) (g : N →+ P) (comm : ∀ (m : M) (n : N), AddCommute (f m) (g n)) {Q : Type u_4} [AddMonoid Q] (h : P →+ Q)
Goal: h.comp (f.noncommCoprod g comm) = (h.comp f).noncommCoprod (h.comp g) ⋯
-- Subsemigroup.coe_centralizer
@[to_additive (attr := simp, norm_cast)]
theorem coe_centralizer : ↑(centralizer S) = S.centralizer 
Arguments: {M : Type u_1} (S : Set M) [Semigroup M]
Goal: ↑(Subsemigroup.centralizer S) = S.centralizer
-- AddSubsemigroup.coe_centralizer
@[to_additive (attr := simp, norm_cast)]
theorem coe_centralizer : ↑(centralizer S) = S.centralizer 
Arguments: {M : Type u_1} (S : Set M) [AddSemigroup M]
Goal: ↑(AddSubsemigroup.centralizer S) = S.addCentralizer
-- Subsemigroup.mem_centralizer_iff
@[to_additive]
theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g 
Arguments: {M : Type u_1} {S : Set M} [Semigroup M] {z : M}
Goal: z ∈ Subsemigroup.centralizer S ↔ ∀ g ∈ S, g * z = z * g
-- AddSubsemigroup.mem_centralizer_iff
@[to_additive]
theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g 
Arguments: {M : Type u_1} {S : Set M} [AddSemigroup M] {z : M}
Goal: z ∈ AddSubsemigroup.centralizer S ↔ ∀ g ∈ S, g + z = z + g
-- Subsemigroup.center_le_centralizer
@[to_additive]
theorem center_le_centralizer (S) : center M ≤ centralizer S 
Arguments: {M : Type u_1} [Semigroup M] (S : Set M)
Goal: Subsemigroup.center M ≤ Subsemigroup.centralizer S
-- AddSubsemigroup.center_le_centralizer
@[to_additive]
theorem center_le_centralizer (S) : center M ≤ centralizer S 
Arguments: {M : Type u_1} [AddSemigroup M] (S : Set M)
Goal: AddSubsemigroup.center M ≤ AddSubsemigroup.centralizer S
-- Subsemigroup.centralizer_le
@[to_additive]
theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [Semigroup M] (h : S ⊆ T)
Goal: Subsemigroup.centralizer T ≤ Subsemigroup.centralizer S
-- AddSubsemigroup.centralizer_le
@[to_additive]
theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [AddSemigroup M] (h : S ⊆ T)
Goal: AddSubsemigroup.centralizer T ≤ AddSubsemigroup.centralizer S
-- AddSubsemigroup.centralizer_eq_top_iff_subset
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M 
Arguments: {M : Type u_1} [AddSemigroup M] {s : Set M}
Goal: AddSubsemigroup.centralizer s = ⊤ ↔ s ⊆ ↑(AddSubsemigroup.center M)
-- Subsemigroup.centralizer_eq_top_iff_subset
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M 
Arguments: {M : Type u_1} [Semigroup M] {s : Set M}
Goal: Subsemigroup.centralizer s = ⊤ ↔ s ⊆ ↑(Subsemigroup.center M)
-- Subsemigroup.centralizer_univ
@[to_additive (attr := simp)]
theorem centralizer_univ : centralizer Set.univ = center M 
Arguments: (M : Type u_1) [Semigroup M]
Goal: Subsemigroup.centralizer Set.univ = Subsemigroup.center M
-- AddSubsemigroup.centralizer_univ
@[to_additive (attr := simp)]
theorem centralizer_univ : centralizer Set.univ = center M 
Arguments: (M : Type u_1) [AddSemigroup M]
Goal: AddSubsemigroup.centralizer Set.univ = AddSubsemigroup.center M
-- Submonoid.coe_centralizer
@[to_additive (attr := simp, norm_cast)]
theorem coe_centralizer : ↑(centralizer S) = S.centralizer 
Arguments: {M : Type u_1} (S : Set M) [Monoid M]
Goal: ↑(Submonoid.centralizer S) = S.centralizer
-- AddSubmonoid.coe_centralizer
@[to_additive (attr := simp, norm_cast)]
theorem coe_centralizer : ↑(centralizer S) = S.centralizer 
Arguments: {M : Type u_1} (S : Set M) [AddMonoid M]
Goal: ↑(AddSubmonoid.centralizer S) = S.addCentralizer
-- Submonoid.centralizer_toSubsemigroup
theorem centralizer_toSubsemigroup : (centralizer S).toSubsemigroup = Subsemigroup.centralizer S 
Arguments: {M : Type u_1} (S : Set M) [Monoid M]
Goal: (Submonoid.centralizer S).toSubsemigroup = Subsemigroup.centralizer S
-- AddSubmonoid.centralizer_toAddSubsemigroup
theorem _root_.AddSubmonoid.centralizer_toAddSubsemigroup {M} [AddMonoid M] (S : Set M) :
    (AddSubmonoid.centralizer S).toAddSubsemigroup = AddSubsemigroup.centralizer S 
Arguments: {M : Type u_2} [AddMonoid M] (S : Set M)
Goal: (AddSubmonoid.centralizer S).toAddSubsemigroup = AddSubsemigroup.centralizer S
-- Submonoid.mem_centralizer_iff
@[to_additive]
theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g 
Arguments: {M : Type u_1} {S : Set M} [Monoid M] {z : M}
Goal: z ∈ Submonoid.centralizer S ↔ ∀ g ∈ S, g * z = z * g
-- AddSubmonoid.mem_centralizer_iff
@[to_additive]
theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g 
Arguments: {M : Type u_1} {S : Set M} [AddMonoid M] {z : M}
Goal: z ∈ AddSubmonoid.centralizer S ↔ ∀ g ∈ S, g + z = z + g
-- Submonoid.center_le_centralizer
@[to_additive]
theorem center_le_centralizer (s) : center M ≤ centralizer s 
Arguments: {M : Type u_1} [Monoid M] (s : Set M)
Goal: Submonoid.center M ≤ Submonoid.centralizer s
-- AddSubmonoid.center_le_centralizer
@[to_additive]
theorem center_le_centralizer (s) : center M ≤ centralizer s 
Arguments: {M : Type u_1} [AddMonoid M] (s : Set M)
Goal: AddSubmonoid.center M ≤ AddSubmonoid.centralizer s
-- AddSubmonoid.centralizer_le
@[to_additive]
theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [AddMonoid M] (h : S ⊆ T)
Goal: AddSubmonoid.centralizer T ≤ AddSubmonoid.centralizer S
-- Submonoid.centralizer_le
@[to_additive]
theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [Monoid M] (h : S ⊆ T)
Goal: Submonoid.centralizer T ≤ Submonoid.centralizer S
-- AddSubmonoid.centralizer_eq_top_iff_subset
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M 
Arguments: {M : Type u_1} [AddMonoid M] {s : Set M}
Goal: AddSubmonoid.centralizer s = ⊤ ↔ s ⊆ ↑(AddSubmonoid.center M)
-- Submonoid.centralizer_eq_top_iff_subset
@[to_additive (attr := simp)]
theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M 
Arguments: {M : Type u_1} [Monoid M] {s : Set M}
Goal: Submonoid.centralizer s = ⊤ ↔ s ⊆ ↑(Submonoid.center M)
-- Submonoid.centralizer_univ
@[to_additive (attr := simp)]
theorem centralizer_univ : centralizer Set.univ = center M 
Arguments: (M : Type u_1) [Monoid M]
Goal: Submonoid.centralizer Set.univ = Submonoid.center M
-- AddSubmonoid.centralizer_univ
@[to_additive (attr := simp)]
theorem centralizer_univ : centralizer Set.univ = center M 
Arguments: (M : Type u_1) [AddMonoid M]
Goal: AddSubmonoid.centralizer Set.univ = AddSubmonoid.center M
-- AddSubmonoid.le_centralizer_centralizer
@[to_additive]
lemma le_centralizer_centralizer {s : Submonoid M} : s ≤ centralizer (centralizer (s : Set M)) 
Arguments: (M : Type u_1) [AddMonoid M] {s : AddSubmonoid M}
Goal: s ≤ AddSubmonoid.centralizer ↑(AddSubmonoid.centralizer ↑s)
-- Submonoid.le_centralizer_centralizer
@[to_additive]
lemma le_centralizer_centralizer {s : Submonoid M} : s ≤ centralizer (centralizer (s : Set M)) 
Arguments: (M : Type u_1) [Monoid M] {s : Submonoid M}
Goal: s ≤ Submonoid.centralizer ↑(Submonoid.centralizer ↑s)