ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.digits_ofDigits
theorem digits_ofDigits (b : ℕ) (h : 1 < b) (L : List ℕ) (w₁ : ∀ l ∈ L, l < b)
    (w₂ : ∀ h : L ≠ [], L.getLast h ≠ 0) : digits b (ofDigits b L) = L 
Arguments: (b : ℕ) (h : 1 < b) (L : List ℕ) (w₁ : ∀ l ∈ L, l < b) (w₂ : ∀ (h : L ≠ []), L.getLast h ≠ 0)
Goal: b.digits (Nat.ofDigits b L) = L
-- Nat.ofDigits_digits
theorem ofDigits_digits (b n : ℕ) : ofDigits b (digits b n) = n 
Arguments: (b n : ℕ)
Goal: Nat.ofDigits b (b.digits n) = n
-- Nat.ofDigits_one
theorem ofDigits_one (L : List ℕ) : ofDigits 1 L = L.sum 
Arguments: (L : List ℕ)
Goal: Nat.ofDigits 1 L = L.sum
-- Nat.digits_eq_nil_iff_eq_zero
theorem digits_eq_nil_iff_eq_zero {b n : ℕ} : digits b n = [] ↔ n = 0 
Arguments: {b n : ℕ}
Goal: b.digits n = [] ↔ n = 0
-- Nat.digits_ne_nil_iff_ne_zero
theorem digits_ne_nil_iff_ne_zero {b n : ℕ} : digits b n ≠ [] ↔ n ≠ 0 
Arguments: {b n : ℕ}
Goal: b.digits n ≠ [] ↔ n ≠ 0
-- Nat.digits_eq_cons_digits_div
theorem digits_eq_cons_digits_div {b n : ℕ} (h : 1 < b) (w : n ≠ 0) :
    digits b n = (n % b) :: digits b (n / b) 
Arguments: {b n : ℕ} (h : 1 < b) (w : n ≠ 0)
Goal: b.digits n = n % b :: b.digits (n / b)
-- Nat.digits_getLast
theorem digits_getLast {b : ℕ} (m : ℕ) (h : 1 < b) (p q) :
    (digits b m).getLast p = (digits b (m / b)).getLast q 
Arguments: {b : ℕ} (m : ℕ) (h : 1 < b) (p : b.digits m ≠ []) (q : b.digits (m / b) ≠ [])
Goal: (b.digits m).getLast p = (b.digits (m / b)).getLast q
-- Nat.digits.injective
theorem digits.injective (b : ℕ) : Function.Injective b.digits 
Arguments: (b : ℕ)
Goal: Function.Injective b.digits
-- Nat.digits_inj_iff
@[simp]
theorem digits_inj_iff {b n m : ℕ} : b.digits n = b.digits m ↔ n = m 
Arguments: {b n m : ℕ}
Goal: b.digits n = b.digits m ↔ n = m
-- Nat.digits_len
theorem digits_len (b n : ℕ) (hb : 1 < b) (hn : n ≠ 0) : (b.digits n).length = b.log n + 1 
Arguments: (b n : ℕ) (hb : 1 < b) (hn : n ≠ 0)
Goal: (b.digits n).length = Nat.log b n + 1
-- Nat.getLast_digit_ne_zero
theorem getLast_digit_ne_zero (b : ℕ) {m : ℕ} (hm : m ≠ 0) :
    (digits b m).getLast (digits_ne_nil_iff_ne_zero.mpr hm) ≠ 0 
Arguments: (b : ℕ) {m : ℕ} (hm : m ≠ 0)
Goal: (b.digits m).getLast ⋯ ≠ 0
-- Nat.mul_ofDigits
theorem mul_ofDigits (n : ℕ) {b : ℕ} {l : List ℕ} :
    n * ofDigits b l = ofDigits b (l.map (n * ·)) 
Arguments: (n : ℕ) {b : ℕ} {l : List ℕ}
Goal: n * Nat.ofDigits b l = Nat.ofDigits b (List.map (fun x => n * x) l)
-- Nat.ofDigits_add_ofDigits_eq_ofDigits_zipWith_of_length_eq
theorem ofDigits_add_ofDigits_eq_ofDigits_zipWith_of_length_eq {b : ℕ} {l1 l2 : List ℕ}
    (h : l1.length = l2.length) :
    ofDigits b l1 + ofDigits b l2 = ofDigits b (l1.zipWith (· + ·) l2) 
Arguments: {b : ℕ} {l1 l2 : List ℕ} (h : l1.length = l2.length)
Goal: Nat.ofDigits b l1 + Nat.ofDigits b l2 = Nat.ofDigits b (List.zipWith (fun x x_1 => x + x_1) l1 l2)
-- Nat.digits_lt_base'
theorem digits_lt_base' {b m : ℕ} : ∀ {d}, d ∈ digits (b + 2) m → d < b + 2 
Arguments: {b m d : ℕ}
Goal: d ∈ (b + 2).digits m → d < b + 2
-- Nat.digits_lt_base
theorem digits_lt_base {b m d : ℕ} (hb : 1 < b) (hd : d ∈ digits b m) : d < b 
Arguments: {b m d : ℕ} (hb : 1 < b) (hd : d ∈ b.digits m)
Goal: d < b
-- Nat.ofDigits_lt_base_pow_length'
theorem ofDigits_lt_base_pow_length' {b : ℕ} {l : List ℕ} (hl : ∀ x ∈ l, x < b + 2) :
    ofDigits (b + 2) l < (b + 2) ^ l.length 
