ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- exists_one_lt'
@[to_additive exists_zero_lt]
theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a 
Arguments: {α : Type u} [LinearOrderedCommGroup α] [Nontrivial α]
Goal: ∃ a, 1 < a
-- exists_zero_lt
@[to_additive exists_zero_lt]
theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a 
Arguments: {α : Type u} [LinearOrderedAddCommGroup α] [Nontrivial α]
Goal: ∃ a, 0 < a
-- inv_le_self_iff
@[to_additive (attr := simp)]
theorem inv_le_self_iff : a⁻¹ ≤ a ↔ 1 ≤ a 
Arguments: {α : Type u} [LinearOrderedCommGroup α] {a : α}
Goal: a⁻¹ ≤ a ↔ 1 ≤ a
-- neg_le_self_iff
@[to_additive (attr := simp)]
theorem inv_le_self_iff : a⁻¹ ≤ a ↔ 1 ≤ a 
Arguments: {α : Type u} [LinearOrderedAddCommGroup α] {a : α}
Goal: -a ≤ a ↔ 0 ≤ a
-- inv_lt_self_iff
@[to_additive (attr := simp)]
theorem inv_lt_self_iff : a⁻¹ < a ↔ 1 < a 
Arguments: {α : Type u} [LinearOrderedCommGroup α] {a : α}
Goal: a⁻¹ < a ↔ 1 < a
-- neg_lt_self_iff
@[to_additive (attr := simp)]
theorem inv_lt_self_iff : a⁻¹ < a ↔ 1 < a 
Arguments: {α : Type u} [LinearOrderedAddCommGroup α] {a : α}
Goal: -a < a ↔ 0 < a
-- le_neg_self_iff
@[to_additive (attr := simp)]
theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1 
Arguments: {α : Type u} [LinearOrderedAddCommGroup α] {a : α}
Goal: a ≤ -a ↔ a ≤ 0
-- le_inv_self_iff
@[to_additive (attr := simp)]
theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1 
Arguments: {α : Type u} [LinearOrderedCommGroup α] {a : α}
Goal: a ≤ a⁻¹ ↔ a ≤ 1
-- lt_inv_self_iff
@[to_additive (attr := simp)]
theorem lt_inv_self_iff : a < a⁻¹ ↔ a < 1 
Arguments: {α : Type u} [LinearOrderedCommGroup α] {a : α}
Goal: a < a⁻¹ ↔ a < 1
-- lt_neg_self_iff
@[to_additive (attr := simp)]
theorem lt_inv_self_iff : a < a⁻¹ ↔ a < 1 
Arguments: {α : Type u} [LinearOrderedAddCommGroup α] {a : α}
Goal: a < -a ↔ a < 0
-- inv_le_inv'
@[to_additive (attr := gcongr) neg_le_neg]
theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ 
Arguments: {α : Type u} [OrderedCommGroup α] {a b : α}
Goal: a ≤ b → b⁻¹ ≤ a⁻¹
-- neg_le_neg
@[to_additive (attr := gcongr) neg_le_neg]
theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ 
Arguments: {α : Type u} [OrderedAddCommGroup α] {a b : α}
Goal: a ≤ b → -b ≤ -a
-- neg_lt_neg
@[to_additive (attr := gcongr) neg_lt_neg]
theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ 
Arguments: {α : Type u} [OrderedAddCommGroup α] {a b : α}
Goal: a < b → -b < -a
-- inv_lt_inv'
@[to_additive (attr := gcongr) neg_lt_neg]
theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ 
Arguments: {α : Type u} [OrderedCommGroup α] {a b : α}
Goal: a < b → b⁻¹ < a⁻¹
-- inv_lt_one_of_one_lt
@[to_additive]
theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 
Arguments: {α : Type u} [OrderedCommGroup α] {a : α}
Goal: 1 < a → a⁻¹ < 1
-- neg_neg_of_pos
@[to_additive]
theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 
Arguments: {α : Type u} [OrderedAddCommGroup α] {a : α}
Goal: 0 < a → -a < 0
-- neg_nonpos_of_nonneg
@[to_additive]
theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 
Arguments: {α : Type u} [OrderedAddCommGroup α] {a : α}
Goal: 0 ≤ a → -a ≤ 0
-- inv_le_one_of_one_le
@[to_additive]
theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 
Arguments: {α : Type u} [OrderedCommGroup α] {a : α}
Goal: 1 ≤ a → a⁻¹ ≤ 1
-- one_le_inv_of_le_one
@[to_additive neg_nonneg_of_nonpos]
theorem one_le_inv_of_le_one : a ≤ 1 → 1 ≤ a⁻¹ 
Arguments: {α : Type u} [OrderedCommGroup α] {a : α}
Goal: a ≤ 1 → 1 ≤ a⁻¹
-- neg_nonneg_of_nonpos
@[to_additive neg_nonneg_of_nonpos]
theorem one_le_inv_of_le_one : a ≤ 1 → 1 ≤ a⁻¹ 
Arguments: {α : Type u} [OrderedAddCommGroup α] {a : α}
Goal: a ≤ 0 → 0 ≤ -a
-- Nat.pow_left_strictMono
protected lemma pow_left_strictMono (hn : n ≠ 0) : StrictMono (· ^ n : ℕ → ℕ) 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: StrictMono fun x => x ^ n
-- StrictMono.nat_pow
lemma _root_.StrictMono.nat_pow [Preorder α] (hn : n ≠ 0) (hf : StrictMono f) :
    StrictMono (f · ^ n) 
