ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.succ_div_of_not_dvd
lemma succ_div_of_not_dvd (hba : ¬b ∣ a + 1) : (a + 1) / b = a / b 
Arguments: {a b : ℕ} (hba : ¬b ∣ a + 1)
Goal: (a + 1) / b = a / b
-- Nat.dvd_iff_div_mul_eq
lemma dvd_iff_div_mul_eq (n d : ℕ) : d ∣ n ↔ n / d * d = n 
Arguments: (n d : ℕ)
Goal: d ∣ n ↔ n / d * d = n
-- Nat.dvd_iff_le_div_mul
lemma dvd_iff_le_div_mul (n d : ℕ) : d ∣ n ↔ n ≤ n / d * d 
Arguments: (n d : ℕ)
Goal: d ∣ n ↔ n ≤ n / d * d
-- Nat.dvd_iff_dvd_dvd
lemma dvd_iff_dvd_dvd (n d : ℕ) : d ∣ n ↔ ∀ k : ℕ, k ∣ d → k ∣ n 
Arguments: (n d : ℕ)
Goal: d ∣ n ↔ ∀ (k : ℕ), k ∣ d → k ∣ n
-- Nat.dvd_div_of_mul_dvd
lemma dvd_div_of_mul_dvd (h : a * b ∣ c) : b ∣ c / a 
Arguments: {a b c : ℕ} (h : a * b ∣ c)
Goal: b ∣ c / a
-- Nat.dvd_div_iff_mul_dvd
@[simp] lemma dvd_div_iff_mul_dvd (hbc : c ∣ b) : a ∣ b / c ↔ c * a ∣ b 
Arguments: {a b c : ℕ} (hbc : c ∣ b)
Goal: a ∣ b / c ↔ c * a ∣ b
-- Nat.dvd_mul_of_div_dvd
lemma dvd_mul_of_div_dvd (h : b ∣ a) (hdiv : a / b ∣ c) : a ∣ b * c 
Arguments: {a b c : ℕ} (h : b ∣ a) (hdiv : a / b ∣ c)
Goal: a ∣ b * c
-- Nat.div_dvd_iff_dvd_mul
@[simp] lemma div_dvd_iff_dvd_mul (h : b ∣ a) (hb : b ≠ 0) : a / b ∣ c ↔ a ∣ b * c 
Arguments: {a b c : ℕ} (h : b ∣ a) (hb : b ≠ 0)
Goal: a / b ∣ c ↔ a ∣ b * c
-- Nat.div_div_div_eq_div
@[simp] lemma div_div_div_eq_div (dvd : b ∣ a) (dvd2 : a ∣ c) : c / (a / b) / b = c / a 
Arguments: {a b c : ℕ} (dvd : b ∣ a) (dvd2 : a ∣ c)
Goal: c / (a / b) / b = c / a
-- Nat.eq_zero_of_dvd_of_lt
lemma eq_zero_of_dvd_of_lt (w : a ∣ b) (h : b < a) : b = 0 
Arguments: {a b : ℕ} (w : a ∣ b) (h : b < a)
Goal: b = 0
-- Nat.le_of_lt_add_of_dvd
lemma le_of_lt_add_of_dvd (h : a < b + n) : n ∣ a → n ∣ b → a ≤ b 
Arguments: {a b n : ℕ} (h : a < b + n)
Goal: n ∣ a → n ∣ b → a ≤ b
-- Nat.not_dvd_iff_between_consec_multiples
lemma not_dvd_iff_between_consec_multiples (n : ℕ) {a : ℕ} (ha : 0 < a) :
    (∃ k : ℕ, a * k < n ∧ n < a * (k + 1)) ↔ ¬a ∣ n 
Arguments: (n : ℕ) {a : ℕ} (ha : 0 < a)
Goal: (∃ k, a * k < n ∧ n < a * (k + 1)) ↔ ¬a ∣ n
-- Nat.dvd_right_iff_eq
lemma dvd_right_iff_eq : (∀ a : ℕ, m ∣ a ↔ n ∣ a) ↔ m = n 
Arguments: {m n : ℕ}
Goal: (∀ (a : ℕ), m ∣ a ↔ n ∣ a) ↔ m = n
-- Nat.dvd_left_iff_eq
lemma dvd_left_iff_eq : (∀ a : ℕ, a ∣ m ↔ a ∣ n) ↔ m = n 
Arguments: {m n : ℕ}
Goal: (∀ (a : ℕ), a ∣ m ↔ a ∣ n) ↔ m = n
-- Nat.dvd_left_injective
lemma dvd_left_injective : Function.Injective ((· ∣ ·) : ℕ → ℕ → Prop) 
Goal: Function.Injective fun x x_1 => x ∣ x_1
-- Nat.div_lt_div_of_lt_of_dvd
lemma div_lt_div_of_lt_of_dvd {a b d : ℕ} (hdb : d ∣ b) (h : a < b) : a / d < b / d 
Arguments: {a b d : ℕ} (hdb : d ∣ b) (h : a < b)
Goal: a / d < b / d
-- _private.Mathlib.Data.Nat.Defs.0.Nat.iter_fp_bound
private lemma iter_fp_bound (n k : ℕ) :
    let iter_next (n guess : ℕ) := (guess + n / guess) / 2;
    sqrt.iter n k ≤ iter_next n (sqrt.iter n k) 