Arguments: {b : ℕ} {l : List ℕ} (hl : ∀ x ∈ l, x < b + 2)
Goal: Nat.ofDigits (b + 2) l < (b + 2) ^ l.length
-- Nat.ofDigits_lt_base_pow_length
theorem ofDigits_lt_base_pow_length {b : ℕ} {l : List ℕ} (hb : 1 < b) (hl : ∀ x ∈ l, x < b) :
    ofDigits b l < b ^ l.length 
Arguments: {b : ℕ} {l : List ℕ} (hb : 1 < b) (hl : ∀ x ∈ l, x < b)
Goal: Nat.ofDigits b l < b ^ l.length
-- Nat.lt_base_pow_length_digits'
theorem lt_base_pow_length_digits' {b m : ℕ} : m < (b + 2) ^ (digits (b + 2) m).length 
Arguments: {b m : ℕ}
Goal: m < (b + 2) ^ ((b + 2).digits m).length
-- Nat.lt_base_pow_length_digits
theorem lt_base_pow_length_digits {b m : ℕ} (hb : 1 < b) : m < b ^ (digits b m).length 
Arguments: {b m : ℕ} (hb : 1 < b)
Goal: m < b ^ (b.digits m).length
-- Nat.ofDigits_digits_append_digits
theorem ofDigits_digits_append_digits {b m n : ℕ} :
    ofDigits b (digits b n ++ digits b m) = n + b ^ (digits b n).length * m 
Arguments: {b m n : ℕ}
Goal: Nat.ofDigits b (b.digits n ++ b.digits m) = n + b ^ (b.digits n).length * m
-- Nat.digits_append_digits
theorem digits_append_digits {b m n : ℕ} (hb : 0 < b) :
    digits b n ++ digits b m = digits b (n + b ^ (digits b n).length * m) 
Arguments: {b m n : ℕ} (hb : 0 < b)
Goal: b.digits n ++ b.digits m = b.digits (n + b ^ (b.digits n).length * m)
-- Nat.digits_len_le_digits_len_succ
theorem digits_len_le_digits_len_succ (b n : ℕ) :
    (digits b n).length ≤ (digits b (n + 1)).length 
Arguments: (b n : ℕ)
Goal: (b.digits n).length ≤ (b.digits (n + 1)).length
-- Nat.le_digits_len_le
theorem le_digits_len_le (b n m : ℕ) (h : n ≤ m) : (digits b n).length ≤ (digits b m).length 
Arguments: (b n m : ℕ) (h : n ≤ m)
Goal: (b.digits n).length ≤ (b.digits m).length
-- Nat.ofDigits_monotone
@[mono]
theorem ofDigits_monotone {p q : ℕ} (L : List ℕ) (h : p ≤ q) : ofDigits p L ≤ ofDigits q L 
Arguments: {p q : ℕ} (L : List ℕ) (h : p ≤ q)
Goal: Nat.ofDigits p L ≤ Nat.ofDigits q L
-- Nat.sum_le_ofDigits
theorem sum_le_ofDigits {p : ℕ} (L : List ℕ) (h : 1 ≤ p) : L.sum ≤ ofDigits p L 
Arguments: {p : ℕ} (L : List ℕ) (h : 1 ≤ p)
Goal: L.sum ≤ Nat.ofDigits p L
-- Nat.digit_sum_le
theorem digit_sum_le (p n : ℕ) : List.sum (digits p n) ≤ n 
Arguments: (p n : ℕ)
Goal: (p.digits n).sum ≤ n
-- Nat.pow_length_le_mul_ofDigits
theorem pow_length_le_mul_ofDigits {b : ℕ} {l : List ℕ} (hl : l ≠ []) (hl2 : l.getLast hl ≠ 0) :
    (b + 2) ^ l.length ≤ (b + 2) * ofDigits (b + 2) l 
Arguments: {b : ℕ} {l : List ℕ} (hl : l ≠ []) (hl2 : l.getLast hl ≠ 0)
Goal: (b + 2) ^ l.length ≤ (b + 2) * Nat.ofDigits (b + 2) l
-- Nat.base_pow_length_digits_le'
theorem base_pow_length_digits_le' (b m : ℕ) (hm : m ≠ 0) :
    (b + 2) ^ (digits (b + 2) m).length ≤ (b + 2) * m 
Arguments: (b m : ℕ) (hm : m ≠ 0)
Goal: (b + 2) ^ ((b + 2).digits m).length ≤ (b + 2) * m
-- Nat.base_pow_length_digits_le
theorem base_pow_length_digits_le (b m : ℕ) (hb : 1 < b) :
    m ≠ 0 → b ^ (digits b m).length ≤ b * m 
Arguments: (b m : ℕ) (hb : 1 < b)
Goal: m ≠ 0 → b ^ (b.digits m).length ≤ b * m
-- Nat.ofDigits_div_eq_ofDigits_tail
lemma ofDigits_div_eq_ofDigits_tail {p : ℕ} (hpos : 0 < p) (digits : List ℕ)
    (w₁ : ∀ l ∈ digits, l < p) : ofDigits p digits / p = ofDigits p digits.tail 