Arguments: {α : Type u_1} {n : ℕ} {f : α → ℕ} [Preorder α] (hn : n ≠ 0) (hf : StrictMono f)
Goal: StrictMono fun x => f x ^ n
-- IsGLB.exists_between_self_add
theorem IsGLB.exists_between_self_add (h : IsGLB s a) (hε : 0 < ε) : ∃ b ∈ s, a ≤ b ∧ b < a + ε 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {s : Set α} {a ε : α} (h : IsGLB s a) (hε : 0 < ε)
Goal: ∃ b ∈ s, a ≤ b ∧ b < a + ε
-- IsGLB.exists_between_self_add'
theorem IsGLB.exists_between_self_add' (h : IsGLB s a) (h₂ : a ∉ s) (hε : 0 < ε) :
    ∃ b ∈ s, a < b ∧ b < a + ε 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {s : Set α} {a ε : α} (h : IsGLB s a) (h₂ : a ∉ s) (hε : 0 < ε)
Goal: ∃ b ∈ s, a < b ∧ b < a + ε
-- IsLUB.exists_between_sub_self
theorem IsLUB.exists_between_sub_self (h : IsLUB s a) (hε : 0 < ε) : ∃ b ∈ s, a - ε < b ∧ b ≤ a 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {s : Set α} {a ε : α} (h : IsLUB s a) (hε : 0 < ε)
Goal: ∃ b ∈ s, a - ε < b ∧ b ≤ a
-- IsLUB.exists_between_sub_self'
theorem IsLUB.exists_between_sub_self' (h : IsLUB s a) (h₂ : a ∉ s) (hε : 0 < ε) :
    ∃ b ∈ s, a - ε < b ∧ b < a 
Arguments: {α : Type u_1} [LinearOrderedAddCommGroup α] {s : Set α} {a ε : α} (h : IsLUB s a) (h₂ : a ∉ s) (hε : 0 < ε)
Goal: ∃ b ∈ s, a - ε < b ∧ b < a
-- Finset.mem_finAntidiagonal
@[simp] lemma mem_finAntidiagonal {d : ℕ} {f : Fin d → μ} :
    f ∈ finAntidiagonal d n ↔ ∑ i, f i = n 
Arguments: {μ : Type u_2} [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {n : μ} {d : ℕ} {f : Fin d → μ}
Goal: f ∈ Finset.finAntidiagonal d n ↔ ∑ i : Fin d, f i = n
-- Finset.mem_piAntidiag
@[simp] lemma mem_piAntidiag : f ∈ piAntidiag s n ↔ s.sum f = n ∧ ∀ i, f i ≠ 0 → i ∈ s 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {s : Finset ι} {n : μ} {f : ι → μ}
Goal: f ∈ s.piAntidiag n ↔ s.sum f = n ∧ ∀ (i : ι), f i ≠ 0 → i ∈ s
-- Finset.piAntidiag_empty_zero
@[simp] lemma piAntidiag_empty_zero : piAntidiag (∅ : Finset ι) (0 : μ) = {0} 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ]
Goal: ∅.piAntidiag 0 = {0}
-- Finset.piAntidiag_empty_of_ne_zero
@[simp] lemma piAntidiag_empty_of_ne_zero (hn : n ≠ 0) : piAntidiag (∅ : Finset ι) n = ∅ 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {n : μ} (hn : n ≠ 0)
Goal: ∅.piAntidiag n = ∅
-- Finset.piAntidiag_empty
lemma piAntidiag_empty (n : μ) : piAntidiag (∅ : Finset ι) n = if n = 0 then {0} else ∅ 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] (n : μ)
Goal: ∅.piAntidiag n = if n = 0 then {0} else ∅
-- Finset.finsetCongr_piAntidiag_eq_antidiag
lemma finsetCongr_piAntidiag_eq_antidiag (n : μ) :
    Equiv.finsetCongr (Equiv.boolArrowEquivProd _) (piAntidiag univ n) = antidiagonal n 