Arguments: (n k : ℕ)
Goal: let iter_next := fun n guess => (guess + n / guess) / 2;
Nat.sqrt.iter n k ≤ iter_next n (Nat.sqrt.iter n k)
-- _private.Mathlib.Data.Nat.Defs.0.Nat.AM_GM
private lemma AM_GM : {a b : ℕ} → (4 * a * b ≤ (a + b) * (a + b))
  
Arguments: {a b : ℕ}
Goal: 4 * a * b ≤ (a + b) * (a + b)
-- Nat.sqrt.iter_sq_le
lemma sqrt.iter_sq_le (n guess : ℕ) : sqrt.iter n guess * sqrt.iter n guess ≤ n 
Arguments: (n guess : ℕ)
Goal: Nat.sqrt.iter n guess * Nat.sqrt.iter n guess ≤ n
-- Nat.sqrt.lt_iter_succ_sq
lemma sqrt.lt_iter_succ_sq (n guess : ℕ) (hn : n < (guess + 1) * (guess + 1)) :
    n < (sqrt.iter n guess + 1) * (sqrt.iter n guess + 1) 
Arguments: (n guess : ℕ) (hn : n < (guess + 1) * (guess + 1))
Goal: n < (Nat.sqrt.iter n guess + 1) * (Nat.sqrt.iter n guess + 1)
-- _private.Mathlib.Data.Nat.Defs.0.Nat.sqrt_isSqrt
private lemma sqrt_isSqrt (n : ℕ) : IsSqrt n (sqrt n) 
Arguments: (n : ℕ)
Goal: Nat.IsSqrt n n.sqrt
-- Nat.sqrt_le
lemma sqrt_le (n : ℕ) : sqrt n * sqrt n ≤ n 
Arguments: (n : ℕ)
Goal: n.sqrt * n.sqrt ≤ n
-- Nat.sqrt_le'
lemma sqrt_le' (n : ℕ) : sqrt n ^ 2 ≤ n 
Arguments: (n : ℕ)
Goal: n.sqrt ^ 2 ≤ n
-- Nat.lt_succ_sqrt
lemma lt_succ_sqrt (n : ℕ) : n < succ (sqrt n) * succ (sqrt n) 
Arguments: (n : ℕ)
Goal: n < n.sqrt.succ * n.sqrt.succ
-- Nat.lt_succ_sqrt'
lemma lt_succ_sqrt' (n : ℕ) : n < succ (sqrt n) ^ 2 
Arguments: (n : ℕ)
Goal: n < n.sqrt.succ ^ 2
-- Nat.sqrt_le_add
lemma sqrt_le_add (n : ℕ) : n ≤ sqrt n * sqrt n + sqrt n + sqrt n 
Arguments: (n : ℕ)
Goal: n ≤ n.sqrt * n.sqrt + n.sqrt + n.sqrt
-- Nat.le_sqrt
lemma le_sqrt : m ≤ sqrt n ↔ m * m ≤ n 
Arguments: {m n : ℕ}
Goal: m ≤ n.sqrt ↔ m * m ≤ n
-- Nat.le_sqrt'
lemma le_sqrt' : m ≤ sqrt n ↔ m ^ 2 ≤ n 
Arguments: {m n : ℕ}
Goal: m ≤ n.sqrt ↔ m ^ 2 ≤ n
-- Nat.sqrt_lt
lemma sqrt_lt : sqrt m < n ↔ m < n * n 
Arguments: {m n : ℕ}
Goal: m.sqrt < n ↔ m < n * n
-- Nat.sqrt_lt'
lemma sqrt_lt' : sqrt m < n ↔ m < n ^ 2 
Arguments: {m n : ℕ}
Goal: m.sqrt < n ↔ m < n ^ 2
-- Nat.sqrt_le_self
lemma sqrt_le_self (n : ℕ) : sqrt n ≤ n 
Arguments: (n : ℕ)
Goal: n.sqrt ≤ n
-- Nat.sqrt_le_sqrt
lemma sqrt_le_sqrt (h : m ≤ n) : sqrt m ≤ sqrt n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.sqrt ≤ n.sqrt
-- Nat.sqrt_zero
@[simp] lemma sqrt_zero : sqrt 0 = 0 
Goal: Nat.sqrt 0 = 0
-- Nat.sqrt_one
@[simp] lemma sqrt_one : sqrt 1 = 1 
Goal: Nat.sqrt 1 = 1
-- Nat.sqrt_eq_zero
lemma sqrt_eq_zero : sqrt n = 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: n.sqrt = 0 ↔ n = 0
-- Nat.eq_sqrt
lemma eq_sqrt : a = sqrt n ↔ a * a ≤ n ∧ n < (a + 1) * (a + 1) 
Arguments: {a n : ℕ}
Goal: a = n.sqrt ↔ a * a ≤ n ∧ n < (a + 1) * (a + 1)
-- Nat.eq_sqrt'
lemma eq_sqrt' : a = sqrt n ↔ a ^ 2 ≤ n ∧ n < (a + 1) ^ 2 
Arguments: {a n : ℕ}
Goal: a = n.sqrt ↔ a ^ 2 ≤ n ∧ n < (a + 1) ^ 2
-- Nat.le_three_of_sqrt_eq_one
lemma le_three_of_sqrt_eq_one (h : sqrt n = 1) : n ≤ 3 
Arguments: {n : ℕ} (h : n.sqrt = 1)
Goal: n ≤ 3
-- Nat.sqrt_lt_self
lemma sqrt_lt_self (h : 1 < n) : sqrt n < n 
Arguments: {n : ℕ} (h : 1 < n)
Goal: n.sqrt < n
-- Nat.sqrt_pos
lemma sqrt_pos : 0 < sqrt n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < n.sqrt ↔ 0 < n
-- Nat.sqrt_add_eq
lemma sqrt_add_eq (n : ℕ) (h : a ≤ n + n) : sqrt (n * n + a) = n 
Arguments: {a : ℕ} (n : ℕ) (h : a ≤ n + n)
Goal: (n * n + a).sqrt = n
-- Nat.sqrt_add_eq'
lemma sqrt_add_eq' (n : ℕ) (h : a ≤ n + n) : sqrt (n ^ 2 + a) = n 
Arguments: {a : ℕ} (n : ℕ) (h : a ≤ n + n)
Goal: (n ^ 2 + a).sqrt = n
-- Nat.sqrt_eq
lemma sqrt_eq (n : ℕ) : sqrt (n * n) = n 
Arguments: (n : ℕ)
Goal: (n * n).sqrt = n
-- Nat.sqrt_eq'
lemma sqrt_eq' (n : ℕ) : sqrt (n ^ 2) = n 
Arguments: (n : ℕ)
Goal: (n ^ 2).sqrt = n
-- Nat.sqrt_succ_le_succ_sqrt
lemma sqrt_succ_le_succ_sqrt (n : ℕ) : sqrt n.succ ≤ n.sqrt.succ 
Arguments: (n : ℕ)
Goal: n.succ.sqrt ≤ n.sqrt.succ
-- Nat.exists_mul_self
lemma exists_mul_self (x : ℕ) : (∃ n, n * n = x) ↔ sqrt x * sqrt x = x 
Arguments: (x : ℕ)
Goal: (∃ n, n * n = x) ↔ x.sqrt * x.sqrt = x
-- Nat.exists_mul_self'
lemma exists_mul_self' (x : ℕ) : (∃ n, n ^ 2 = x) ↔ sqrt x ^ 2 = x 
Arguments: (x : ℕ)
Goal: (∃ n, n ^ 2 = x) ↔ x.sqrt ^ 2 = x
-- Nat.sqrt_mul_sqrt_lt_succ
lemma sqrt_mul_sqrt_lt_succ (n : ℕ) : sqrt n * sqrt n < n + 1 
Arguments: (n : ℕ)
Goal: n.sqrt * n.sqrt < n + 1
-- Nat.sqrt_mul_sqrt_lt_succ'
lemma sqrt_mul_sqrt_lt_succ' (n : ℕ) : sqrt n ^ 2 < n + 1 
Arguments: (n : ℕ)
Goal: n.sqrt ^ 2 < n + 1
-- Nat.succ_le_succ_sqrt
lemma succ_le_succ_sqrt (n : ℕ) : n + 1 ≤ (sqrt n + 1) * (sqrt n + 1) 
Arguments: (n : ℕ)
Goal: n + 1 ≤ (n.sqrt + 1) * (n.sqrt + 1)
-- Nat.succ_le_succ_sqrt'
lemma succ_le_succ_sqrt' (n : ℕ) : n + 1 ≤ (sqrt n + 1) ^ 2 
Arguments: (n : ℕ)
Goal: n + 1 ≤ (n.sqrt + 1) ^ 2
-- Nat.not_exists_sq
lemma not_exists_sq (hl : m * m < n) (hr : n < (m + 1) * (m + 1)) : ¬∃ t, t * t = n 
Arguments: {m n : ℕ} (hl : m * m < n) (hr : n < (m + 1) * (m + 1))
Goal: ¬∃ t, t * t = n
-- Nat.not_exists_sq'
lemma not_exists_sq' : m ^ 2 < n → n < (m + 1) ^ 2 → ¬∃ t, t ^ 2 = n 
Arguments: {m n : ℕ}
Goal: m ^ 2 < n → n < (m + 1) ^ 2 → ¬∃ t, t ^ 2 = n
-- WType.leftInverse_nat
theorem leftInverse_nat : Function.LeftInverse ofNat toNat
  