Arguments: {p : ℕ} (hpos : 0 < p) (digits : List ℕ) (w₁ : ∀ l ∈ digits, l < p)
Goal: Nat.ofDigits p digits / p = Nat.ofDigits p digits.tail
-- Nat.ofDigits_div_pow_eq_ofDigits_drop
lemma ofDigits_div_pow_eq_ofDigits_drop
    {p : ℕ} (i : ℕ) (hpos : 0 < p) (digits : List ℕ) (w₁ : ∀ l ∈ digits, l < p) :
    ofDigits p digits / p ^ i = ofDigits p (digits.drop i) 
Arguments: {p : ℕ} (i : ℕ) (hpos : 0 < p) (digits : List ℕ) (w₁ : ∀ l ∈ digits, l < p)
Goal: Nat.ofDigits p digits / p ^ i = Nat.ofDigits p (List.drop i digits)
-- Nat.self_div_pow_eq_ofDigits_drop
lemma self_div_pow_eq_ofDigits_drop {p : ℕ} (i n : ℕ) (h : 2 ≤ p) :
    n / p ^ i = ofDigits p ((p.digits n).drop i) 
Arguments: {p : ℕ} (i n : ℕ) (h : 2 ≤ p)
Goal: n / p ^ i = Nat.ofDigits p (List.drop i (p.digits n))
-- Nat.sub_one_mul_sum_div_pow_eq_sub_sum_digits
theorem sub_one_mul_sum_div_pow_eq_sub_sum_digits {p : ℕ}
    (L : List ℕ) {h_nonempty} (h_ne_zero : L.getLast h_nonempty ≠ 0) (h_lt : ∀ l ∈ L, l < p) :
    (p - 1) * ∑ i ∈ range L.length, (ofDigits p L) / p ^ i.succ = (ofDigits p L) - L.sum 
Arguments: {p : ℕ} (L : List ℕ) {h_nonempty : L ≠ []} (h_ne_zero : L.getLast h_nonempty ≠ 0) (h_lt : ∀ l ∈ L, l < p)
Goal: (p - 1) * ∑ i ∈ Finset.range L.length, Nat.ofDigits p L / p ^ i.succ = Nat.ofDigits p L - L.sum
-- Nat.sub_one_mul_sum_log_div_pow_eq_sub_sum_digits
theorem sub_one_mul_sum_log_div_pow_eq_sub_sum_digits {p : ℕ} (n : ℕ) :
    (p - 1) * ∑ i ∈ range (log p n).succ, n / p ^ i.succ = n - (p.digits n).sum 
Arguments: {p : ℕ} (n : ℕ)
Goal: (p - 1) * ∑ i ∈ Finset.range (Nat.log p n).succ, n / p ^ i.succ = n - (p.digits n).sum
-- Nat.digits_two_eq_bits
theorem digits_two_eq_bits (n : ℕ) : digits 2 n = n.bits.map fun b => cond b 1 0 
Arguments: (n : ℕ)
Goal: Nat.digits 2 n = List.map (fun b => bif b then 1 else 0) n.bits
-- Nat.dvd_ofDigits_sub_ofDigits
theorem dvd_ofDigits_sub_ofDigits {α : Type*} [CommRing α] {a b k : α} (h : k ∣ a - b)
    (L : List ℕ) : k ∣ ofDigits a L - ofDigits b L 
