ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.biUnion_lt_succ
theorem biUnion_lt_succ (u : ℕ → Set α) (n : ℕ) : ⋃ k < n + 1, u k = (⋃ k < n, u k) ∪ u n 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋃ k, ⋃ (_ : k < n + 1), u k = (⋃ k, ⋃ (_ : k < n), u k) ∪ u n
-- Set.biUnion_lt_succ'
theorem biUnion_lt_succ' (u : ℕ → Set α) (n : ℕ) : ⋃ k < n + 1, u k = u 0 ∪ ⋃ k < n, u (k + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋃ k, ⋃ (_ : k < n + 1), u k = u 0 ∪ ⋃ k, ⋃ (_ : k < n), u (k + 1)
-- Set.biInter_lt_succ
theorem biInter_lt_succ (u : ℕ → Set α) (n : ℕ) : ⋂ k < n + 1, u k = (⋂ k < n, u k) ∩ u n 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋂ k, ⋂ (_ : k < n + 1), u k = (⋂ k, ⋂ (_ : k < n), u k) ∩ u n
-- Set.biInter_lt_succ'
theorem biInter_lt_succ' (u : ℕ → Set α) (n : ℕ) : ⋂ k < n + 1, u k = u 0 ∩ ⋂ k < n, u (k + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋂ k, ⋂ (_ : k < n + 1), u k = u 0 ∩ ⋂ k, ⋂ (_ : k < n), u (k + 1)
-- Set.biUnion_le_succ
theorem biUnion_le_succ (u : ℕ → Set α) (n : ℕ) : ⋃ k ≤ n + 1, u k = (⋃ k ≤ n, u k) ∪ u (n + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋃ k, ⋃ (_ : k ≤ n + 1), u k = (⋃ k, ⋃ (_ : k ≤ n), u k) ∪ u (n + 1)
-- Set.biUnion_le_succ'
theorem biUnion_le_succ' (u : ℕ → Set α) (n : ℕ) : ⋃ k ≤ n + 1, u k = u 0 ∪ ⋃ k ≤ n, u (k + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋃ k, ⋃ (_ : k ≤ n + 1), u k = u 0 ∪ ⋃ k, ⋃ (_ : k ≤ n), u (k + 1)
-- Set.biInter_le_succ
theorem biInter_le_succ (u : ℕ → Set α) (n : ℕ) : ⋂ k ≤ n + 1, u k = (⋂ k ≤ n, u k) ∩ u (n + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋂ k, ⋂ (_ : k ≤ n + 1), u k = (⋂ k, ⋂ (_ : k ≤ n), u k) ∩ u (n + 1)
-- Set.biInter_le_succ'
theorem biInter_le_succ' (u : ℕ → Set α) (n : ℕ) : ⋂ k ≤ n + 1, u k = u 0 ∩ ⋂ k ≤ n, u (k + 1) 
Arguments: {α : Type u_1} (u : ℕ → Set α) (n : ℕ)
Goal: ⋂ k, ⋂ (_ : k ≤ n + 1), u k = u 0 ∩ ⋂ k, ⋂ (_ : k ≤ n), u (k + 1)
-- Nat.centralBinom_eq_two_mul_choose
theorem centralBinom_eq_two_mul_choose (n : ℕ) : centralBinom n = (2 * n).choose n 
Arguments: (n : ℕ)
Goal: n.centralBinom = (2 * n).choose n
-- Nat.centralBinom_pos
theorem centralBinom_pos (n : ℕ) : 0 < centralBinom n 
Arguments: (n : ℕ)
Goal: 0 < n.centralBinom
-- Nat.centralBinom_ne_zero
theorem centralBinom_ne_zero (n : ℕ) : centralBinom n ≠ 0 
Arguments: (n : ℕ)
Goal: n.centralBinom ≠ 0
-- Nat.centralBinom_zero
@[simp]
theorem centralBinom_zero : centralBinom 0 = 1 
Goal: Nat.centralBinom 0 = 1
-- Nat.choose_le_centralBinom
theorem choose_le_centralBinom (r n : ℕ) : choose (2 * n) r ≤ centralBinom n 
Arguments: (r n : ℕ)
Goal: (2 * n).choose r ≤ n.centralBinom
-- Nat.two_le_centralBinom
theorem two_le_centralBinom (n : ℕ) (n_pos : 0 < n) : 2 ≤ centralBinom n 
Arguments: (n : ℕ) (n_pos : 0 < n)
Goal: 2 ≤ n.centralBinom
-- Nat.succ_mul_centralBinom_succ
theorem succ_mul_centralBinom_succ (n : ℕ) :
    (n + 1) * centralBinom (n + 1) = 2 * (2 * n + 1) * centralBinom n 
Arguments: (n : ℕ)
Goal: (n + 1) * (n + 1).centralBinom = 2 * (2 * n + 1) * n.centralBinom
-- Nat.four_pow_lt_mul_centralBinom
theorem four_pow_lt_mul_centralBinom (n : ℕ) (n_big : 4 ≤ n) : 4 ^ n < n * centralBinom n 
Arguments: (n : ℕ) (n_big : 4 ≤ n)
Goal: 4 ^ n < n * n.centralBinom
-- Nat.four_pow_le_two_mul_self_mul_centralBinom
theorem four_pow_le_two_mul_self_mul_centralBinom :
    ∀ (n : ℕ) (_ : 0 < n), 4 ^ n ≤ 2 * n * centralBinom n
  
Arguments: (n : ℕ)
Goal: 0 < n → 4 ^ n ≤ 2 * n * n.centralBinom
-- Nat.two_dvd_centralBinom_succ
theorem two_dvd_centralBinom_succ (n : ℕ) : 2 ∣ centralBinom (n + 1) 
Arguments: (n : ℕ)
Goal: 2 ∣ (n + 1).centralBinom
-- Nat.two_dvd_centralBinom_of_one_le
theorem two_dvd_centralBinom_of_one_le {n : ℕ} (h : 0 < n) : 2 ∣ centralBinom n 
Arguments: {n : ℕ} (h : 0 < n)
Goal: 2 ∣ n.centralBinom
-- Nat.succ_dvd_centralBinom
theorem succ_dvd_centralBinom (n : ℕ) : n + 1 ∣ n.centralBinom 
Arguments: (n : ℕ)
Goal: n + 1 ∣ n.centralBinom
-- Nat.primeFactorsList_zero
@[simp]
theorem primeFactorsList_zero : primeFactorsList 0 = [] 
Goal: Nat.primeFactorsList 0 = []
-- Nat.primeFactorsList_one
@[simp]
theorem primeFactorsList_one : primeFactorsList 1 = [] 
Goal: Nat.primeFactorsList 1 = []
-- Nat.primeFactorsList_two
@[simp]
theorem primeFactorsList_two : primeFactorsList 2 = [2] 
Goal: Nat.primeFactorsList 2 = [2]
-- Nat.prime_of_mem_primeFactorsList
theorem prime_of_mem_primeFactorsList {n : ℕ} : ∀ {p : ℕ}, p ∈ primeFactorsList n → Prime p 
Arguments: {n p : ℕ}
Goal: p ∈ n.primeFactorsList → Nat.Prime p
-- Nat.pos_of_mem_primeFactorsList
theorem pos_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ primeFactorsList n) : 0 < p 
Arguments: {n p : ℕ} (h : p ∈ n.primeFactorsList)
Goal: 0 < p
-- Nat.prod_primeFactorsList
theorem prod_primeFactorsList : ∀ {n}, n ≠ 0 → List.prod (primeFactorsList n) = n
  
Arguments: {n : ℕ}
Goal: n ≠ 0 → n.primeFactorsList.prod = n
-- Nat.primeFactorsList_prime
theorem primeFactorsList_prime {p : ℕ} (hp : Nat.Prime p) : p.primeFactorsList = [p] 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.primeFactorsList = [p]
-- Nat.primeFactorsList_chain
theorem primeFactorsList_chain {n : ℕ} :
    ∀ {a}, (∀ p, Prime p → p ∣ n → a ≤ p) → List.Chain (· ≤ ·) a (primeFactorsList n) 
Arguments: {n a : ℕ}
Goal: (∀ (p : ℕ), Nat.Prime p → p ∣ n → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a n.primeFactorsList
-- Nat.primeFactorsList_chain_2
theorem primeFactorsList_chain_2 (n) : List.Chain (· ≤ ·) 2 (primeFactorsList n) 
Arguments: (n : ℕ)
Goal: List.Chain (fun x x_1 => x ≤ x_1) 2 n.primeFactorsList
-- Nat.primeFactorsList_chain'
theorem primeFactorsList_chain' (n) : List.Chain' (· ≤ ·) (primeFactorsList n) 
Arguments: (n : ℕ)
Goal: List.Chain' (fun x x_1 => x ≤ x_1) n.primeFactorsList
-- Nat.primeFactorsList_sorted
theorem primeFactorsList_sorted (n : ℕ) : List.Sorted (· ≤ ·) (primeFactorsList n) 
Arguments: (n : ℕ)
Goal: List.Sorted (fun x x_1 => x ≤ x_1) n.primeFactorsList
-- Nat.primeFactorsList_add_two
theorem primeFactorsList_add_two (n : ℕ) :
    primeFactorsList (n + 2) = minFac (n + 2) :: primeFactorsList ((n + 2) / minFac (n + 2)) 
Arguments: (n : ℕ)
Goal: (n + 2).primeFactorsList = (n + 2).minFac :: ((n + 2) / (n + 2).minFac).primeFactorsList
-- Nat.primeFactorsList_eq_nil
@[simp]
theorem primeFactorsList_eq_nil (n : ℕ) : n.primeFactorsList = [] ↔ n = 0 ∨ n = 1 
Arguments: (n : ℕ)
Goal: n.primeFactorsList = [] ↔ n = 0 ∨ n = 1
-- Nat.eq_of_perm_primeFactorsList
theorem eq_of_perm_primeFactorsList {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
    (h : a.primeFactorsList ~ b.primeFactorsList) : a = b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) (h : a.primeFactorsList.Perm b.primeFactorsList)
Goal: a = b
-- Nat.mem_primeFactorsList_iff_dvd
theorem mem_primeFactorsList_iff_dvd {n p : ℕ} (hn : n ≠ 0) (hp : Prime p) :
    p ∈ primeFactorsList n ↔ p ∣ n 
Arguments: {n p : ℕ} (hn : n ≠ 0) (hp : Nat.Prime p)
Goal: p ∈ n.primeFactorsList ↔ p ∣ n
-- Nat.dvd_of_mem_primeFactorsList
theorem dvd_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ n.primeFactorsList) : p ∣ n 
Arguments: {n p : ℕ} (h : p ∈ n.primeFactorsList)
Goal: p ∣ n
-- Nat.mem_primeFactorsList
theorem mem_primeFactorsList {n p} (hn : n ≠ 0) : p ∈ primeFactorsList n ↔ Prime p ∧ p ∣ n 
Arguments: {n p : ℕ} (hn : n ≠ 0)
Goal: p ∈ n.primeFactorsList ↔ Nat.Prime p ∧ p ∣ n
-- Nat.mem_primeFactorsList'
@[simp] lemma mem_primeFactorsList' {n p} : p ∈ n.primeFactorsList ↔ p.Prime ∧ p ∣ n ∧ n ≠ 0 
Arguments: {n p : ℕ}
Goal: p ∈ n.primeFactorsList ↔ Nat.Prime p ∧ p ∣ n ∧ n ≠ 0
-- Nat.le_of_mem_primeFactorsList
theorem le_of_mem_primeFactorsList {n p : ℕ} (h : p ∈ n.primeFactorsList) : p ≤ n 
Arguments: {n p : ℕ} (h : p ∈ n.primeFactorsList)
Goal: p ≤ n
-- Nat.primeFactorsList_unique
theorem primeFactorsList_unique {n : ℕ} {l : List ℕ} (h₁ : prod l = n) (h₂ : ∀ p ∈ l, Prime p) :
    l ~ primeFactorsList n 
Arguments: {n : ℕ} {l : List ℕ} (h₁ : l.prod = n) (h₂ : ∀ p ∈ l, Nat.Prime p)
Goal: l.Perm n.primeFactorsList
-- Nat.Prime.primeFactorsList_pow
theorem Prime.primeFactorsList_pow {p : ℕ} (hp : p.Prime) (n : ℕ) :
    (p ^ n).primeFactorsList = List.replicate n p 
Arguments: {p : ℕ} (hp : Nat.Prime p) (n : ℕ)
Goal: (p ^ n).primeFactorsList = List.replicate n p
-- Nat.eq_prime_pow_of_unique_prime_dvd
theorem eq_prime_pow_of_unique_prime_dvd {n p : ℕ} (hpos : n ≠ 0)
    (h : ∀ {d}, Nat.Prime d → d ∣ n → d = p) : n = p ^ n.primeFactorsList.length 
Arguments: {n p : ℕ} (hpos : n ≠ 0) (h : ∀ {d : ℕ}, Nat.Prime d → d ∣ n → d = p)
Goal: n = p ^ n.primeFactorsList.length
-- Nat.perm_primeFactorsList_mul
theorem perm_primeFactorsList_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).primeFactorsList ~ a.primeFactorsList ++ b.primeFactorsList 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: (a * b).primeFactorsList.Perm (a.primeFactorsList ++ b.primeFactorsList)
-- Nat.perm_primeFactorsList_mul_of_coprime
theorem perm_primeFactorsList_mul_of_coprime {a b : ℕ} (hab : Coprime a b) :
    (a * b).primeFactorsList ~ a.primeFactorsList ++ b.primeFactorsList 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: (a * b).primeFactorsList.Perm (a.primeFactorsList ++ b.primeFactorsList)