Goal: Function.LeftInverse WType.ofNat WType.toNat
-- WType.rightInverse_nat
theorem rightInverse_nat : Function.RightInverse ofNat toNat
  
Goal: Function.RightInverse WType.ofNat WType.toNat
-- WType.NatαEquivPUnitSumPUnit_apply
@[simps]
def NatαEquivPUnitSumPUnit : Natα ≃ PUnit.{u + 1} ⊕ PUnit 
Arguments: (c : WType.Natα)
Goal: WType.NatαEquivPUnitSumPUnit c =
  match c with
  | WType.Natα.zero => Sum.inl PUnit.unit
  | WType.Natα.succ => Sum.inr PUnit.unit
-- WType.NatαEquivPUnitSumPUnit_symm_apply
@[simps]
def NatαEquivPUnitSumPUnit : Natα ≃ PUnit.{u + 1} ⊕ PUnit 
Arguments: (b : PUnit.{u + 1} ⊕ PUnit.{u_1 + 1})
Goal: WType.NatαEquivPUnitSumPUnit.symm b =
  match b with
  | Sum.inl val => WType.Natα.zero
  | Sum.inr val => WType.Natα.succ
-- WType.leftInverse_list
theorem leftInverse_list : Function.LeftInverse (ofList γ) (toList _)
  