Arguments: {μ : Type u_2} [AddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] (n : μ)
Goal: (Equiv.boolArrowEquivProd μ).finsetCongr (Finset.univ.piAntidiag n) = Finset.antidiagonal n
-- Finset.pairwiseDisjoint_piAntidiag_map_addRightEmbedding
lemma pairwiseDisjoint_piAntidiag_map_addRightEmbedding (hi : i ∉ s) (n : μ) :
    (antidiagonal n : Set (μ × μ)).PairwiseDisjoint fun p ↦
      map (addRightEmbedding fun j ↦ if j = i then p.1 else 0) (s.piAntidiag p.2) 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCancelCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {i : ι} {s : Finset ι} (hi : i ∉ s) (n : μ)
Goal: (↑(Finset.antidiagonal n)).PairwiseDisjoint fun p =>
  Finset.map (addRightEmbedding fun j => if j = i then p.1 else 0) (s.piAntidiag p.2)
-- Finset.piAntidiag_cons
lemma piAntidiag_cons (hi : i ∉ s)  (n : μ) :
    piAntidiag (cons i s hi) n = (antidiagonal n).disjiUnion (fun p : μ × μ ↦
      (piAntidiag s p.snd).map (addRightEmbedding fun t ↦ if t = i then p.fst else 0))
        (pairwiseDisjoint_piAntidiag_map_addRightEmbedding hi _) 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCancelCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {i : ι} {s : Finset ι} (hi : i ∉ s) (n : μ)
Goal: (Finset.cons i s hi).piAntidiag n =
  (Finset.antidiagonal n).disjiUnion
    (fun p => Finset.map (addRightEmbedding fun t => if t = i then p.1 else 0) (s.piAntidiag p.2)) ⋯
-- Finset.piAntidiag_insert
lemma piAntidiag_insert [DecidableEq (ι → μ)] (hi : i ∉ s) (n : μ) :
    piAntidiag (insert i s) n = (antidiagonal n).biUnion fun p : μ × μ ↦ (piAntidiag s p.snd).image
      (fun f j ↦ f j + if j = i then p.fst else 0) 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [AddCancelCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] {i : ι} {s : Finset ι} [DecidableEq (ι → μ)] (hi : i ∉ s) (n : μ)
Goal: (insert i s).piAntidiag n =
  (Finset.antidiagonal n).biUnion fun p => Finset.image (fun f j => f j + if j = i then p.1 else 0) (s.piAntidiag p.2)
-- Finset.piAntidiag_zero
@[simp] lemma piAntidiag_zero (s : Finset ι) : piAntidiag s (0 : μ) = {0} 
Arguments: {ι : Type u_1} {μ : Type u_2} [DecidableEq ι] [CanonicallyOrderedAddCommMonoid μ] [Finset.HasAntidiagonal μ] [DecidableEq μ] (s : Finset ι)
Goal: s.piAntidiag 0 = {0}
-- Finset.piAntidiag_univ_fin_eq_antidiagonalTuple
lemma piAntidiag_univ_fin_eq_antidiagonalTuple (n k : ℕ) :
    piAntidiag univ n = Nat.antidiagonalTuple k n 
Arguments: (n k : ℕ)
Goal: Finset.univ.piAntidiag n = Finset.Nat.antidiagonalTuple k n
-- Finset.nsmul_piAntidiag
lemma nsmul_piAntidiag [DecidableEq (ι → ℕ)] (s : Finset ι) (m : ℕ) {n : ℕ} (hn : n ≠ 0) :
    n •ℕ piAntidiag s m = (piAntidiag s (n * m)).filter fun f : ι → ℕ ↦ ∀ i ∈ s, n ∣ f i 