-- Nat.primeFactorsList_sublist_right
theorem primeFactorsList_sublist_right {n k : ℕ} (h : k ≠ 0) :
    n.primeFactorsList <+ (n * k).primeFactorsList 
Arguments: {n k : ℕ} (h : k ≠ 0)
Goal: n.primeFactorsList.Sublist (n * k).primeFactorsList
-- Nat.primeFactorsList_sublist_of_dvd
theorem primeFactorsList_sublist_of_dvd {n k : ℕ} (h : n ∣ k) (h' : k ≠ 0) :
    n.primeFactorsList <+ k.primeFactorsList 
Arguments: {n k : ℕ} (h : n ∣ k) (h' : k ≠ 0)
Goal: n.primeFactorsList.Sublist k.primeFactorsList
-- Nat.primeFactorsList_subset_right
theorem primeFactorsList_subset_right {n k : ℕ} (h : k ≠ 0) :
    n.primeFactorsList ⊆ (n * k).primeFactorsList 
Arguments: {n k : ℕ} (h : k ≠ 0)
Goal: n.primeFactorsList ⊆ (n * k).primeFactorsList
-- Nat.primeFactorsList_subset_of_dvd
theorem primeFactorsList_subset_of_dvd {n k : ℕ} (h : n ∣ k) (h' : k ≠ 0) :
    n.primeFactorsList ⊆ k.primeFactorsList 
Arguments: {n k : ℕ} (h : n ∣ k) (h' : k ≠ 0)
Goal: n.primeFactorsList ⊆ k.primeFactorsList
-- Nat.dvd_of_primeFactorsList_subperm
theorem dvd_of_primeFactorsList_subperm {a b : ℕ} (ha : a ≠ 0)
    (h : a.primeFactorsList <+~ b.primeFactorsList) : a ∣ b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (h : a.primeFactorsList.Subperm b.primeFactorsList)
Goal: a ∣ b
-- Nat.replicate_subperm_primeFactorsList_iff
theorem replicate_subperm_primeFactorsList_iff {a b n : ℕ} (ha : Prime a) (hb : b ≠ 0) :
    replicate n a <+~ primeFactorsList b ↔ a ^ n ∣ b 
Arguments: {a b n : ℕ} (ha : Nat.Prime a) (hb : b ≠ 0)
Goal: (List.replicate n a).Subperm b.primeFactorsList ↔ a ^ n ∣ b
-- Nat.mem_primeFactorsList_mul
theorem mem_primeFactorsList_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) {p : ℕ} :
    p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) {p : ℕ}
Goal: p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList
-- Nat.coprime_primeFactorsList_disjoint
theorem coprime_primeFactorsList_disjoint {a b : ℕ} (hab : a.Coprime b) :
    List.Disjoint a.primeFactorsList b.primeFactorsList 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: a.primeFactorsList.Disjoint b.primeFactorsList
-- Nat.mem_primeFactorsList_mul_of_coprime
theorem mem_primeFactorsList_mul_of_coprime {a b : ℕ} (hab : Coprime a b) (p : ℕ) :
    p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∪ b.primeFactorsList 
Arguments: {a b : ℕ} (hab : a.Coprime b) (p : ℕ)
Goal: p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∪ b.primeFactorsList
-- Nat.mem_primeFactorsList_mul_left
theorem mem_primeFactorsList_mul_left {p a b : ℕ} (hpa : p ∈ a.primeFactorsList) (hb : b ≠ 0) :
    p ∈ (a * b).primeFactorsList 
Arguments: {p a b : ℕ} (hpa : p ∈ a.primeFactorsList) (hb : b ≠ 0)
Goal: p ∈ (a * b).primeFactorsList
-- Nat.mem_primeFactorsList_mul_right
theorem mem_primeFactorsList_mul_right {p a b : ℕ} (hpb : p ∈ b.primeFactorsList) (ha : a ≠ 0) :
    p ∈ (a * b).primeFactorsList 
Arguments: {p a b : ℕ} (hpb : p ∈ b.primeFactorsList) (ha : a ≠ 0)
Goal: p ∈ (a * b).primeFactorsList
-- Nat.eq_two_pow_or_exists_odd_prime_and_dvd
theorem eq_two_pow_or_exists_odd_prime_and_dvd (n : ℕ) :
    (∃ k : ℕ, n = 2 ^ k) ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p 
Arguments: (n : ℕ)
Goal: (∃ k, n = 2 ^ k) ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p
-- Nat.four_dvd_or_exists_odd_prime_and_dvd_of_two_lt
theorem four_dvd_or_exists_odd_prime_and_dvd_of_two_lt {n : ℕ} (n2 : 2 < n) :
    4 ∣ n ∨ ∃ p, Prime p ∧ p ∣ n ∧ Odd p 
Arguments: {n : ℕ} (n2 : 2 < n)
Goal: 4 ∣ n ∨ ∃ p, Nat.Prime p ∧ p ∣ n ∧ Odd p
-- ENNReal.div_eq_inv_mul
protected theorem div_eq_inv_mul : a / b = b⁻¹ * a 
Arguments: {a b : ENNReal}
Goal: a / b = b⁻¹ * a
-- ENNReal.inv_zero
@[simp] theorem inv_zero : (0 : ℝ≥0∞)⁻¹ = ∞ 
Goal: 0⁻¹ = ⊤
-- ENNReal.inv_top
@[simp] theorem inv_top : ∞⁻¹ = 0 
Goal: ⊤⁻¹ = 0
-- ENNReal.coe_inv_le
theorem coe_inv_le : (↑r⁻¹ : ℝ≥0∞) ≤ (↑r)⁻¹ 
Arguments: {r : ℝ≥0}
Goal: ↑r⁻¹ ≤ (↑r)⁻¹
-- ENNReal.coe_inv
@[simp, norm_cast]
theorem coe_inv (hr : r ≠ 0) : (↑r⁻¹ : ℝ≥0∞) = (↑r)⁻¹ 
Arguments: {r : ℝ≥0} (hr : r ≠ 0)
Goal: ↑r⁻¹ = (↑r)⁻¹
-- ENNReal.coe_inv_two
@[norm_cast]
theorem coe_inv_two : ((2⁻¹ : ℝ≥0) : ℝ≥0∞) = 2⁻¹ 
Goal: ↑2⁻¹ = 2⁻¹
-- ENNReal.coe_div
@[simp, norm_cast]
theorem coe_div (hr : r ≠ 0) : (↑(p / r) : ℝ≥0∞) = p / r 
Arguments: {r p : ℝ≥0} (hr : r ≠ 0)
Goal: ↑(p / r) = ↑p / ↑r
-- ENNReal.coe_div_le
lemma coe_div_le : ↑(p / r) ≤ (p / r : ℝ≥0∞) 
Arguments: {r p : ℝ≥0}
Goal: ↑(p / r) ≤ ↑p / ↑r
-- ENNReal.div_zero
theorem div_zero (h : a ≠ 0) : a / 0 = ∞ 
Arguments: {a : ENNReal} (h : a ≠ 0)
Goal: a / 0 = ⊤
-- ENNReal.inv_pow
protected theorem inv_pow : ∀ {a : ℝ≥0∞} {n : ℕ}, (a ^ n)⁻¹ = a⁻¹ ^ n
  
Arguments: {a : ENNReal} {n : ℕ}
Goal: (a ^ n)⁻¹ = a⁻¹ ^ n
-- ENNReal.mul_inv_cancel
protected theorem mul_inv_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a * a⁻¹ = 1 
Arguments: {a : ENNReal} (h0 : a ≠ 0) (ht : a ≠ ⊤)
Goal: a * a⁻¹ = 1
-- ENNReal.inv_mul_cancel
protected theorem inv_mul_cancel (h0 : a ≠ 0) (ht : a ≠ ∞) : a⁻¹ * a = 1 
Arguments: {a : ENNReal} (h0 : a ≠ 0) (ht : a ≠ ⊤)
Goal: a⁻¹ * a = 1
-- ENNReal.div_mul_cancel
protected theorem div_mul_cancel (h0 : a ≠ 0) (hI : a ≠ ∞) : b / a * a = b 
Arguments: {a b : ENNReal} (h0 : a ≠ 0) (hI : a ≠ ⊤)
Goal: b / a * a = b
-- ENNReal.mul_div_cancel'
protected theorem mul_div_cancel' (h0 : a ≠ 0) (hI : a ≠ ∞) : a * (b / a) = b 
Arguments: {a b : ENNReal} (h0 : a ≠ 0) (hI : a ≠ ⊤)
Goal: a * (b / a) = b
-- ENNReal.mul_comm_div
protected theorem mul_comm_div : a / b * c = a * (c / b) 
Arguments: {a b c : ENNReal}
Goal: a / b * c = a * (c / b)
-- ENNReal.mul_div_right_comm
protected theorem mul_div_right_comm : a * b / c = a / c * b 
Arguments: {a b c : ENNReal}
Goal: a * b / c = a / c * b
-- ENNReal.inv_eq_one
@[simp] protected lemma inv_eq_one : a⁻¹ = 1 ↔ a = 1 
Arguments: {a : ENNReal}
Goal: a⁻¹ = 1 ↔ a = 1
-- ENNReal.inv_eq_top
@[simp] theorem inv_eq_top : a⁻¹ = ∞ ↔ a = 0 
Arguments: {a : ENNReal}
Goal: a⁻¹ = ⊤ ↔ a = 0
-- ENNReal.inv_ne_top
theorem inv_ne_top : a⁻¹ ≠ ∞ ↔ a ≠ 0 
Arguments: {a : ENNReal}
Goal: a⁻¹ ≠ ⊤ ↔ a ≠ 0
-- ENNReal.inv_lt_top
@[simp]
theorem inv_lt_top {x : ℝ≥0∞} : x⁻¹ < ∞ ↔ 0 < x 
Arguments: {x : ENNReal}
Goal: x⁻¹ < ⊤ ↔ 0 < x
-- ENNReal.div_lt_top
theorem div_lt_top {x y : ℝ≥0∞} (h1 : x ≠ ∞) (h2 : y ≠ 0) : x / y < ∞ 
Arguments: {x y : ENNReal} (h1 : x ≠ ⊤) (h2 : y ≠ 0)
Goal: x / y < ⊤
-- ENNReal.inv_eq_zero
@[simp]
protected theorem inv_eq_zero : a⁻¹ = 0 ↔ a = ∞ 
Arguments: {a : ENNReal}
Goal: a⁻¹ = 0 ↔ a = ⊤
-- ENNReal.inv_ne_zero
protected theorem inv_ne_zero : a⁻¹ ≠ 0 ↔ a ≠ ∞ 
Arguments: {a : ENNReal}
Goal: a⁻¹ ≠ 0 ↔ a ≠ ⊤
-- ENNReal.div_pos
protected theorem div_pos (ha : a ≠ 0) (hb : b ≠ ∞) : 0 < a / b 
Arguments: {a b : ENNReal} (ha : a ≠ 0) (hb : b ≠ ⊤)
Goal: 0 < a / b
-- ENNReal.inv_mul_le_iff
protected theorem inv_mul_le_iff {x y z : ℝ≥0∞} (h1 : x ≠ 0) (h2 : x ≠ ∞) :
    x⁻¹ * y ≤ z ↔ y ≤ x * z 
Arguments: {x y z : ENNReal} (h1 : x ≠ 0) (h2 : x ≠ ⊤)
Goal: x⁻¹ * y ≤ z ↔ y ≤ x * z
-- ENNReal.mul_inv_le_iff
protected theorem mul_inv_le_iff {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x * y⁻¹ ≤ z ↔ x ≤ z * y 
Arguments: {x y z : ENNReal} (h1 : y ≠ 0) (h2 : y ≠ ⊤)
Goal: x * y⁻¹ ≤ z ↔ x ≤ z * y
-- ENNReal.div_le_iff
protected theorem div_le_iff {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x / y ≤ z ↔ x ≤ z * y 
Arguments: {x y z : ENNReal} (h1 : y ≠ 0) (h2 : y ≠ ⊤)
Goal: x / y ≤ z ↔ x ≤ z * y
-- ENNReal.div_le_iff'
protected theorem div_le_iff' {x y z : ℝ≥0∞} (h1 : y ≠ 0) (h2 : y ≠ ∞) :
    x / y ≤ z ↔ x ≤ y * z 
Arguments: {x y z : ENNReal} (h1 : y ≠ 0) (h2 : y ≠ ⊤)
Goal: x / y ≤ z ↔ x ≤ y * z
-- ENNReal.mul_inv
protected theorem mul_inv {a b : ℝ≥0∞} (ha : a ≠ 0 ∨ b ≠ ∞) (hb : a ≠ ∞ ∨ b ≠ 0) :
    (a * b)⁻¹ = a⁻¹ * b⁻¹ 
Arguments: {a b : ENNReal} (ha : a ≠ 0 ∨ b ≠ ⊤) (hb : a ≠ ⊤ ∨ b ≠ 0)
Goal: (a * b)⁻¹ = a⁻¹ * b⁻¹
-- ENNReal.mul_div_mul_left
protected theorem mul_div_mul_left (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    c * a / (c * b) = a / b 
Arguments: {c : ENNReal} (a b : ENNReal) (hc : c ≠ 0) (hc' : c ≠ ⊤)
Goal: c * a / (c * b) = a / b
-- ENNReal.mul_div_mul_right
protected theorem mul_div_mul_right (a b : ℝ≥0∞) (hc : c ≠ 0) (hc' : c ≠ ⊤) :
    a * c / (b * c) = a / b 
Arguments: {c : ENNReal} (a b : ENNReal) (hc : c ≠ 0) (hc' : c ≠ ⊤)
Goal: a * c / (b * c) = a / b
-- ENNReal.sub_div
protected theorem sub_div (h : 0 < b → b < a → c ≠ 0) : (a - b) / c = a / c - b / c 
Arguments: {a b c : ENNReal} (h : 0 < b → b < a → c ≠ 0)
Goal: (a - b) / c = a / c - b / c
-- ENNReal.inv_pos
@[simp]
protected theorem inv_pos : 0 < a⁻¹ ↔ a ≠ ∞ 
Arguments: {a : ENNReal}
Goal: 0 < a⁻¹ ↔ a ≠ ⊤
-- ENNReal.inv_strictAnti
theorem inv_strictAnti : StrictAnti (Inv.inv : ℝ≥0∞ → ℝ≥0∞) 
Goal: StrictAnti Inv.inv
-- ENNReal.inv_lt_inv
@[simp]
protected theorem inv_lt_inv : a⁻¹ < b⁻¹ ↔ b < a 
Arguments: {a b : ENNReal}
Goal: a⁻¹ < b⁻¹ ↔ b < a
-- ENNReal.inv_lt_iff_inv_lt
theorem inv_lt_iff_inv_lt : a⁻¹ < b ↔ b⁻¹ < a 
Arguments: {a b : ENNReal}
Goal: a⁻¹ < b ↔ b⁻¹ < a
-- ENNReal.lt_inv_iff_lt_inv
theorem lt_inv_iff_lt_inv : a < b⁻¹ ↔ b < a⁻¹ 
Arguments: {a b : ENNReal}
Goal: a < b⁻¹ ↔ b < a⁻¹
-- ENNReal.inv_le_inv
@[simp]
protected theorem inv_le_inv : a⁻¹ ≤ b⁻¹ ↔ b ≤ a 
Arguments: {a b : ENNReal}
Goal: a⁻¹ ≤ b⁻¹ ↔ b ≤ a
-- ENNReal.inv_le_iff_inv_le
theorem inv_le_iff_inv_le : a⁻¹ ≤ b ↔ b⁻¹ ≤ a 
Arguments: {a b : ENNReal}
Goal: a⁻¹ ≤ b ↔ b⁻¹ ≤ a
-- ENNReal.le_inv_iff_le_inv
theorem le_inv_iff_le_inv : a ≤ b⁻¹ ↔ b ≤ a⁻¹ 
Arguments: {a b : ENNReal}
Goal: a ≤ b⁻¹ ↔ b ≤ a⁻¹
-- ENNReal.inv_le_inv'
@[gcongr] protected theorem inv_le_inv' (h : a ≤ b) : b⁻¹ ≤ a⁻¹ 
Arguments: {a b : ENNReal} (h : a ≤ b)
Goal: b⁻¹ ≤ a⁻¹
-- ENNReal.inv_lt_inv'
@[gcongr] protected theorem inv_lt_inv' (h : a < b) : b⁻¹ < a⁻¹ 
Arguments: {a b : ENNReal} (h : a < b)
Goal: b⁻¹ < a⁻¹
-- ENNReal.inv_le_one
@[simp]
protected theorem inv_le_one : a⁻¹ ≤ 1 ↔ 1 ≤ a 
Arguments: {a : ENNReal}
Goal: a⁻¹ ≤ 1 ↔ 1 ≤ a
-- ENNReal.one_le_inv
protected theorem one_le_inv : 1 ≤ a⁻¹ ↔ a ≤ 1 
Arguments: {a : ENNReal}
Goal: 1 ≤ a⁻¹ ↔ a ≤ 1
-- ENNReal.inv_lt_one
@[simp]
protected theorem inv_lt_one : a⁻¹ < 1 ↔ 1 < a 
Arguments: {a : ENNReal}
Goal: a⁻¹ < 1 ↔ 1 < a
-- ENNReal.one_lt_inv
@[simp]
protected theorem one_lt_inv : 1 < a⁻¹ ↔ a < 1 
Arguments: {a : ENNReal}
Goal: 1 < a⁻¹ ↔ a < 1
-- OrderIso.invENNReal_apply
@[simps! apply]
def _root_.OrderIso.invENNReal : ℝ≥0∞ ≃o ℝ≥0∞ᵒᵈ 
Goal: ∀ (a : ENNReal), OrderIso.invENNReal a = (OrderDual.toDual a)⁻¹
-- OrderIso.invENNReal_symm_apply
@[simp]
theorem _root_.OrderIso.invENNReal_symm_apply (a : ℝ≥0∞ᵒᵈ) :
    OrderIso.invENNReal.symm a = (OrderDual.ofDual a)⁻¹ 
Arguments: (a : ENNRealᵒᵈ)
Goal: OrderIso.invENNReal.symm a = (OrderDual.ofDual a)⁻¹
-- ENNReal.div_top
@[simp] theorem div_top : a / ∞ = 0 
Arguments: {a : ENNReal}
Goal: a / ⊤ = 0
-- ENNReal.top_div
theorem top_div : ∞ / a = if a = ∞ then 0 else ∞ 
Arguments: {a : ENNReal}
Goal: ⊤ / a = if a = ⊤ then 0 else ⊤
-- ENNReal.top_div_of_ne_top
theorem top_div_of_ne_top (h : a ≠ ∞) : ∞ / a = ∞ 
Arguments: {a : ENNReal} (h : a ≠ ⊤)
Goal: ⊤ / a = ⊤
-- ENNReal.top_div_coe
@[simp] theorem top_div_coe : ∞ / p = ∞ 
Arguments: {p : ℝ≥0}
Goal: ⊤ / ↑p = ⊤
-- ENNReal.top_div_of_lt_top
theorem top_div_of_lt_top (h : a < ∞) : ∞ / a = ∞ 
Arguments: {a : ENNReal} (h : a < ⊤)
Goal: ⊤ / a = ⊤
-- ENNReal.zero_div
@[simp] protected theorem zero_div : 0 / a = 0 
Arguments: {a : ENNReal}
Goal: 0 / a = 0
-- ENNReal.div_eq_top
theorem div_eq_top : a / b = ∞ ↔ a ≠ 0 ∧ b = 0 ∨ a = ∞ ∧ b ≠ ∞ 
Arguments: {a b : ENNReal}
Goal: a / b = ⊤ ↔ a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤
-- ENNReal.le_div_iff_mul_le
protected theorem le_div_iff_mul_le (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ∞ ∨ c ≠ ∞) :
    a ≤ c / b ↔ a * b ≤ c 
Arguments: {a b c : ENNReal} (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ⊤ ∨ c ≠ ⊤)
Goal: a ≤ c / b ↔ a * b ≤ c
-- ENNReal.div_le_iff_le_mul
protected theorem div_le_iff_le_mul (hb0 : b ≠ 0 ∨ c ≠ ∞) (hbt : b ≠ ∞ ∨ c ≠ 0) :
    a / b ≤ c ↔ a ≤ c * b 
Arguments: {a b c : ENNReal} (hb0 : b ≠ 0 ∨ c ≠ ⊤) (hbt : b ≠ ⊤ ∨ c ≠ 0)
Goal: a / b ≤ c ↔ a ≤ c * b
-- ENNReal.lt_div_iff_mul_lt
protected theorem lt_div_iff_mul_lt (hb0 : b ≠ 0 ∨ c ≠ ∞) (hbt : b ≠ ∞ ∨ c ≠ 0) :
    c < a / b ↔ c * b < a 
Arguments: {a b c : ENNReal} (hb0 : b ≠ 0 ∨ c ≠ ⊤) (hbt : b ≠ ⊤ ∨ c ≠ 0)
Goal: c < a / b ↔ c * b < a
-- ENNReal.div_le_of_le_mul
theorem div_le_of_le_mul (h : a ≤ b * c) : a / c ≤ b 
Arguments: {a b c : ENNReal} (h : a ≤ b * c)
Goal: a / c ≤ b
-- ENNReal.div_le_of_le_mul'
theorem div_le_of_le_mul' (h : a ≤ b * c) : a / b ≤ c 
Arguments: {a b c : ENNReal} (h : a ≤ b * c)
Goal: a / b ≤ c
-- ENNReal.div_self_le_one
@[simp] protected theorem div_self_le_one : a / a ≤ 1 
Arguments: {a : ENNReal}
Goal: a / a ≤ 1
-- ENNReal.mul_inv_le_one
@[simp] protected lemma mul_inv_le_one (a : ℝ≥0∞) : a * a⁻¹ ≤ 1 
Arguments: (a : ENNReal)
Goal: a * a⁻¹ ≤ 1
-- ENNReal.inv_mul_le_one
@[simp] protected lemma inv_mul_le_one (a : ℝ≥0∞) : a⁻¹ * a ≤ 1 
Arguments: (a : ENNReal)
Goal: a⁻¹ * a ≤ 1
-- ENNReal.mul_inv_ne_top
@[simp] lemma mul_inv_ne_top (a : ℝ≥0∞) : a * a⁻¹ ≠ ⊤ 
Arguments: (a : ENNReal)
Goal: a * a⁻¹ ≠ ⊤
-- ENNReal.inv_mul_ne_top
@[simp] lemma inv_mul_ne_top (a : ℝ≥0∞) : a⁻¹ * a ≠ ⊤ 
Arguments: (a : ENNReal)
Goal: a⁻¹ * a ≠ ⊤
-- ENNReal.mul_le_of_le_div
theorem mul_le_of_le_div (h : a ≤ b / c) : a * c ≤ b 
Arguments: {a b c : ENNReal} (h : a ≤ b / c)
Goal: a * c ≤ b
-- ENNReal.mul_le_of_le_div'
theorem mul_le_of_le_div' (h : a ≤ b / c) : c * a ≤ b 
Arguments: {a b c : ENNReal} (h : a ≤ b / c)
Goal: c * a ≤ b
-- ENNReal.div_lt_iff
protected theorem div_lt_iff (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ∞ ∨ c ≠ ∞) : c / b < a ↔ c < a * b 
Arguments: {a b c : ENNReal} (h0 : b ≠ 0 ∨ c ≠ 0) (ht : b ≠ ⊤ ∨ c ≠ ⊤)
Goal: c / b < a ↔ c < a * b
-- ENNReal.mul_lt_of_lt_div
theorem mul_lt_of_lt_div (h : a < b / c) : a * c < b 
Arguments: {a b c : ENNReal} (h : a < b / c)
Goal: a * c < b
-- ENNReal.mul_lt_of_lt_div'
theorem mul_lt_of_lt_div' (h : a < b / c) : c * a < b 
Arguments: {a b c : ENNReal} (h : a < b / c)
Goal: c * a < b
-- ENNReal.div_lt_of_lt_mul
theorem div_lt_of_lt_mul (h : a < b * c) : a / c < b 
Arguments: {a b c : ENNReal} (h : a < b * c)
Goal: a / c < b
-- ENNReal.div_lt_of_lt_mul'
theorem div_lt_of_lt_mul' (h : a < b * c) : a / b < c 
Arguments: {a b c : ENNReal} (h : a < b * c)
Goal: a / b < c
-- ENNReal.inv_le_iff_le_mul
theorem inv_le_iff_le_mul (h₁ : b = ∞ → a ≠ 0) (h₂ : a = ∞ → b ≠ 0) : a⁻¹ ≤ b ↔ 1 ≤ a * b 
Arguments: {a b : ENNReal} (h₁ : b = ⊤ → a ≠ 0) (h₂ : a = ⊤ → b ≠ 0)
Goal: a⁻¹ ≤ b ↔ 1 ≤ a * b
-- ENNReal.le_inv_iff_mul_le
@[simp 900]
theorem le_inv_iff_mul_le : a ≤ b⁻¹ ↔ a * b ≤ 1 
Arguments: {a b : ENNReal}
Goal: a ≤ b⁻¹ ↔ a * b ≤ 1
-- ENNReal.div_le_div
@[gcongr] protected theorem div_le_div (hab : a ≤ b) (hdc : d ≤ c) : a / c ≤ b / d 
Arguments: {a b c d : ENNReal} (hab : a ≤ b) (hdc : d ≤ c)
Goal: a / c ≤ b / d
-- ENNReal.div_le_div_left
@[gcongr] protected theorem div_le_div_left (h : a ≤ b) (c : ℝ≥0∞) : c / b ≤ c / a 
Arguments: {a b : ENNReal} (h : a ≤ b) (c : ENNReal)
Goal: c / b ≤ c / a
-- ENNReal.div_le_div_right
@[gcongr] protected theorem div_le_div_right (h : a ≤ b) (c : ℝ≥0∞) : a / c ≤ b / c 
Arguments: {a b : ENNReal} (h : a ≤ b) (c : ENNReal)
Goal: a / c ≤ b / c
-- ENNReal.eq_inv_of_mul_eq_one_left
protected theorem eq_inv_of_mul_eq_one_left (h : a * b = 1) : a = b⁻¹ 
Arguments: {a b : ENNReal} (h : a * b = 1)
Goal: a = b⁻¹