Arguments: (γ : Type u)
Goal: Function.LeftInverse (WType.ofList γ) (WType.toList γ)
-- WType.rightInverse_list
theorem rightInverse_list : Function.RightInverse (ofList γ) (toList _)
  
Arguments: (γ : Type u)
Goal: Function.RightInverse (WType.ofList γ) (WType.toList γ)
-- Nat.totient_zero
@[simp]
theorem totient_zero : φ 0 = 0 
Goal: Nat.totient 0 = 0
-- Nat.totient_one
@[simp]
theorem totient_one : φ 1 = 1 
Goal: Nat.totient 1 = 1
-- Nat.totient_eq_card_coprime
theorem totient_eq_card_coprime (n : ℕ) : φ n = ((range n).filter n.Coprime).card 
Arguments: (n : ℕ)
Goal: n.totient = (Finset.filter n.Coprime (Finset.range n)).card
-- Nat.totient_eq_card_lt_and_coprime
theorem totient_eq_card_lt_and_coprime (n : ℕ) : φ n = Nat.card { m | m < n ∧ n.Coprime m } 
Arguments: (n : ℕ)
Goal: n.totient = Nat.card ↑{m | m < n ∧ n.Coprime m}
-- Nat.totient_le
theorem totient_le (n : ℕ) : φ n ≤ n 
Arguments: (n : ℕ)
Goal: n.totient ≤ n
-- Nat.totient_lt
theorem totient_lt (n : ℕ) (hn : 1 < n) : φ n < n 
Arguments: (n : ℕ) (hn : 1 < n)
Goal: n.totient < n
-- Nat.totient_eq_zero
@[simp]
theorem totient_eq_zero : ∀ {n : ℕ}, φ n = 0 ↔ n = 0
  
Arguments: {n : ℕ}
Goal: n.totient = 0 ↔ n = 0
-- Nat.totient_pos
@[simp] theorem totient_pos {n : ℕ} : 0 < φ n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < n.totient ↔ 0 < n
-- Nat.filter_coprime_Ico_eq_totient
theorem filter_coprime_Ico_eq_totient (a n : ℕ) :
    ((Ico n (n + a)).filter (Coprime a)).card = totient a 
Arguments: (a n : ℕ)
Goal: (Finset.filter a.Coprime (Finset.Ico n (n + a))).card = a.totient
-- Nat.Ico_filter_coprime_le
theorem Ico_filter_coprime_le {a : ℕ} (k n : ℕ) (a_pos : 0 < a) :
    ((Ico k (k + n)).filter (Coprime a)).card ≤ totient a * (n / a + 1) 