Arguments: {ι : Type u_1} [DecidableEq ι] [DecidableEq (ι → ℕ)] (s : Finset ι) (m : ℕ) {n : ℕ} (hn : n ≠ 0)
Goal: SMul.smul n (s.piAntidiag m) = Finset.filter (fun f => ∀ i ∈ s, n ∣ f i) (s.piAntidiag (n * m))
-- Finset.map_nsmul_piAntidiag
lemma map_nsmul_piAntidiag (s : Finset ι) (m : ℕ) {n : ℕ} (hn : n ≠ 0) :
    (piAntidiag s m).map
      ⟨(n • ·), fun f g h ↦ funext fun i ↦ mul_right_injective₀ hn (congr_fun h i)⟩ =
        (piAntidiag s (n * m)).filter fun f : ι → ℕ ↦ ∀ i ∈ s, n ∣ f i 
Arguments: {ι : Type u_1} [DecidableEq ι] (s : Finset ι) (m : ℕ) {n : ℕ} (hn : n ≠ 0)
Goal: Finset.map { toFun := fun x => n • x, inj' := ⋯ } (s.piAntidiag m) =
  Finset.filter (fun f => ∀ i ∈ s, n ∣ f i) (s.piAntidiag (n * m))
-- Finset.nsmul_piAntidiag_univ
lemma nsmul_piAntidiag_univ [Fintype ι] (m : ℕ) {n : ℕ} (hn : n ≠ 0) :
    @SMul.smul _ _ Finset.smulFinset n (piAntidiag univ m) =
      (piAntidiag univ (n * m)).filter fun f : ι → ℕ ↦ ∀ i, n ∣ f i 
Arguments: {ι : Type u_1} [DecidableEq ι] [Fintype ι] (m : ℕ) {n : ℕ} (hn : n ≠ 0)
Goal: SMul.smul n (Finset.univ.piAntidiag m) = Finset.filter (fun f => ∀ (i : ι), n ∣ f i) (Finset.univ.piAntidiag (n * m))
-- Finset.map_nsmul_piAntidiag_univ
lemma map_nsmul_piAntidiag_univ [Fintype ι] (m : ℕ) {n : ℕ} (hn : n ≠ 0) :
    (piAntidiag (univ : Finset ι) m).map
        ⟨(n • ·), fun f g h ↦ funext fun i ↦ mul_right_injective₀ hn (congr_fun h i)⟩ =
      (piAntidiag univ (n * m)).filter fun f : ι → ℕ ↦ ∀ i, n ∣ f i 
Arguments: {ι : Type u_1} [DecidableEq ι] [Fintype ι] (m : ℕ) {n : ℕ} (hn : n ≠ 0)
Goal: Finset.map { toFun := fun x => n • x, inj' := ⋯ } (Finset.univ.piAntidiag m) =
  Finset.filter (fun f => ∀ (i : ι), n ∣ f i) (Finset.univ.piAntidiag (n * m))
-- Finset.map_sym_eq_piAntidiag
lemma map_sym_eq_piAntidiag [DecidableEq ι] (s : Finset ι) (n : ℕ) :
    (s.sym n).map ⟨fun m a ↦ m.1.count a, Multiset.count_injective.comp Sym.coe_injective⟩ =
      piAntidiag s n 
Arguments: {ι : Type u_1} [DecidableEq ι] (s : Finset ι) (n : ℕ)
Goal: Finset.map { toFun := fun m a => Multiset.count a ↑m, inj' := ⋯ } (s.sym n) = s.piAntidiag n
-- OrderIso.neg_symm_apply
@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
def OrderIso.inv : α ≃o αᵒᵈ 
Arguments: (α : Type u) [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
Goal: ∀ (a : αᵒᵈ), (RelIso.symm (OrderIso.neg α)) a = -OrderDual.ofDual a
-- OrderIso.inv_symm_apply
@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
def OrderIso.inv : α ≃o αᵒᵈ 
Arguments: (α : Type u) [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
Goal: ∀ (a : αᵒᵈ), (RelIso.symm (OrderIso.inv α)) a = (OrderDual.ofDual a)⁻¹
-- OrderIso.neg_apply
@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
def OrderIso.inv : α ≃o αᵒᵈ 
Arguments: (α : Type u) [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1]
Goal: ∀ (a : α), (OrderIso.neg α) a = OrderDual.toDual (-a)
-- OrderIso.inv_apply
@[to_additive (attr := simps!) "`x ↦ -x` as an order-reversing equivalence."]
def OrderIso.inv : α ≃o αᵒᵈ 
Arguments: (α : Type u) [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1]
Goal: ∀ (a : α), (OrderIso.inv α) a = OrderDual.toDual a⁻¹
-- inv_le'
@[to_additive neg_le]
theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α}
Goal: a⁻¹ ≤ b ↔ b⁻¹ ≤ a
-- neg_le
@[to_additive neg_le]
theorem inv_le' : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}
Goal: -a ≤ b ↔ -b ≤ a
-- le_neg
@[to_additive le_neg]
theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] {a b : α}
Goal: a ≤ -b ↔ b ≤ -a
-- le_inv'
@[to_additive le_neg]
theorem le_inv' : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] {a b : α}
Goal: a ≤ b⁻¹ ↔ b ≤ a⁻¹
-- OrderIso.divLeft_symm_apply
@[to_additive (attr := simps!) "`x ↦ a - x` as an order-reversing equivalence."]
def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: ∀ (a_1 : αᵒᵈ), (RelIso.symm (OrderIso.divLeft a)) a_1 = (OrderDual.ofDual a_1)⁻¹ * a
-- OrderIso.subLeft_symm_apply
@[to_additive (attr := simps!) "`x ↦ a - x` as an order-reversing equivalence."]
def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: ∀ (a_1 : αᵒᵈ), (RelIso.symm (OrderIso.subLeft a)) a_1 = -OrderDual.ofDual a_1 + a
-- OrderIso.subLeft_apply
@[to_additive (attr := simps!) "`x ↦ a - x` as an order-reversing equivalence."]
def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: ∀ (a_1 : α), (OrderIso.subLeft a) a_1 = OrderDual.toDual (a - a_1)
-- OrderIso.divLeft_apply
@[to_additive (attr := simps!) "`x ↦ a - x` as an order-reversing equivalence."]
def OrderIso.divLeft (a : α) : α ≃o αᵒᵈ 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: ∀ (a_1 : α), (OrderIso.divLeft a) a_1 = OrderDual.toDual (a / a_1)
-- OrderIso.mulRight_toEquiv
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
def OrderIso.mulRight (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.mulRight a).toEquiv = Equiv.mulRight a
-- OrderIso.addRight_apply
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
def OrderIso.mulRight (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a x : α)
Goal: (OrderIso.addRight a) x = x + a
-- OrderIso.mulRight_apply
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
def OrderIso.mulRight (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a x : α)
Goal: (OrderIso.mulRight a) x = x * a
-- OrderIso.addRight_toEquiv
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addRight` as an `OrderIso`. See also `OrderEmbedding.addRight`."]
def OrderIso.mulRight (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.addRight a).toEquiv = Equiv.addRight a
-- OrderIso.mulRight_symm
@[to_additive (attr := simp)]
theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹
-- OrderIso.addRight_symm
@[to_additive (attr := simp)]
theorem OrderIso.mulRight_symm (a : α) : (OrderIso.mulRight a).symm = OrderIso.mulRight a⁻¹ 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.addRight a).symm = OrderIso.addRight (-a)
-- OrderIso.subRight_symm_apply
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α)
Goal: (RelIso.symm (OrderIso.subRight a)) b = b + a
-- OrderIso.divRight_apply
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a b : α)
Goal: (OrderIso.divRight a) b = b / a
-- OrderIso.subRight_apply
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a b : α)
Goal: (OrderIso.subRight a) b = b - a
-- OrderIso.divRight_symm_apply
@[to_additive (attr := simps!) "`x ↦ x - a` as an order isomorphism."]
def OrderIso.divRight (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (Function.swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a b : α)
Goal: (RelIso.symm (OrderIso.divRight a)) b = b * a
-- OrderIso.addLeft_toEquiv
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
def OrderIso.mulLeft (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.addLeft a).toEquiv = Equiv.addLeft a
-- OrderIso.mulLeft_toEquiv
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
def OrderIso.mulLeft (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.mulLeft a).toEquiv = Equiv.mulLeft a
-- OrderIso.addLeft_apply
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
def OrderIso.mulLeft (a : α) : α ≃o α 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a x : α)
Goal: (OrderIso.addLeft a) x = a + x
-- OrderIso.mulLeft_apply
@[to_additive (attr := simps! (config := { simpRhs := true }) toEquiv apply)
  "`Equiv.addLeft` as an `OrderIso`. See also `OrderEmbedding.addLeft`."]
def OrderIso.mulLeft (a : α) : α ≃o α 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a x : α)
Goal: (OrderIso.mulLeft a) x = a * x
-- OrderIso.addLeft_symm
@[to_additive (attr := simp)]
theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ 
Arguments: {α : Type u} [AddGroup α] [LE α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.addLeft a).symm = OrderIso.addLeft (-a)
-- OrderIso.mulLeft_symm
@[to_additive (attr := simp)]
theorem OrderIso.mulLeft_symm (a : α) : (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹ 
Arguments: {α : Type u} [Group α] [LE α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] (a : α)
Goal: (OrderIso.mulLeft a).symm = OrderIso.mulLeft a⁻¹
-- toDual_one
@[to_additive (attr := simp)]
theorem toDual_one [One α] : toDual (1 : α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: OrderDual.toDual 1 = 1
-- toDual_zero
@[to_additive (attr := simp)]
theorem toDual_one [One α] : toDual (1 : α) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: OrderDual.toDual 0 = 0
-- ofDual_zero
@[to_additive (attr := simp)]
theorem ofDual_one [One α] : (ofDual 1 : α) = 1 
Arguments: {α : Type u_1} [Zero α]
Goal: OrderDual.ofDual 0 = 0
-- ofDual_one
@[to_additive (attr := simp)]
theorem ofDual_one [One α] : (ofDual 1 : α) = 1 
Arguments: {α : Type u_1} [One α]
Goal: OrderDual.ofDual 1 = 1
-- toDual_mul
@[to_additive (attr := simp)]
theorem toDual_mul [Mul α] (a b : α) : toDual (a * b) = toDual a * toDual b 
Arguments: {α : Type u_1} [Mul α] (a b : α)
Goal: OrderDual.toDual (a * b) = OrderDual.toDual a * OrderDual.toDual b
-- toDual_add
@[to_additive (attr := simp)]
theorem toDual_mul [Mul α] (a b : α) : toDual (a * b) = toDual a * toDual b 
Arguments: {α : Type u_1} [Add α] (a b : α)
Goal: OrderDual.toDual (a + b) = OrderDual.toDual a + OrderDual.toDual b
-- ofDual_mul
@[to_additive (attr := simp)]
theorem ofDual_mul [Mul α] (a b : αᵒᵈ) : ofDual (a * b) = ofDual a * ofDual b 
Arguments: {α : Type u_1} [Mul α] (a b : αᵒᵈ)
Goal: OrderDual.ofDual (a * b) = OrderDual.ofDual a * OrderDual.ofDual b
-- ofDual_add
@[to_additive (attr := simp)]
theorem ofDual_mul [Mul α] (a b : αᵒᵈ) : ofDual (a * b) = ofDual a * ofDual b 
Arguments: {α : Type u_1} [Add α] (a b : αᵒᵈ)
Goal: OrderDual.ofDual (a + b) = OrderDual.ofDual a + OrderDual.ofDual b
-- toDual_inv
@[to_additive (attr := simp)]
theorem toDual_inv [Inv α] (a : α) : toDual a⁻¹ = (toDual a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : α)
Goal: OrderDual.toDual a⁻¹ = (OrderDual.toDual a)⁻¹
-- toDual_neg
@[to_additive (attr := simp)]
theorem toDual_inv [Inv α] (a : α) : toDual a⁻¹ = (toDual a)⁻¹ 
Arguments: {α : Type u_1} [Neg α] (a : α)
Goal: OrderDual.toDual (-a) = -OrderDual.toDual a
-- ofDual_neg
@[to_additive (attr := simp)]
theorem ofDual_inv [Inv α] (a : αᵒᵈ) : ofDual a⁻¹ = (ofDual a)⁻¹ 
Arguments: {α : Type u_1} [Neg α] (a : αᵒᵈ)
Goal: OrderDual.ofDual (-a) = -OrderDual.ofDual a
-- ofDual_inv
@[to_additive (attr := simp)]
theorem ofDual_inv [Inv α] (a : αᵒᵈ) : ofDual a⁻¹ = (ofDual a)⁻¹ 
Arguments: {α : Type u_1} [Inv α] (a : αᵒᵈ)
Goal: OrderDual.ofDual a⁻¹ = (OrderDual.ofDual a)⁻¹
-- toDual_sub
@[to_additive (attr := simp)]
theorem toDual_div [Div α] (a b : α) : toDual (a / b) = toDual a / toDual b 
Arguments: {α : Type u_1} [Sub α] (a b : α)
Goal: OrderDual.toDual (a - b) = OrderDual.toDual a - OrderDual.toDual b