Arguments: {α : Type u_1} [CommRing α] {a b k : α} (h : k ∣ a - b) (L : List ℕ)
Goal: k ∣ Nat.ofDigits a L - Nat.ofDigits b L
-- Nat.ofDigits_modEq'
theorem ofDigits_modEq' (b b' : ℕ) (k : ℕ) (h : b ≡ b' [MOD k]) (L : List ℕ) :
    ofDigits b L ≡ ofDigits b' L [MOD k] 
Arguments: (b b' k : ℕ) (h : b ≡ b' [MOD k]) (L : List ℕ)
Goal: Nat.ofDigits b L ≡ Nat.ofDigits b' L [MOD k]
-- Nat.ofDigits_modEq
theorem ofDigits_modEq (b k : ℕ) (L : List ℕ) : ofDigits b L ≡ ofDigits (b % k) L [MOD k] 
Arguments: (b k : ℕ) (L : List ℕ)
Goal: Nat.ofDigits b L ≡ Nat.ofDigits (b % k) L [MOD k]
-- Nat.ofDigits_mod
theorem ofDigits_mod (b k : ℕ) (L : List ℕ) : ofDigits b L % k = ofDigits (b % k) L % k 
Arguments: (b k : ℕ) (L : List ℕ)
Goal: Nat.ofDigits b L % k = Nat.ofDigits (b % k) L % k
-- Nat.ofDigits_mod_eq_head!
theorem ofDigits_mod_eq_head! (b : ℕ) (l : List ℕ) : ofDigits b l % b = l.head! % b 
Arguments: (b : ℕ) (l : List ℕ)
Goal: Nat.ofDigits b l % b = l.head! % b
-- Nat.head!_digits
theorem head!_digits {b n : ℕ} (h : b ≠ 1) : (Nat.digits b n).head! = n % b 
Arguments: {b n : ℕ} (h : b ≠ 1)
Goal: (b.digits n).head! = n % b
-- Nat.ofDigits_zmodeq'
theorem ofDigits_zmodeq' (b b' : ℤ) (k : ℕ) (h : b ≡ b' [ZMOD k]) (L : List ℕ) :
    ofDigits b L ≡ ofDigits b' L [ZMOD k] 
Arguments: (b b' : ℤ) (k : ℕ) (h : b ≡ b' [ZMOD ↑k]) (L : List ℕ)
Goal: Nat.ofDigits b L ≡ Nat.ofDigits b' L [ZMOD ↑k]
-- Nat.ofDigits_zmodeq
theorem ofDigits_zmodeq (b : ℤ) (k : ℕ) (L : List ℕ) : ofDigits b L ≡ ofDigits (b % k) L [ZMOD k] 
Arguments: (b : ℤ) (k : ℕ) (L : List ℕ)
Goal: Nat.ofDigits b L ≡ Nat.ofDigits (b % ↑k) L [ZMOD ↑k]
-- Nat.ofDigits_zmod
theorem ofDigits_zmod (b : ℤ) (k : ℕ) (L : List ℕ) : ofDigits b L % k = ofDigits (b % k) L % k 
Arguments: (b : ℤ) (k : ℕ) (L : List ℕ)
Goal: Nat.ofDigits b L % ↑k = Nat.ofDigits (b % ↑k) L % ↑k
-- Nat.modEq_digits_sum
theorem modEq_digits_sum (b b' : ℕ) (h : b' % b = 1) (n : ℕ) : n ≡ (digits b' n).sum [MOD b] 
Arguments: (b b' : ℕ) (h : b' % b = 1) (n : ℕ)
Goal: n ≡ (b'.digits n).sum [MOD b]
-- Nat.modEq_three_digits_sum
theorem modEq_three_digits_sum (n : ℕ) : n ≡ (digits 10 n).sum [MOD 3] 
Arguments: (n : ℕ)
Goal: n ≡ (Nat.digits 10 n).sum [MOD 3]
-- Nat.modEq_nine_digits_sum
theorem modEq_nine_digits_sum (n : ℕ) : n ≡ (digits 10 n).sum [MOD 9] 
Arguments: (n : ℕ)
Goal: n ≡ (Nat.digits 10 n).sum [MOD 9]
-- Nat.zmodeq_ofDigits_digits
theorem zmodeq_ofDigits_digits (b b' : ℕ) (c : ℤ) (h : b' ≡ c [ZMOD b]) (n : ℕ) :
    n ≡ ofDigits c (digits b' n) [ZMOD b] 
Arguments: (b b' : ℕ) (c : ℤ) (h : ↑b' ≡ c [ZMOD ↑b]) (n : ℕ)
Goal: ↑n ≡ Nat.ofDigits c (b'.digits n) [ZMOD ↑b]
-- Nat.ofDigits_neg_one
theorem ofDigits_neg_one :
    ∀ L : List ℕ, ofDigits (-1 : ℤ) L = (L.map fun n : ℕ => (n : ℤ)).alternatingSum
  
Arguments: (L : List ℕ)
Goal: Nat.ofDigits (-1) L = (List.map (fun n => ↑n) L).alternatingSum
-- Nat.modEq_eleven_digits_sum
theorem modEq_eleven_digits_sum (n : ℕ) :
    n ≡ ((digits 10 n).map fun n : ℕ => (n : ℤ)).alternatingSum [ZMOD 11] 
Arguments: (n : ℕ)
Goal: ↑n ≡ (List.map (fun n => ↑n) (Nat.digits 10 n)).alternatingSum [ZMOD 11]
-- Nat.dvd_iff_dvd_digits_sum
theorem dvd_iff_dvd_digits_sum (b b' : ℕ) (h : b' % b = 1) (n : ℕ) :
    b ∣ n ↔ b ∣ (digits b' n).sum 
Arguments: (b b' : ℕ) (h : b' % b = 1) (n : ℕ)
Goal: b ∣ n ↔ b ∣ (b'.digits n).sum
-- Nat.three_dvd_iff
theorem three_dvd_iff (n : ℕ) : 3 ∣ n ↔ 3 ∣ (digits 10 n).sum 
Arguments: (n : ℕ)
Goal: 3 ∣ n ↔ 3 ∣ (Nat.digits 10 n).sum
-- Nat.nine_dvd_iff
theorem nine_dvd_iff (n : ℕ) : 9 ∣ n ↔ 9 ∣ (digits 10 n).sum 
Arguments: (n : ℕ)
Goal: 9 ∣ n ↔ 9 ∣ (Nat.digits 10 n).sum
-- Nat.dvd_iff_dvd_ofDigits
theorem dvd_iff_dvd_ofDigits (b b' : ℕ) (c : ℤ) (h : (b : ℤ) ∣ (b' : ℤ) - c) (n : ℕ) :
    b ∣ n ↔ (b : ℤ) ∣ ofDigits c (digits b' n) 
Arguments: (b b' : ℕ) (c : ℤ) (h : ↑b ∣ ↑b' - c) (n : ℕ)
Goal: b ∣ n ↔ ↑b ∣ Nat.ofDigits c (b'.digits n)
-- Nat.eleven_dvd_iff
theorem eleven_dvd_iff :
    11 ∣ n ↔ (11 : ℤ) ∣ ((digits 10 n).map fun n : ℕ => (n : ℤ)).alternatingSum 
Arguments: {n : ℕ}
Goal: 11 ∣ n ↔ 11 ∣ (List.map (fun n => ↑n) (Nat.digits 10 n)).alternatingSum
-- Nat.eleven_dvd_of_palindrome
theorem eleven_dvd_of_palindrome (p : (digits 10 n).Palindrome) (h : Even (digits 10 n).length) :
    11 ∣ n 
Arguments: {n : ℕ} (p : (Nat.digits 10 n).Palindrome) (h : Even (Nat.digits 10 n).length)
Goal: 11 ∣ n
-- Nat.toDigitsCore_lens_eq_aux
lemma toDigitsCore_lens_eq_aux (b f : Nat) :
    ∀ (n : Nat) (l1 l2 : List Char), l1.length = l2.length →
    (Nat.toDigitsCore b f n l1).length = (Nat.toDigitsCore b f n l2).length 
Arguments: (b f n : ℕ) (l1 l2 : List Char)
Goal: l1.length = l2.length → (b.toDigitsCore f n l1).length = (b.toDigitsCore f n l2).length
-- Nat.toDigitsCore_lens_eq
lemma toDigitsCore_lens_eq (b f : Nat) : ∀ (n : Nat) (c : Char) (tl : List Char),
    (Nat.toDigitsCore b f n (c :: tl)).length = (Nat.toDigitsCore b f n tl).length + 1 
Arguments: (b f n : ℕ) (c : Char) (tl : List Char)
Goal: (b.toDigitsCore f n (c :: tl)).length = (b.toDigitsCore f n tl).length + 1
-- Nat.nat_repr_len_aux
lemma nat_repr_len_aux (n b e : Nat) (h_b_pos : 0 < b) :  n < b ^ e.succ → n / b < b ^ e 
Arguments: (n b e : ℕ) (h_b_pos : 0 < b)
Goal: n < b ^ e.succ → n / b < b ^ e
-- Nat.toDigitsCore_length
lemma toDigitsCore_length (b : Nat) (h : 2 <= b) (f n e : Nat)
    (hlt : n < b ^ e) (h_e_pos : 0 < e) : (Nat.toDigitsCore b f n []).length <= e 
Arguments: (b : ℕ) (h : 2 ≤ b) (f n e : ℕ) (hlt : n < b ^ e) (h_e_pos : 0 < e)
Goal: (b.toDigitsCore f n []).length ≤ e
-- Nat.repr_length
lemma repr_length (n e : Nat) : 0 < e → n < 10 ^ e → (Nat.repr n).length <= e 
Arguments: (n e : ℕ)
Goal: 0 < e → n < 10 ^ e → n.repr.length ≤ e
-- Nat.NormDigits.digits_succ
theorem digits_succ (b n m r l) (e : r + b * m = n) (hr : r < b)
    (h : Nat.digits b m = l ∧ 1 < b ∧ 0 < m) : (Nat.digits b n = r :: l) ∧ 1 < b ∧ 0 < n 
Arguments: (b n m r : ℕ) (l : List ℕ) (e : r + b * m = n) (hr : r < b) (h : b.digits m = l ∧ 1 < b ∧ 0 < m)
Goal: b.digits n = r :: l ∧ 1 < b ∧ 0 < n
-- Nat.NormDigits.digits_one
theorem digits_one (b n) (n0 : 0 < n) (nb : n < b) : Nat.digits b n = [n] ∧ 1 < b ∧ 0 < n 
Arguments: (b n : ℕ) (n0 : 0 < n) (nb : n < b)
Goal: b.digits n = [n] ∧ 1 < b ∧ 0 < n
-- NNReal.sq_sqrt
@[simp] lemma sq_sqrt (x : ℝ≥0) : sqrt x ^ 2 = x 
Arguments: (x : ℝ≥0)
Goal: NNReal.sqrt x ^ 2 = x
-- NNReal.sqrt_sq
@[simp] lemma sqrt_sq (x : ℝ≥0) : sqrt (x ^ 2) = x 
Arguments: (x : ℝ≥0)
Goal: NNReal.sqrt (x ^ 2) = x
-- NNReal.mul_self_sqrt
@[simp] lemma mul_self_sqrt (x : ℝ≥0) : sqrt x * sqrt x = x 
Arguments: (x : ℝ≥0)
Goal: NNReal.sqrt x * NNReal.sqrt x = x
-- NNReal.sqrt_mul_self
@[simp] lemma sqrt_mul_self (x : ℝ≥0) : sqrt (x * x) = x 
Arguments: (x : ℝ≥0)
Goal: NNReal.sqrt (x * x) = x
-- NNReal.sqrt_le_sqrt
lemma sqrt_le_sqrt : sqrt x ≤ sqrt y ↔ x ≤ y 
Arguments: {x y : ℝ≥0}
Goal: NNReal.sqrt x ≤ NNReal.sqrt y ↔ x ≤ y
-- NNReal.sqrt_lt_sqrt
lemma sqrt_lt_sqrt : sqrt x < sqrt y ↔ x < y 
Arguments: {x y : ℝ≥0}
Goal: NNReal.sqrt x < NNReal.sqrt y ↔ x < y
-- NNReal.sqrt_eq_iff_eq_sq
lemma sqrt_eq_iff_eq_sq : sqrt x = y ↔ x = y ^ 2 
Arguments: {x y : ℝ≥0}
Goal: NNReal.sqrt x = y ↔ x = y ^ 2
-- NNReal.sqrt_le_iff_le_sq
lemma sqrt_le_iff_le_sq : sqrt x ≤ y ↔ x ≤ y ^ 2 
Arguments: {x y : ℝ≥0}
Goal: NNReal.sqrt x ≤ y ↔ x ≤ y ^ 2
-- NNReal.le_sqrt_iff_sq_le
lemma le_sqrt_iff_sq_le : x ≤ sqrt y ↔ x ^ 2 ≤ y 
Arguments: {x y : ℝ≥0}
Goal: x ≤ NNReal.sqrt y ↔ x ^ 2 ≤ y
-- NNReal.sqrt_eq_zero
@[simp] lemma sqrt_eq_zero : sqrt x = 0 ↔ x = 0 
Arguments: {x : ℝ≥0}
Goal: NNReal.sqrt x = 0 ↔ x = 0
-- NNReal.sqrt_eq_one
@[simp] lemma sqrt_eq_one : sqrt x = 1 ↔ x = 1 
Arguments: {x : ℝ≥0}
Goal: NNReal.sqrt x = 1 ↔ x = 1
-- NNReal.sqrt_zero
@[simp] lemma sqrt_zero : sqrt 0 = 0 
Goal: NNReal.sqrt 0 = 0
-- NNReal.sqrt_one
@[simp] lemma sqrt_one : sqrt 1 = 1 
Goal: NNReal.sqrt 1 = 1
-- NNReal.sqrt_le_one
@[simp] lemma sqrt_le_one : sqrt x ≤ 1 ↔ x ≤ 1 
Arguments: {x : ℝ≥0}
Goal: NNReal.sqrt x ≤ 1 ↔ x ≤ 1
-- NNReal.one_le_sqrt
@[simp] lemma one_le_sqrt : 1 ≤ sqrt x ↔ 1 ≤ x 
Arguments: {x : ℝ≥0}
Goal: 1 ≤ NNReal.sqrt x ↔ 1 ≤ x
-- NNReal.sqrt_mul
theorem sqrt_mul (x y : ℝ≥0) : sqrt (x * y) = sqrt x * sqrt y 
Arguments: (x y : ℝ≥0)
Goal: NNReal.sqrt (x * y) = NNReal.sqrt x * NNReal.sqrt y
-- NNReal.sqrt_inv
theorem sqrt_inv (x : ℝ≥0) : sqrt x⁻¹ = (sqrt x)⁻¹ 
Arguments: (x : ℝ≥0)
Goal: NNReal.sqrt x⁻¹ = (NNReal.sqrt x)⁻¹
-- NNReal.sqrt_div
theorem sqrt_div (x y : ℝ≥0) : sqrt (x / y) = sqrt x / sqrt y 
Arguments: (x y : ℝ≥0)
Goal: NNReal.sqrt (x / y) = NNReal.sqrt x / NNReal.sqrt y
-- NNReal.continuous_sqrt
@[continuity, fun_prop]
theorem continuous_sqrt : Continuous sqrt 
Goal: Continuous ⇑NNReal.sqrt
-- NNReal.sqrt_pos
@[simp] theorem sqrt_pos : 0 < sqrt x ↔ 0 < x 
Arguments: {x : ℝ≥0}
Goal: 0 < NNReal.sqrt x ↔ 0 < x
-- Real.coe_sqrt
@[simp, norm_cast]
theorem coe_sqrt {x : ℝ≥0} : (NNReal.sqrt x : ℝ) = √(x : ℝ) 
Arguments: {x : ℝ≥0}
Goal: ↑(NNReal.sqrt x) = √↑x
-- Real.continuous_sqrt
@[continuity]
theorem continuous_sqrt : Continuous (√· : ℝ → ℝ) 
Goal: Continuous fun x => √x
-- Real.sqrt_eq_zero_of_nonpos
theorem sqrt_eq_zero_of_nonpos (h : x ≤ 0) : sqrt x = 0 
Arguments: {x : ℝ} (h : x ≤ 0)
Goal: √x = 0
-- Real.sqrt_nonneg
theorem sqrt_nonneg (x : ℝ) : 0 ≤ √x 
Arguments: (x : ℝ)
Goal: 0 ≤ √x
-- Real.mul_self_sqrt
@[simp]
theorem mul_self_sqrt (h : 0 ≤ x) : √x * √x = x 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √x * √x = x
-- Real.sqrt_mul_self
@[simp]
theorem sqrt_mul_self (h : 0 ≤ x) : √(x * x) = x 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √(x * x) = x
-- Real.sqrt_eq_cases
theorem sqrt_eq_cases : √x = y ↔ y * y = x ∧ 0 ≤ y ∨ x < 0 ∧ y = 0 
Arguments: {x y : ℝ}
Goal: √x = y ↔ y * y = x ∧ 0 ≤ y ∨ x < 0 ∧ y = 0
-- Real.sqrt_eq_iff_mul_self_eq
theorem sqrt_eq_iff_mul_self_eq (hx : 0 ≤ x) (hy : 0 ≤ y) : √x = y ↔ y * y = x 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y)
Goal: √x = y ↔ y * y = x
-- Real.sqrt_eq_iff_mul_self_eq_of_pos
theorem sqrt_eq_iff_mul_self_eq_of_pos (h : 0 < y) : √x = y ↔ y * y = x 
Arguments: {x y : ℝ} (h : 0 < y)
Goal: √x = y ↔ y * y = x
-- Real.sqrt_eq_one
@[simp]
theorem sqrt_eq_one : √x = 1 ↔ x = 1 
Arguments: {x : ℝ}
Goal: √x = 1 ↔ x = 1
-- Real.sq_sqrt
@[simp]
theorem sq_sqrt (h : 0 ≤ x) : √x ^ 2 = x 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √x ^ 2 = x
-- Real.sqrt_sq
@[simp]
theorem sqrt_sq (h : 0 ≤ x) : √(x ^ 2) = x 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √(x ^ 2) = x
-- Real.sqrt_eq_iff_sq_eq
theorem sqrt_eq_iff_sq_eq (hx : 0 ≤ x) (hy : 0 ≤ y) : √x = y ↔ y ^ 2 = x 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y)
Goal: √x = y ↔ y ^ 2 = x
-- Real.sqrt_mul_self_eq_abs
theorem sqrt_mul_self_eq_abs (x : ℝ) : √(x * x) = |x| 
Arguments: (x : ℝ)
Goal: √(x * x) = |x|
-- Real.sqrt_sq_eq_abs
theorem sqrt_sq_eq_abs (x : ℝ) : √(x ^ 2) = |x| 
Arguments: (x : ℝ)
Goal: √(x ^ 2) = |x|
-- Real.sqrt_zero
@[simp]
theorem sqrt_zero : √0 = 0 
Goal: √0 = 0
-- Real.sqrt_one
@[simp]
theorem sqrt_one : √1 = 1 
Goal: √1 = 1
-- Real.sqrt_le_sqrt_iff
@[simp]
theorem sqrt_le_sqrt_iff (hy : 0 ≤ y) : √x ≤ √y ↔ x ≤ y 
Arguments: {x y : ℝ} (hy : 0 ≤ y)
Goal: √x ≤ √y ↔ x ≤ y
-- Real.sqrt_lt_sqrt_iff
@[simp]
theorem sqrt_lt_sqrt_iff (hx : 0 ≤ x) : √x < √y ↔ x < y 
Arguments: {x y : ℝ} (hx : 0 ≤ x)
Goal: √x < √y ↔ x < y
-- Real.sqrt_lt_sqrt_iff_of_pos
theorem sqrt_lt_sqrt_iff_of_pos (hy : 0 < y) : √x < √y ↔ x < y 
Arguments: {x y : ℝ} (hy : 0 < y)
Goal: √x < √y ↔ x < y
-- Real.sqrt_le_sqrt
@[gcongr]
theorem sqrt_le_sqrt (h : x ≤ y) : √x ≤ √y 
Arguments: {x y : ℝ} (h : x ≤ y)
Goal: √x ≤ √y
-- Real.sqrt_lt_sqrt
@[gcongr]
theorem sqrt_lt_sqrt (hx : 0 ≤ x) (h : x < y) : √x < √y 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (h : x < y)
Goal: √x < √y
-- Real.sqrt_le_left
theorem sqrt_le_left (hy : 0 ≤ y) : √x ≤ y ↔ x ≤ y ^ 2 
Arguments: {x y : ℝ} (hy : 0 ≤ y)
Goal: √x ≤ y ↔ x ≤ y ^ 2
-- Real.sqrt_le_iff
theorem sqrt_le_iff : √x ≤ y ↔ 0 ≤ y ∧ x ≤ y ^ 2 
Arguments: {x y : ℝ}
Goal: √x ≤ y ↔ 0 ≤ y ∧ x ≤ y ^ 2
-- Real.sqrt_lt
theorem sqrt_lt (hx : 0 ≤ x) (hy : 0 ≤ y) : √x < y ↔ x < y ^ 2 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y)
Goal: √x < y ↔ x < y ^ 2
-- Real.sqrt_lt'
theorem sqrt_lt' (hy : 0 < y) : √x < y ↔ x < y ^ 2 
Arguments: {x y : ℝ} (hy : 0 < y)
Goal: √x < y ↔ x < y ^ 2
-- Real.le_sqrt
theorem le_sqrt (hx : 0 ≤ x) (hy : 0 ≤ y) : x ≤ √y ↔ x ^ 2 ≤ y 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y)
Goal: x ≤ √y ↔ x ^ 2 ≤ y
-- Real.le_sqrt'
theorem le_sqrt' (hx : 0 < x) : x ≤ √y ↔ x ^ 2 ≤ y 
Arguments: {x y : ℝ} (hx : 0 < x)
Goal: x ≤ √y ↔ x ^ 2 ≤ y
-- Real.abs_le_sqrt
theorem abs_le_sqrt (h : x ^ 2 ≤ y) : |x| ≤ √y 
Arguments: {x y : ℝ} (h : x ^ 2 ≤ y)
Goal: |x| ≤ √y
-- Real.sq_le
theorem sq_le (h : 0 ≤ y) : x ^ 2 ≤ y ↔ -√y ≤ x ∧ x ≤ √y 
Arguments: {x y : ℝ} (h : 0 ≤ y)
Goal: x ^ 2 ≤ y ↔ -√y ≤ x ∧ x ≤ √y
-- Real.neg_sqrt_le_of_sq_le
theorem neg_sqrt_le_of_sq_le (h : x ^ 2 ≤ y) : -√y ≤ x 
Arguments: {x y : ℝ} (h : x ^ 2 ≤ y)
Goal: -√y ≤ x
-- Real.le_sqrt_of_sq_le
theorem le_sqrt_of_sq_le (h : x ^ 2 ≤ y) : x ≤ √y 
Arguments: {x y : ℝ} (h : x ^ 2 ≤ y)
Goal: x ≤ √y
-- Real.sqrt_inj
@[simp]
theorem sqrt_inj (hx : 0 ≤ x) (hy : 0 ≤ y) : √x = √y ↔ x = y 
Arguments: {x y : ℝ} (hx : 0 ≤ x) (hy : 0 ≤ y)
Goal: √x = √y ↔ x = y
-- Real.sqrt_eq_zero
@[simp]
theorem sqrt_eq_zero (h : 0 ≤ x) : √x = 0 ↔ x = 0 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √x = 0 ↔ x = 0
-- Real.sqrt_eq_zero'
theorem sqrt_eq_zero' : √x = 0 ↔ x ≤ 0 
Arguments: {x : ℝ}
Goal: √x = 0 ↔ x ≤ 0
-- Real.sqrt_ne_zero
theorem sqrt_ne_zero (h : 0 ≤ x) : √x ≠ 0 ↔ x ≠ 0 
Arguments: {x : ℝ} (h : 0 ≤ x)
Goal: √x ≠ 0 ↔ x ≠ 0
-- Real.sqrt_ne_zero'
theorem sqrt_ne_zero' : √x ≠ 0 ↔ 0 < x 
Arguments: {x : ℝ}
Goal: √x ≠ 0 ↔ 0 < x
-- Real.sqrt_pos
@[simp]
theorem sqrt_pos : 0 < √x ↔ 0 < x 
Arguments: {x : ℝ}
Goal: 0 < √x ↔ 0 < x
-- Real.sqrt_le_sqrt_iff'
lemma sqrt_le_sqrt_iff' (hx : 0 < x) : √x ≤ √y ↔ x ≤ y 
Arguments: {x y : ℝ} (hx : 0 < x)
Goal: √x ≤ √y ↔ x ≤ y
-- Real.one_le_sqrt
@[simp] lemma one_le_sqrt : 1 ≤ √x ↔ 1 ≤ x 
Arguments: {x : ℝ}
Goal: 1 ≤ √x ↔ 1 ≤ x
-- Real.sqrt_le_one
@[simp] lemma sqrt_le_one : √x ≤ 1 ↔ x ≤ 1 
Arguments: {x : ℝ}
Goal: √x ≤ 1 ↔ x ≤ 1
-- Real.sqrt_mul
@[simp]
theorem sqrt_mul {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : √(x * y) = √x * √y 
Arguments: {x : ℝ} (hx : 0 ≤ x) (y : ℝ)
Goal: √(x * y) = √x * √y
-- Real.sqrt_mul'
@[simp]
theorem sqrt_mul' (x) {y : ℝ} (hy : 0 ≤ y) : √(x * y) = √x * √y 
Arguments: (x : ℝ) {y : ℝ} (hy : 0 ≤ y)
Goal: √(x * y) = √x * √y
-- Real.sqrt_inv
@[simp]
theorem sqrt_inv (x : ℝ) : √x⁻¹ = (√x)⁻¹ 
Arguments: (x : ℝ)
Goal: √x⁻¹ = (√x)⁻¹
-- Real.sqrt_div
@[simp]
theorem sqrt_div {x : ℝ} (hx : 0 ≤ x) (y : ℝ) : √(x / y) = √x / √y 
Arguments: {x : ℝ} (hx : 0 ≤ x) (y : ℝ)
Goal: √(x / y) = √x / √y
-- Real.sqrt_div'
@[simp]
theorem sqrt_div' (x) {y : ℝ} (hy : 0 ≤ y) : √(x / y) = √x / √y 
Arguments: (x : ℝ) {y : ℝ} (hy : 0 ≤ y)
Goal: √(x / y) = √x / √y
-- Real.div_sqrt
@[simp]
theorem div_sqrt : x / √x = √x 
Arguments: {x : ℝ}
Goal: x / √x = √x
-- Real.sqrt_div_self'
theorem sqrt_div_self' : √x / x = 1 / √x 
Arguments: {x : ℝ}
Goal: √x / x = 1 / √x
-- Real.sqrt_div_self
theorem sqrt_div_self : √x / x = (√x)⁻¹ 
Arguments: {x : ℝ}
Goal: √x / x = (√x)⁻¹
-- Real.lt_sqrt
theorem lt_sqrt (hx : 0 ≤ x) : x < √y ↔ x ^ 2 < y 
Arguments: {x y : ℝ} (hx : 0 ≤ x)
Goal: x < √y ↔ x ^ 2 < y
-- Real.sq_lt
theorem sq_lt : x ^ 2 < y ↔ -√y < x ∧ x < √y 
Arguments: {x y : ℝ}
Goal: x ^ 2 < y ↔ -√y < x ∧ x < √y
-- Real.neg_sqrt_lt_of_sq_lt
theorem neg_sqrt_lt_of_sq_lt (h : x ^ 2 < y) : -√y < x 
Arguments: {x y : ℝ} (h : x ^ 2 < y)
Goal: -√y < x
-- Real.lt_sqrt_of_sq_lt
theorem lt_sqrt_of_sq_lt (h : x ^ 2 < y) : x < √y 
Arguments: {x y : ℝ} (h : x ^ 2 < y)
Goal: x < √y
-- Real.lt_sq_of_sqrt_lt
theorem lt_sq_of_sqrt_lt (h : √x < y) : x < y ^ 2 
Arguments: {x y : ℝ} (h : √x < y)
Goal: x < y ^ 2
-- Real.nat_sqrt_le_real_sqrt
theorem nat_sqrt_le_real_sqrt {a : ℕ} : ↑(Nat.sqrt a) ≤ √(a : ℝ) 
Arguments: {a : ℕ}
Goal: ↑a.sqrt ≤ √↑a