Arguments: {a : ℕ} (k n : ℕ) (a_pos : 0 < a)
Goal: (Finset.filter a.Coprime (Finset.Ico k (k + n))).card ≤ a.totient * (n / a + 1)
-- ZMod.card_units_eq_totient
@[simp]
theorem _root_.ZMod.card_units_eq_totient (n : ℕ) [NeZero n] [Fintype (ZMod n)ˣ] :
    Fintype.card (ZMod n)ˣ = φ n 
Arguments: (n : ℕ) [NeZero n] [Fintype (ZMod n)ˣ]
Goal: Fintype.card (ZMod n)ˣ = n.totient
-- Nat.totient_even
theorem totient_even {n : ℕ} (hn : 2 < n) : Even n.totient 
Arguments: {n : ℕ} (hn : 2 < n)
Goal: Even n.totient
-- Nat.totient_mul
theorem totient_mul {m n : ℕ} (h : m.Coprime n) : φ (m * n) = φ m * φ n 
Arguments: {m n : ℕ} (h : m.Coprime n)
Goal: (m * n).totient = m.totient * n.totient
-- Nat.totient_div_of_dvd
theorem totient_div_of_dvd {n d : ℕ} (hnd : d ∣ n) :
    φ (n / d) = (filter (fun k : ℕ => n.gcd k = d) (range n)).card 
Arguments: {n d : ℕ} (hnd : d ∣ n)
Goal: (n / d).totient = (Finset.filter (fun k => n.gcd k = d) (Finset.range n)).card
-- Nat.sum_totient
theorem sum_totient (n : ℕ) : n.divisors.sum φ = n 
Arguments: (n : ℕ)
Goal: n.divisors.sum Nat.totient = n
-- Nat.sum_totient'
theorem sum_totient' (n : ℕ) : (∑ m ∈ (range n.succ).filter (· ∣ n), φ m) = n 
Arguments: (n : ℕ)
Goal: ∑ m ∈ Finset.filter (fun x => x ∣ n) (Finset.range n.succ), m.totient = n
-- Nat.totient_prime_pow_succ
theorem totient_prime_pow_succ {p : ℕ} (hp : p.Prime) (n : ℕ) : φ (p ^ (n + 1)) = p ^ n * (p - 1) 
Arguments: {p : ℕ} (hp : Nat.Prime p) (n : ℕ)
Goal: (p ^ (n + 1)).totient = p ^ n * (p - 1)
-- Nat.totient_prime_pow
theorem totient_prime_pow {p : ℕ} (hp : p.Prime) {n : ℕ} (hn : 0 < n) :
    φ (p ^ n) = p ^ (n - 1) * (p - 1) 
Arguments: {p : ℕ} (hp : Nat.Prime p) {n : ℕ} (hn : 0 < n)
Goal: (p ^ n).totient = p ^ (n - 1) * (p - 1)
-- Nat.totient_prime
theorem totient_prime {p : ℕ} (hp : p.Prime) : φ p = p - 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.totient = p - 1
-- Nat.totient_eq_iff_prime
theorem totient_eq_iff_prime {p : ℕ} (hp : 0 < p) : p.totient = p - 1 ↔ p.Prime 
Arguments: {p : ℕ} (hp : 0 < p)
Goal: p.totient = p - 1 ↔ Nat.Prime p
-- Nat.card_units_zmod_lt_sub_one
theorem card_units_zmod_lt_sub_one {p : ℕ} (hp : 1 < p) [Fintype (ZMod p)ˣ] :
    Fintype.card (ZMod p)ˣ ≤ p - 1 
Arguments: {p : ℕ} (hp : 1 < p) [Fintype (ZMod p)ˣ]
Goal: Fintype.card (ZMod p)ˣ ≤ p - 1
-- Nat.prime_iff_card_units
theorem prime_iff_card_units (p : ℕ) [Fintype (ZMod p)ˣ] :
    p.Prime ↔ Fintype.card (ZMod p)ˣ = p - 1 
Arguments: (p : ℕ) [Fintype (ZMod p)ˣ]
Goal: Nat.Prime p ↔ Fintype.card (ZMod p)ˣ = p - 1
-- Nat.totient_two
@[simp]
theorem totient_two : φ 2 = 1 
Goal: Nat.totient 2 = 1
-- Nat.totient_eq_one_iff
theorem totient_eq_one_iff : ∀ {n : ℕ}, n.totient = 1 ↔ n = 1 ∨ n = 2
  
Arguments: {n : ℕ}
Goal: n.totient = 1 ↔ n = 1 ∨ n = 2
-- Nat.dvd_two_of_totient_le_one
theorem dvd_two_of_totient_le_one {a : ℕ} (han : 0 < a) (ha : a.totient ≤ 1) : a ∣ 2 
Arguments: {a : ℕ} (han : 0 < a) (ha : a.totient ≤ 1)
Goal: a ∣ 2
-- Nat.totient_eq_prod_factorization
theorem totient_eq_prod_factorization {n : ℕ} (hn : n ≠ 0) :
    φ n = n.factorization.prod fun p k => p ^ (k - 1) * (p - 1) 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: n.totient = n.factorization.prod fun p k => p ^ (k - 1) * (p - 1)
-- Nat.totient_mul_prod_primeFactors
theorem totient_mul_prod_primeFactors (n : ℕ) :
    (φ n * ∏ p ∈ n.primeFactors, p) = n * ∏ p ∈ n.primeFactors, (p - 1) 
Arguments: (n : ℕ)
Goal: n.totient * ∏ p ∈ n.primeFactors, p = n * ∏ p ∈ n.primeFactors, (p - 1)
-- Nat.totient_eq_div_primeFactors_mul
theorem totient_eq_div_primeFactors_mul (n : ℕ) :
    φ n = (n / ∏ p ∈ n.primeFactors, p) * ∏ p ∈ n.primeFactors, (p - 1) 
Arguments: (n : ℕ)
Goal: n.totient = (n / ∏ p ∈ n.primeFactors, p) * ∏ p ∈ n.primeFactors, (p - 1)
-- Nat.totient_eq_mul_prod_factors
theorem totient_eq_mul_prod_factors (n : ℕ) :
    (φ n : ℚ) = n * ∏ p ∈ n.primeFactors, (1 - (p : ℚ)⁻¹) 
Arguments: (n : ℕ)
Goal: ↑n.totient = ↑n * ∏ p ∈ n.primeFactors, (1 - (↑p)⁻¹)
-- Nat.totient_gcd_mul_totient_mul
theorem totient_gcd_mul_totient_mul (a b : ℕ) : φ (a.gcd b) * φ (a * b) = φ a * φ b * a.gcd b 
Arguments: (a b : ℕ)
Goal: (a.gcd b).totient * (a * b).totient = a.totient * b.totient * a.gcd b
-- Nat.totient_super_multiplicative
theorem totient_super_multiplicative (a b : ℕ) : φ a * φ b ≤ φ (a * b) 
Arguments: (a b : ℕ)
Goal: a.totient * b.totient ≤ (a * b).totient
-- Nat.totient_dvd_of_dvd
theorem totient_dvd_of_dvd {a b : ℕ} (h : a ∣ b) : φ a ∣ φ b 
Arguments: {a b : ℕ} (h : a ∣ b)
Goal: a.totient ∣ b.totient
-- Nat.totient_mul_of_prime_of_dvd
theorem totient_mul_of_prime_of_dvd {p n : ℕ} (hp : p.Prime) (h : p ∣ n) :
    (p * n).totient = p * n.totient 
Arguments: {p n : ℕ} (hp : Nat.Prime p) (h : p ∣ n)
Goal: (p * n).totient = p * n.totient
-- Nat.totient_mul_of_prime_of_not_dvd
theorem totient_mul_of_prime_of_not_dvd {p n : ℕ} (hp : p.Prime) (h : ¬p ∣ n) :
    (p * n).totient = (p - 1) * n.totient 
Arguments: {p n : ℕ} (hp : Nat.Prime p) (h : ¬p ∣ n)
Goal: (p * n).totient = (p - 1) * n.totient
-- Real.IsConjExponent.inv_add_inv_conj
@[mk_iff]
structure IsConjExponent (p q : ℝ) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: {p q : ℝ} (self : p.IsConjExponent q)
Goal: p⁻¹ + q⁻¹ = 1
-- Real.IsConjExponent.one_lt
@[mk_iff]
structure IsConjExponent (p q : ℝ) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: {p q : ℝ} (self : p.IsConjExponent q)
Goal: 1 < p
-- Real.isConjExponent_iff
@[mk_iff]
structure IsConjExponent (p q : ℝ) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: (p q : ℝ)
Goal: p.IsConjExponent q ↔ 1 < p ∧ p⁻¹ + q⁻¹ = 1
-- Real.IsConjExponent.pos
theorem pos : 0 < p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 < p
-- Real.IsConjExponent.nonneg
theorem nonneg : 0 ≤ p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 ≤ p
-- Real.IsConjExponent.ne_zero
theorem ne_zero : p ≠ 0 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p ≠ 0
-- Real.IsConjExponent.sub_one_pos
theorem sub_one_pos : 0 < p - 1 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 < p - 1
-- Real.IsConjExponent.sub_one_ne_zero
theorem sub_one_ne_zero : p - 1 ≠ 0 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p - 1 ≠ 0
-- Real.IsConjExponent.inv_pos
protected lemma inv_pos : 0 < p⁻¹ 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 < p⁻¹
-- Real.IsConjExponent.inv_nonneg
protected lemma inv_nonneg : 0 ≤ p⁻¹ 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 ≤ p⁻¹
-- Real.IsConjExponent.inv_ne_zero
protected lemma inv_ne_zero : p⁻¹ ≠ 0 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p⁻¹ ≠ 0
-- Real.IsConjExponent.one_div_pos
theorem one_div_pos : 0 < 1 / p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 < 1 / p
-- Real.IsConjExponent.one_div_nonneg
theorem one_div_nonneg : 0 ≤ 1 / p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 0 ≤ 1 / p
-- Real.IsConjExponent.one_div_ne_zero
theorem one_div_ne_zero : 1 / p ≠ 0 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 1 / p ≠ 0
-- Real.IsConjExponent.conj_eq
theorem conj_eq (h : p.IsConjExponent q) : q = p / (p - 1) 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: q = p / (p - 1)
-- Real.IsConjExponent.conjExponent_eq
lemma conjExponent_eq : conjExponent p = q 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p.conjExponent = q
-- Real.IsConjExponent.one_sub_inv
lemma one_sub_inv : 1 - p⁻¹ = q⁻¹ 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: 1 - p⁻¹ = q⁻¹
-- Real.IsConjExponent.inv_sub_one
lemma inv_sub_one : p⁻¹ - 1 = -q⁻¹ 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p⁻¹ - 1 = -q⁻¹
-- Real.IsConjExponent.sub_one_mul_conj
theorem sub_one_mul_conj : (p - 1) * q = p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: (p - 1) * q = p
-- Real.IsConjExponent.mul_eq_add
theorem mul_eq_add : p * q = p + q 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p * q = p + q
-- Real.IsConjExponent.symm
@[symm] protected lemma symm (h : p.IsConjExponent q) : q.IsConjExponent p 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: q.IsConjExponent p
-- Real.IsConjExponent.div_conj_eq_sub_one
theorem div_conj_eq_sub_one : p / q = p - 1 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: p / q = p - 1
-- Real.IsConjExponent.inv_add_inv_conj_ennreal
theorem inv_add_inv_conj_ennreal : (ENNReal.ofReal p)⁻¹ + (ENNReal.ofReal q)⁻¹ = 1 
Arguments: {p q : ℝ} (h : p.IsConjExponent q)
Goal: (ENNReal.ofReal p)⁻¹ + (ENNReal.ofReal q)⁻¹ = 1
-- Real.IsConjExponent.inv_inv
protected lemma inv_inv (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) : a⁻¹.IsConjExponent b⁻¹ 
Arguments: {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1)
Goal: a⁻¹.IsConjExponent b⁻¹
-- Real.IsConjExponent.inv_one_sub_inv
lemma inv_one_sub_inv (ha₀ : 0 < a) (ha₁ : a < 1) : a⁻¹.IsConjExponent (1 - a)⁻¹ 
Arguments: {a : ℝ} (ha₀ : 0 < a) (ha₁ : a < 1)
Goal: a⁻¹.IsConjExponent (1 - a)⁻¹
-- Real.IsConjExponent.one_sub_inv_inv
lemma one_sub_inv_inv (ha₀ : 0 < a) (ha₁ : a < 1) : (1 - a)⁻¹.IsConjExponent a⁻¹ 
Arguments: {a : ℝ} (ha₀ : 0 < a) (ha₁ : a < 1)
Goal: (1 - a)⁻¹.IsConjExponent a⁻¹
-- Real.isConjExponent_iff_eq_conjExponent
lemma isConjExponent_iff_eq_conjExponent (hp : 1 < p) : p.IsConjExponent q ↔ q = p / (p - 1) 
Arguments: {p q : ℝ} (hp : 1 < p)
Goal: p.IsConjExponent q ↔ q = p / (p - 1)
-- Real.IsConjExponent.conjExponent
lemma IsConjExponent.conjExponent (h : 1 < p) : p.IsConjExponent (conjExponent p) 
Arguments: {p : ℝ} (h : 1 < p)
Goal: p.IsConjExponent p.conjExponent
-- Real.isConjExponent_one_div
lemma isConjExponent_one_div (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
    (1 / a).IsConjExponent (1 / b) 
Arguments: {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1)
Goal: (1 / a).IsConjExponent (1 / b)
-- NNReal.isConjExponent_iff
@[mk_iff]
structure IsConjExponent (p q : ℝ≥0) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: (p q : NNReal)
Goal: p.IsConjExponent q ↔ 1 < p ∧ p⁻¹ + q⁻¹ = 1
-- NNReal.IsConjExponent.inv_add_inv_conj
@[mk_iff]
structure IsConjExponent (p q : ℝ≥0) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: {p q : NNReal} (self : p.IsConjExponent q)
Goal: p⁻¹ + q⁻¹ = 1
-- NNReal.IsConjExponent.one_lt
@[mk_iff]
structure IsConjExponent (p q : ℝ≥0) : Prop where
  one_lt : 1 < p
  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
Arguments: {p q : NNReal} (self : p.IsConjExponent q)
Goal: 1 < p
-- NNReal.isConjExponent_coe
@[simp, norm_cast] lemma isConjExponent_coe : (p : ℝ).IsConjExponent q ↔ p.IsConjExponent q 
Arguments: {p q : NNReal}
Goal: (↑p).IsConjExponent ↑q ↔ p.IsConjExponent q
-- NNReal.IsConjExponent.one_le
lemma one_le : 1 ≤ p 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: 1 ≤ p
-- NNReal.IsConjExponent.pos
lemma pos : 0 < p 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: 0 < p
-- NNReal.IsConjExponent.ne_zero
lemma ne_zero : p ≠ 0 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p ≠ 0
-- NNReal.IsConjExponent.sub_one_pos
lemma sub_one_pos : 0 < p - 1 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: 0 < p - 1
-- NNReal.IsConjExponent.sub_one_ne_zero
lemma sub_one_ne_zero : p - 1 ≠ 0 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p - 1 ≠ 0
-- NNReal.IsConjExponent.inv_pos
lemma inv_pos : 0 < p⁻¹ 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: 0 < p⁻¹
-- NNReal.IsConjExponent.inv_ne_zero
lemma inv_ne_zero : p⁻¹ ≠ 0 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p⁻¹ ≠ 0
-- NNReal.IsConjExponent.one_sub_inv
lemma one_sub_inv : 1 - p⁻¹ = q⁻¹ 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: 1 - p⁻¹ = q⁻¹
-- NNReal.IsConjExponent.conj_eq
lemma conj_eq (h : p.IsConjExponent q) : q = p / (p - 1) 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: q = p / (p - 1)
-- NNReal.IsConjExponent.conjExponent_eq
lemma conjExponent_eq : conjExponent p = q 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p.conjExponent = q
-- NNReal.IsConjExponent.sub_one_mul_conj
lemma sub_one_mul_conj : (p - 1) * q = p 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: (p - 1) * q = p
-- NNReal.IsConjExponent.mul_eq_add
lemma mul_eq_add : p * q = p + q 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p * q = p + q
-- NNReal.IsConjExponent.symm
@[symm]
protected lemma symm (h : p.IsConjExponent q) : q.IsConjExponent p 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: q.IsConjExponent p
-- NNReal.IsConjExponent.div_conj_eq_sub_one
lemma div_conj_eq_sub_one : p / q = p - 1 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: p / q = p - 1
-- NNReal.IsConjExponent.inv_add_inv_conj_ennreal
lemma inv_add_inv_conj_ennreal : (p⁻¹ + q⁻¹ : ℝ≥0∞) = 1 
Arguments: {p q : NNReal} (h : p.IsConjExponent q)
Goal: ↑p⁻¹ + ↑q⁻¹ = 1
-- NNReal.IsConjExponent.inv_inv
protected lemma inv_inv (ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b = 1) :
    a⁻¹.IsConjExponent b⁻¹ 
Arguments: {a b : NNReal} (ha : a ≠ 0) (hb : b ≠ 0) (hab : a + b = 1)
Goal: a⁻¹.IsConjExponent b⁻¹
-- NNReal.IsConjExponent.inv_one_sub_inv
lemma inv_one_sub_inv (ha₀ : a ≠ 0) (ha₁ : a < 1) : a⁻¹.IsConjExponent (1 - a)⁻¹ 
Arguments: {a : NNReal} (ha₀ : a ≠ 0) (ha₁ : a < 1)
Goal: a⁻¹.IsConjExponent (1 - a)⁻¹
-- NNReal.IsConjExponent.one_sub_inv_inv
lemma one_sub_inv_inv (ha₀ : a ≠ 0) (ha₁ : a < 1) : (1 - a)⁻¹.IsConjExponent a⁻¹ 
Arguments: {a : NNReal} (ha₀ : a ≠ 0) (ha₁ : a < 1)
Goal: (1 - a)⁻¹.IsConjExponent a⁻¹
-- NNReal.isConjExponent_iff_eq_conjExponent
lemma isConjExponent_iff_eq_conjExponent (h : 1 < p) : p.IsConjExponent q ↔ q = p / (p - 1) 
Arguments: {p q : NNReal} (h : 1 < p)
Goal: p.IsConjExponent q ↔ q = p / (p - 1)
-- NNReal.IsConjExponent.conjExponent
protected lemma IsConjExponent.conjExponent (h : 1 < p) : p.IsConjExponent (conjExponent p) 
Arguments: {p : NNReal} (h : 1 < p)
Goal: p.IsConjExponent p.conjExponent