ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- sigma_mk_preimage_image'
lemma sigma_mk_preimage_image' (h : i ≠ j) : Sigma.mk j ⁻¹' (Sigma.mk i '' s) = ∅ 
Arguments: {α : Type u_1} {β : α → Type u_2} {i j : α} {s : Set (β i)} (h : i ≠ j)
Goal: Sigma.mk j ⁻¹' (Sigma.mk i '' s) = ∅
-- sigma_mk_preimage_image_eq_self
lemma sigma_mk_preimage_image_eq_self : Sigma.mk i ⁻¹' (Sigma.mk i '' s) = s 
Arguments: {α : Type u_1} {β : α → Type u_2} {i : α} {s : Set (β i)}
Goal: Sigma.mk i ⁻¹' (Sigma.mk i '' s) = s
-- Multiset.zero_disjSum
@[simp]
theorem zero_disjSum : (0 : Multiset α).disjSum t = t.map inr 
Arguments: {α : Type u_1} {β : Type u_2} (t : Multiset β)
Goal: Multiset.disjSum 0 t = Multiset.map Sum.inr t
-- Multiset.disjSum_zero
@[simp]
theorem disjSum_zero : s.disjSum (0 : Multiset β) = s.map inl 
Arguments: {α : Type u_1} {β : Type u_2} (s : Multiset α)
Goal: s.disjSum 0 = Multiset.map Sum.inl s
-- Multiset.card_disjSum
@[simp]
theorem card_disjSum : Multiset.card (s.disjSum t) = Multiset.card s + Multiset.card t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Multiset α) (t : Multiset β)
Goal: Multiset.card (s.disjSum t) = Multiset.card s + Multiset.card t
-- Multiset.mem_disjSum
theorem mem_disjSum : x ∈ s.disjSum t ↔ (∃ a, a ∈ s ∧ inl a = x) ∨ ∃ b, b ∈ t ∧ inr b = x 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {t : Multiset β} {x : α ⊕ β}
Goal: x ∈ s.disjSum t ↔ (∃ a ∈ s, Sum.inl a = x) ∨ ∃ b ∈ t, Sum.inr b = x
-- Multiset.inl_mem_disjSum
@[simp]
theorem inl_mem_disjSum : inl a ∈ s.disjSum t ↔ a ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {t : Multiset β} {a : α}
Goal: Sum.inl a ∈ s.disjSum t ↔ a ∈ s
-- Multiset.inr_mem_disjSum
@[simp]
theorem inr_mem_disjSum : inr b ∈ s.disjSum t ↔ b ∈ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {t : Multiset β} {b : β}
Goal: Sum.inr b ∈ s.disjSum t ↔ b ∈ t
-- Multiset.disjSum_mono
theorem disjSum_mono (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂) : s₁.disjSum t₁ ≤ s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Multiset α} {t₁ t₂ : Multiset β} (hs : s₁ ≤ s₂) (ht : t₁ ≤ t₂)
Goal: s₁.disjSum t₁ ≤ s₂.disjSum t₂
-- Multiset.disjSum_mono_left
theorem disjSum_mono_left (t : Multiset β) : Monotone fun s : Multiset α => s.disjSum t 
Arguments: {α : Type u_1} {β : Type u_2} (t : Multiset β)
Goal: Monotone fun s => s.disjSum t
-- Multiset.disjSum_mono_right
theorem disjSum_mono_right (s : Multiset α) :
    Monotone (s.disjSum : Multiset β → Multiset (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} (s : Multiset α)
Goal: Monotone s.disjSum
-- Multiset.disjSum_lt_disjSum_of_lt_of_le
theorem disjSum_lt_disjSum_of_lt_of_le (hs : s₁ < s₂) (ht : t₁ ≤ t₂) :
    s₁.disjSum t₁ < s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Multiset α} {t₁ t₂ : Multiset β} (hs : s₁ < s₂) (ht : t₁ ≤ t₂)
Goal: s₁.disjSum t₁ < s₂.disjSum t₂
-- Multiset.disjSum_lt_disjSum_of_le_of_lt
theorem disjSum_lt_disjSum_of_le_of_lt (hs : s₁ ≤ s₂) (ht : t₁ < t₂) :
    s₁.disjSum t₁ < s₂.disjSum t₂ 
Arguments: {α : Type u_1} {β : Type u_2} {s₁ s₂ : Multiset α} {t₁ t₂ : Multiset β} (hs : s₁ ≤ s₂) (ht : t₁ < t₂)
Goal: s₁.disjSum t₁ < s₂.disjSum t₂
-- Multiset.disjSum_strictMono_left
theorem disjSum_strictMono_left (t : Multiset β) : StrictMono fun s : Multiset α => s.disjSum t 
Arguments: {α : Type u_1} {β : Type u_2} (t : Multiset β)
Goal: StrictMono fun s => s.disjSum t
-- Multiset.disjSum_strictMono_right
theorem disjSum_strictMono_right (s : Multiset α) :
    StrictMono (s.disjSum : Multiset β → Multiset (α ⊕ β)) 
Arguments: {α : Type u_1} {β : Type u_2} (s : Multiset α)
Goal: StrictMono s.disjSum
-- Multiset.Nodup.disjSum
protected theorem Nodup.disjSum (hs : s.Nodup) (ht : t.Nodup) : (s.disjSum t).Nodup 
Arguments: {α : Type u_1} {β : Type u_2} {s : Multiset α} {t : Multiset β} (hs : s.Nodup) (ht : t.Nodup)
Goal: (s.disjSum t).Nodup
-- Multiset.fold_eq_foldr
theorem fold_eq_foldr (b : α) (s : Multiset α) :
    fold op b s = foldr op (left_comm _ hc.comm ha.assoc) b s 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (s : Multiset α)
Goal: Multiset.fold op b s = Multiset.foldr op ⋯ b s
-- Multiset.coe_fold_r
@[simp]
theorem coe_fold_r (b : α) (l : List α) : fold op b l = l.foldr op b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (l : List α)
Goal: Multiset.fold op b ↑l = List.foldr op b l
-- Multiset.coe_fold_l
theorem coe_fold_l (b : α) (l : List α) : fold op b l = l.foldl op b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (l : List α)
Goal: Multiset.fold op b ↑l = List.foldl op b l
-- Multiset.fold_eq_foldl
theorem fold_eq_foldl (b : α) (s : Multiset α) :
    fold op b s = foldl op (right_comm _ hc.comm ha.assoc) b s 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α) (s : Multiset α)
Goal: Multiset.fold op b s = Multiset.foldl op ⋯ b s
-- Multiset.fold_zero
@[simp]
theorem fold_zero (b : α) : (0 : Multiset α).fold op b = b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b : α)
Goal: Multiset.fold op b 0 = b
-- Multiset.fold_cons_left
@[simp]
theorem fold_cons_left : ∀ (b a : α) (s : Multiset α), (a ::ₘ s).fold op b = a * s.fold op b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α)
Goal: Multiset.fold op b (a ::ₘ s) = op a (Multiset.fold op b s)
-- Multiset.fold_cons_right
theorem fold_cons_right (b a : α) (s : Multiset α) : (a ::ₘ s).fold op b = s.fold op b * a 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α)
Goal: Multiset.fold op b (a ::ₘ s) = op (Multiset.fold op b s) a
-- Multiset.fold_cons'_right
theorem fold_cons'_right (b a : α) (s : Multiset α) : (a ::ₘ s).fold op b = s.fold op (b * a) 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α)
Goal: Multiset.fold op b (a ::ₘ s) = Multiset.fold op (op b a) s
-- Multiset.fold_cons'_left
theorem fold_cons'_left (b a : α) (s : Multiset α) : (a ::ₘ s).fold op b = s.fold op (a * b) 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α)
Goal: Multiset.fold op b (a ::ₘ s) = Multiset.fold op (op a b) s
-- Multiset.fold_add
theorem fold_add (b₁ b₂ : α) (s₁ s₂ : Multiset α) :
    (s₁ + s₂).fold op (b₁ * b₂) = s₁.fold op b₁ * s₂.fold op b₂ 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b₁ b₂ : α) (s₁ s₂ : Multiset α)
Goal: Multiset.fold op (op b₁ b₂) (s₁ + s₂) = op (Multiset.fold op b₁ s₁) (Multiset.fold op b₂ s₂)
-- Multiset.fold_bind
theorem fold_bind {ι : Type*} (s : Multiset ι) (t : ι → Multiset α) (b : ι → α) (b₀ : α) :
    (s.bind t).fold op ((s.map b).fold op b₀) =
    (s.map fun i => (t i).fold op (b i)).fold op b₀ 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] {ι : Type u_3} (s : Multiset ι) (t : ι → Multiset α) (b : ι → α) (b₀ : α)
Goal: Multiset.fold op (Multiset.fold op b₀ (Multiset.map b s)) (s.bind t) =
  Multiset.fold op b₀ (Multiset.map (fun i => Multiset.fold op (b i) (t i)) s)
-- Multiset.fold_singleton
theorem fold_singleton (b a : α) : ({a} : Multiset α).fold op b = a * b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α)
Goal: Multiset.fold op b {a} = op a b
-- Multiset.fold_distrib
theorem fold_distrib {f g : β → α} (u₁ u₂ : α) (s : Multiset β) :
    (s.map fun x => f x * g x).fold op (u₁ * u₂) = (s.map f).fold op u₁ * (s.map g).fold op u₂ 
Arguments: {α : Type u_1} {β : Type u_2} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] {f g : β → α} (u₁ u₂ : α) (s : Multiset β)
Goal: Multiset.fold op (op u₁ u₂) (Multiset.map (fun x => op (f x) (g x)) s) =
  op (Multiset.fold op u₁ (Multiset.map f s)) (Multiset.fold op u₂ (Multiset.map g s))
-- Multiset.fold_hom
theorem fold_hom {op' : β → β → β} [Std.Commutative op'] [Std.Associative op'] {m : α → β}
    (hm : ∀ x y, m (op x y) = op' (m x) (m y)) (b : α) (s : Multiset α) :
    (s.map m).fold op' (m b) = m (s.fold op b) 
Arguments: {α : Type u_1} {β : Type u_2} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] {op' : β → β → β} [Std.Commutative op'] [Std.Associative op'] {m : α → β} (hm : ∀ (x y : α), m (op x y) = op' (m x) (m y)) (b : α) (s : Multiset α)
Goal: Multiset.fold op' (m b) (Multiset.map m s) = m (Multiset.fold op b s)
-- Multiset.fold_union_inter
theorem fold_union_inter [DecidableEq α] (s₁ s₂ : Multiset α) (b₁ b₂ : α) :
    ((s₁ ∪ s₂).fold op b₁ * (s₁ ∩ s₂).fold op b₂) = s₁.fold op b₁ * s₂.fold op b₂ 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] [DecidableEq α] (s₁ s₂ : Multiset α) (b₁ b₂ : α)
Goal: op (Multiset.fold op b₁ (s₁ ∪ s₂)) (Multiset.fold op b₂ (s₁ ∩ s₂)) =
  op (Multiset.fold op b₁ s₁) (Multiset.fold op b₂ s₂)
-- Multiset.fold_dedup_idem
@[simp]
theorem fold_dedup_idem [DecidableEq α] [hi : Std.IdempotentOp op] (s : Multiset α) (b : α) :
    (dedup s).fold op b = s.fold op b 
Arguments: {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] [DecidableEq α] [hi : Std.IdempotentOp op] (s : Multiset α) (b : α)
Goal: Multiset.fold op b s.dedup = Multiset.fold op b s
-- Multiset.le_smul_dedup
theorem le_smul_dedup [DecidableEq α] (s : Multiset α) : ∃ n : ℕ, s ≤ n • dedup s 
Arguments: {α : Type u_1} [DecidableEq α] (s : Multiset α)
Goal: ∃ n, s ≤ n • s.dedup
-- NNRat.val_eq_cast
@[simp] lemma val_eq_cast (q : ℚ≥0) : q.1 = q 
Arguments: (q : ℚ≥0)
Goal: ↑q = ↑q
-- NNRat.ext
@[ext]
theorem ext : (p : ℚ) = (q : ℚ) → p = q 
Arguments: {p q : ℚ≥0}
Goal: ↑p = ↑q → p = q
-- NNRat.coe_injective
protected theorem coe_injective : Injective ((↑) : ℚ≥0 → ℚ) 
Goal: Function.Injective NNRat.cast
-- NNRat.coe_inj
@[simp, norm_cast]
theorem coe_inj : (p : ℚ) = q ↔ p = q 
Arguments: {p q : ℚ≥0}
Goal: ↑p = ↑q ↔ p = q
-- NNRat.ext_iff
theorem ext_iff : p = q ↔ (p : ℚ) = q 
Arguments: {p q : ℚ≥0}
Goal: p = q ↔ ↑p = ↑q
-- NNRat.ne_iff
theorem ne_iff {x y : ℚ≥0} : (x : ℚ) ≠ (y : ℚ) ↔ x ≠ y 
Arguments: {x y : ℚ≥0}
Goal: ↑x ≠ ↑y ↔ x ≠ y
-- NNRat.coe_mk
@[simp, norm_cast] lemma coe_mk (q : ℚ) (hq) : NNRat.cast ⟨q, hq⟩ = q 
Arguments: (q : ℚ) (hq : 0 ≤ q)
Goal: ↑⟨q, hq⟩ = q
-- NNRat.forall
lemma «forall» {p : ℚ≥0 → Prop} : (∀ q, p q) ↔ ∀ q hq, p ⟨q, hq⟩ 
Arguments: {p : ℚ≥0 → Prop}
Goal: (∀ (q : ℚ≥0), p q) ↔ ∀ (q : ℚ) (hq : 0 ≤ q), p ⟨q, hq⟩
-- NNRat.exists
lemma «exists» {p : ℚ≥0 → Prop} : (∃ q, p q) ↔ ∃ q hq, p ⟨q, hq⟩ 
Arguments: {p : ℚ≥0 → Prop}
Goal: (∃ q, p q) ↔ ∃ q, ∃ (hq : 0 ≤ q), p ⟨q, hq⟩
-- Rat.coe_toNNRat
theorem _root_.Rat.coe_toNNRat (q : ℚ) (hq : 0 ≤ q) : (q.toNNRat : ℚ) = q 
Arguments: (q : ℚ) (hq : 0 ≤ q)
Goal: ↑q.toNNRat = q
-- Rat.le_coe_toNNRat
theorem _root_.Rat.le_coe_toNNRat (q : ℚ) : q ≤ q.toNNRat 
Arguments: (q : ℚ)
Goal: q ≤ ↑q.toNNRat
-- NNRat.coe_nonneg
@[simp]
theorem coe_nonneg (q : ℚ≥0) : (0 : ℚ) ≤ q 
Arguments: (q : ℚ≥0)
Goal: 0 ≤ ↑q
-- NNRat.coe_zero
@[simp, norm_cast] lemma coe_zero : ((0 : ℚ≥0) : ℚ) = 0 
Goal: ↑0 = 0
-- NNRat.coe_one
@[simp, norm_cast] lemma coe_one : ((1 : ℚ≥0) : ℚ) = 1 
Goal: ↑1 = 1
-- NNRat.coe_add
@[simp, norm_cast]
theorem coe_add (p q : ℚ≥0) : ((p + q : ℚ≥0) : ℚ) = p + q 
Arguments: (p q : ℚ≥0)
Goal: ↑(p + q) = ↑p + ↑q
-- NNRat.coe_mul
@[simp, norm_cast]
theorem coe_mul (p q : ℚ≥0) : ((p * q : ℚ≥0) : ℚ) = p * q 
Arguments: (p q : ℚ≥0)
Goal: ↑(p * q) = ↑p * ↑q
-- NNRat.coe_pow
@[simp, norm_cast] lemma coe_pow (q : ℚ≥0) (n : ℕ) : (↑(q ^ n) : ℚ) = (q : ℚ) ^ n 
Arguments: (q : ℚ≥0) (n : ℕ)
Goal: ↑(q ^ n) = ↑q ^ n
-- NNRat.num_pow
@[simp] lemma num_pow (q : ℚ≥0) (n : ℕ) : (q ^ n).num = q.num ^ n 
Arguments: (q : ℚ≥0) (n : ℕ)
Goal: (q ^ n).num = q.num ^ n
-- NNRat.den_pow
@[simp] lemma den_pow (q : ℚ≥0) (n : ℕ) : (q ^ n).den = q.den ^ n 
Arguments: (q : ℚ≥0) (n : ℕ)
Goal: (q ^ n).den = q.den ^ n
-- NNRat.coe_sub
@[simp, norm_cast]
theorem coe_sub (h : q ≤ p) : ((p - q : ℚ≥0) : ℚ) = p - q 
Arguments: {p q : ℚ≥0} (h : q ≤ p)
Goal: ↑(p - q) = ↑p - ↑q
-- NNRat.coe_eq_zero
@[simp]
theorem coe_eq_zero : (q : ℚ) = 0 ↔ q = 0 
Arguments: {q : ℚ≥0}
Goal: ↑q = 0 ↔ q = 0
-- NNRat.coe_ne_zero
theorem coe_ne_zero : (q : ℚ) ≠ 0 ↔ q ≠ 0 
Arguments: {q : ℚ≥0}
Goal: ↑q ≠ 0 ↔ q ≠ 0
-- NNRat.coe_le_coe
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_le_coe : (p : ℚ) ≤ q ↔ p ≤ q 
Arguments: {p q : ℚ≥0}
Goal: ↑p ≤ ↑q ↔ p ≤ q
-- NNRat.coe_lt_coe
@[norm_cast] -- Porting note (#10618): simp can prove this
theorem coe_lt_coe : (p : ℚ) < q ↔ p < q 
Arguments: {p q : ℚ≥0}
Goal: ↑p < ↑q ↔ p < q
-- NNRat.coe_pos
@[simp, norm_cast, nolint simpNF]
theorem coe_pos : (0 : ℚ) < q ↔ 0 < q 
Arguments: {q : ℚ≥0}
Goal: 0 < ↑q ↔ 0 < q
-- NNRat.coe_mono
theorem coe_mono : Monotone ((↑) : ℚ≥0 → ℚ) 
Goal: Monotone NNRat.cast
-- NNRat.toNNRat_mono
theorem toNNRat_mono : Monotone toNNRat 
Goal: Monotone Rat.toNNRat
-- NNRat.toNNRat_coe
@[simp]
theorem toNNRat_coe (q : ℚ≥0) : toNNRat q = q 
Arguments: (q : ℚ≥0)
Goal: (↑q).toNNRat = q
-- NNRat.toNNRat_coe_nat
@[simp]
theorem toNNRat_coe_nat (n : ℕ) : toNNRat n = n 
Arguments: (n : ℕ)
Goal: (↑n).toNNRat = ↑n
-- NNRat.coe_natCast
@[simp, norm_cast] lemma coe_natCast (n : ℕ) : (↑(↑n : ℚ≥0) : ℚ) = n 
Arguments: (n : ℕ)
Goal: ↑↑n = ↑n
-- NNRat.mk_natCast
@[simp]
theorem mk_natCast (n : ℕ) : @Eq ℚ≥0 (⟨(n : ℚ), n.cast_nonneg⟩ : ℚ≥0) n 
Arguments: (n : ℕ)
Goal: ⟨↑n, ⋯⟩ = ↑n
-- NNRat.coe_coeHom
@[simp]
theorem coe_coeHom : ⇑coeHom = ((↑) : ℚ≥0 → ℚ) 
Goal: ⇑NNRat.coeHom = NNRat.cast
-- NNRat.nsmul_coe
@[norm_cast]
theorem nsmul_coe (q : ℚ≥0) (n : ℕ) : ↑(n • q) = n • (q : ℚ) 
Arguments: (q : ℚ≥0) (n : ℕ)
Goal: ↑(n • q) = n • ↑q
-- NNRat.bddAbove_coe
theorem bddAbove_coe {s : Set ℚ≥0} : BddAbove ((↑) '' s : Set ℚ) ↔ BddAbove s 
Arguments: {s : Set ℚ≥0}
Goal: BddAbove (NNRat.cast '' s) ↔ BddAbove s
-- NNRat.bddBelow_coe
theorem bddBelow_coe (s : Set ℚ≥0) : BddBelow (((↑) : ℚ≥0 → ℚ) '' s) 
Arguments: (s : Set ℚ≥0)
Goal: BddBelow (NNRat.cast '' s)
-- NNRat.coe_max
@[simp, norm_cast, nolint simpNF]
theorem coe_max (x y : ℚ≥0) : ((max x y : ℚ≥0) : ℚ) = max (x : ℚ) (y : ℚ) 
Arguments: (x y : ℚ≥0)
Goal: ↑(max x y) = max ↑x ↑y
-- NNRat.coe_min
@[simp, norm_cast, nolint simpNF]
theorem coe_min (x y : ℚ≥0) : ((min x y : ℚ≥0) : ℚ) = min (x : ℚ) (y : ℚ) 
Arguments: (x y : ℚ≥0)
Goal: ↑(min x y) = min ↑x ↑y
-- NNRat.sub_def
theorem sub_def (p q : ℚ≥0) : p - q = toNNRat (p - q) 
Arguments: (p q : ℚ≥0)
Goal: p - q = (↑p - ↑q).toNNRat
-- NNRat.abs_coe
@[simp]
theorem abs_coe (q : ℚ≥0) : |(q : ℚ)| = q 
Arguments: (q : ℚ≥0)
Goal: |↑q| = ↑q
-- Rat.toNNRat_zero
@[simp]
theorem toNNRat_zero : toNNRat 0 = 0 
Goal: Rat.toNNRat 0 = 0
-- Rat.toNNRat_one
@[simp]
theorem toNNRat_one : toNNRat 1 = 1 
Goal: Rat.toNNRat 1 = 1
-- Rat.toNNRat_pos
@[simp]
theorem toNNRat_pos : 0 < toNNRat q ↔ 0 < q 
Arguments: {q : ℚ}
Goal: 0 < q.toNNRat ↔ 0 < q
-- Rat.toNNRat_eq_zero
@[simp]
theorem toNNRat_eq_zero : toNNRat q = 0 ↔ q ≤ 0 
Arguments: {q : ℚ}
Goal: q.toNNRat = 0 ↔ q ≤ 0
-- Rat.toNNRat_le_toNNRat_iff
@[simp]
theorem toNNRat_le_toNNRat_iff (hp : 0 ≤ p) : toNNRat q ≤ toNNRat p ↔ q ≤ p 
Arguments: {p q : ℚ} (hp : 0 ≤ p)
Goal: q.toNNRat ≤ p.toNNRat ↔ q ≤ p
-- Rat.toNNRat_lt_toNNRat_iff'
@[simp]
theorem toNNRat_lt_toNNRat_iff' : toNNRat q < toNNRat p ↔ q < p ∧ 0 < p 
Arguments: {p q : ℚ}
Goal: q.toNNRat < p.toNNRat ↔ q < p ∧ 0 < p
-- Rat.toNNRat_lt_toNNRat_iff
theorem toNNRat_lt_toNNRat_iff (h : 0 < p) : toNNRat q < toNNRat p ↔ q < p 
Arguments: {p q : ℚ} (h : 0 < p)
Goal: q.toNNRat < p.toNNRat ↔ q < p
-- Rat.toNNRat_lt_toNNRat_iff_of_nonneg
theorem toNNRat_lt_toNNRat_iff_of_nonneg (hq : 0 ≤ q) : toNNRat q < toNNRat p ↔ q < p 
Arguments: {p q : ℚ} (hq : 0 ≤ q)
Goal: q.toNNRat < p.toNNRat ↔ q < p
-- Rat.toNNRat_add
@[simp]
theorem toNNRat_add (hq : 0 ≤ q) (hp : 0 ≤ p) : toNNRat (q + p) = toNNRat q + toNNRat p 
Arguments: {p q : ℚ} (hq : 0 ≤ q) (hp : 0 ≤ p)
Goal: (q + p).toNNRat = q.toNNRat + p.toNNRat
-- Rat.toNNRat_add_le
theorem toNNRat_add_le : toNNRat (q + p) ≤ toNNRat q + toNNRat p 
Arguments: {p q : ℚ}
Goal: (q + p).toNNRat ≤ q.toNNRat + p.toNNRat
-- Rat.toNNRat_le_iff_le_coe
theorem toNNRat_le_iff_le_coe {p : ℚ≥0} : toNNRat q ≤ p ↔ q ≤ ↑p 
Arguments: {q : ℚ} {p : ℚ≥0}
Goal: q.toNNRat ≤ p ↔ q ≤ ↑p
-- Rat.le_toNNRat_iff_coe_le
theorem le_toNNRat_iff_coe_le {q : ℚ≥0} (hp : 0 ≤ p) : q ≤ toNNRat p ↔ ↑q ≤ p 
Arguments: {p : ℚ} {q : ℚ≥0} (hp : 0 ≤ p)
Goal: q ≤ p.toNNRat ↔ ↑q ≤ p
-- Rat.le_toNNRat_iff_coe_le'
theorem le_toNNRat_iff_coe_le' {q : ℚ≥0} (hq : 0 < q) : q ≤ toNNRat p ↔ ↑q ≤ p 
Arguments: {p : ℚ} {q : ℚ≥0} (hq : 0 < q)
Goal: q ≤ p.toNNRat ↔ ↑q ≤ p
-- Rat.toNNRat_lt_iff_lt_coe
theorem toNNRat_lt_iff_lt_coe {p : ℚ≥0} (hq : 0 ≤ q) : toNNRat q < p ↔ q < ↑p 
Arguments: {q : ℚ} {p : ℚ≥0} (hq : 0 ≤ q)
Goal: q.toNNRat < p ↔ q < ↑p
-- Rat.lt_toNNRat_iff_coe_lt
theorem lt_toNNRat_iff_coe_lt {q : ℚ≥0} : q < toNNRat p ↔ ↑q < p 
Arguments: {p : ℚ} {q : ℚ≥0}
Goal: q < p.toNNRat ↔ ↑q < p
-- Rat.toNNRat_mul
theorem toNNRat_mul (hp : 0 ≤ p) : toNNRat (p * q) = toNNRat p * toNNRat q 
Arguments: {p q : ℚ} (hp : 0 ≤ p)
Goal: (p * q).toNNRat = p.toNNRat * q.toNNRat
-- Rat.coe_nnabs
@[norm_cast, simp]
theorem Rat.coe_nnabs (x : ℚ) : (Rat.nnabs x : ℚ) = abs x 
Arguments: (x : ℚ)
Goal: ↑(Rat.nnabs x) = |x|
-- NNRat.num_coe
@[norm_cast] lemma num_coe (q : ℚ≥0) : (q : ℚ).num = q.num 
Arguments: (q : ℚ≥0)
Goal: (↑q).num = ↑q.num
-- NNRat.natAbs_num_coe
theorem natAbs_num_coe : (q : ℚ).num.natAbs = q.num 
Arguments: {q : ℚ≥0}
Goal: (↑q).num.natAbs = q.num
-- NNRat.den_coe
@[norm_cast] lemma den_coe : (q : ℚ).den = q.den 
Arguments: {q : ℚ≥0}
Goal: (↑q).den = q.den
-- NNRat.num_ne_zero
@[simp] lemma num_ne_zero : q.num ≠ 0 ↔ q ≠ 0 
Arguments: {q : ℚ≥0}
Goal: q.num ≠ 0 ↔ q ≠ 0
-- NNRat.num_pos
@[simp] lemma num_pos : 0 < q.num ↔ 0 < q 
Arguments: {q : ℚ≥0}
Goal: 0 < q.num ↔ 0 < q
-- NNRat.den_pos
@[simp] lemma den_pos (q : ℚ≥0) : 0 < q.den 
Arguments: (q : ℚ≥0)
Goal: 0 < q.den
-- NNRat.den_ne_zero
@[simp] lemma den_ne_zero (q : ℚ≥0) : q.den ≠ 0 
Arguments: (q : ℚ≥0)
Goal: q.den ≠ 0
-- NNRat.coprime_num_den
lemma coprime_num_den (q : ℚ≥0) : q.num.Coprime q.den 
Arguments: (q : ℚ≥0)
Goal: q.num.Coprime q.den
-- NNRat.num_natCast
@[simp, norm_cast] lemma num_natCast (n : ℕ) : num n = n 
Arguments: (n : ℕ)
Goal: (↑n).num = n
-- NNRat.den_natCast
@[simp, norm_cast] lemma den_natCast (n : ℕ) : den n = 1 
Arguments: (n : ℕ)
Goal: (↑n).den = 1
-- NNRat.num_ofNat
@[simp] lemma num_ofNat (n : ℕ) [n.AtLeastTwo] : num (no_index (OfNat.ofNat n)) = OfNat.ofNat n 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).num = OfNat.ofNat n
-- NNRat.den_ofNat
@[simp] lemma den_ofNat (n : ℕ) [n.AtLeastTwo] : den (no_index (OfNat.ofNat n)) = 1 
Arguments: (n : ℕ) [n.AtLeastTwo]
Goal: (OfNat.ofNat n).den = 1
-- NNRat.ext_num_den
theorem ext_num_den (hn : p.num = q.num) (hd : p.den = q.den) : p = q 
Arguments: {p q : ℚ≥0} (hn : p.num = q.num) (hd : p.den = q.den)
Goal: p = q
-- NNRat.ext_num_den_iff
theorem ext_num_den_iff : p = q ↔ p.num = q.num ∧ p.den = q.den 
Arguments: {p q : ℚ≥0}
Goal: p = q ↔ p.num = q.num ∧ p.den = q.den
-- NNRat.coe_divNat
@[simp, norm_cast] lemma coe_divNat (n d : ℕ) : (divNat n d : ℚ) = .divInt n d 
Arguments: (n d : ℕ)
Goal: ↑(NNRat.divNat n d) = Rat.divInt ↑n ↑d
-- NNRat.mk_divInt
lemma mk_divInt (n d : ℕ) :
    ⟨.divInt n d, Rat.divInt_nonneg n.cast_nonneg d.cast_nonneg⟩ = divNat n d 
Arguments: (n d : ℕ)
Goal: ⟨Rat.divInt ↑n ↑d, ⋯⟩ = NNRat.divNat n d
-- NNRat.divNat_inj
lemma divNat_inj (h₁ : d₁ ≠ 0) (h₂ : d₂ ≠ 0) : divNat n₁ d₁ = divNat n₂ d₂ ↔ n₁ * d₂ = n₂ * d₁ 
Arguments: {n₁ n₂ d₁ d₂ : ℕ} (h₁ : d₁ ≠ 0) (h₂ : d₂ ≠ 0)
Goal: NNRat.divNat n₁ d₁ = NNRat.divNat n₂ d₂ ↔ n₁ * d₂ = n₂ * d₁
-- NNRat.divNat_zero
@[simp] lemma divNat_zero (n : ℕ) : divNat n 0 = 0 
Arguments: (n : ℕ)
Goal: NNRat.divNat n 0 = 0
-- NNRat.num_divNat_den
@[simp] lemma num_divNat_den (q : ℚ≥0) : divNat q.num q.den = q 
Arguments: (q : ℚ≥0)
Goal: NNRat.divNat q.num q.den = q
-- NNRat.natCast_eq_divNat
lemma natCast_eq_divNat (n : ℕ) : (n : ℚ≥0) = divNat n 1 
Arguments: (n : ℕ)
Goal: ↑n = NNRat.divNat n 1
-- NNRat.divNat_mul_divNat
lemma divNat_mul_divNat (n₁ n₂ : ℕ) {d₁ d₂} (hd₁ : d₁ ≠ 0) (hd₂ : d₂ ≠ 0) :
    divNat n₁ d₁ * divNat n₂ d₂ = divNat (n₁ * n₂) (d₁ * d₂) 
Arguments: (n₁ n₂ : ℕ) {d₁ d₂ : ℕ} (hd₁ : d₁ ≠ 0) (hd₂ : d₂ ≠ 0)
Goal: NNRat.divNat n₁ d₁ * NNRat.divNat n₂ d₂ = NNRat.divNat (n₁ * n₂) (d₁ * d₂)
-- NNRat.divNat_mul_left
lemma divNat_mul_left {a : ℕ} (ha : a ≠ 0) (n d : ℕ) : divNat (a * n) (a * d) = divNat n d 
Arguments: {a : ℕ} (ha : a ≠ 0) (n d : ℕ)
Goal: NNRat.divNat (a * n) (a * d) = NNRat.divNat n d
-- NNRat.divNat_mul_right
lemma divNat_mul_right {a : ℕ} (ha : a ≠ 0) (n d : ℕ) : divNat (n * a) (d * a) = divNat n d 
Arguments: {a : ℕ} (ha : a ≠ 0) (n d : ℕ)
Goal: NNRat.divNat (n * a) (d * a) = NNRat.divNat n d
-- NNRat.mul_den_eq_num
@[simp] lemma mul_den_eq_num (q : ℚ≥0) : q * q.den = q.num 
Arguments: (q : ℚ≥0)
Goal: q * ↑q.den = ↑q.num
-- NNRat.den_mul_eq_num
@[simp] lemma den_mul_eq_num (q : ℚ≥0) : q.den * q = q.num 
Arguments: (q : ℚ≥0)
Goal: ↑q.den * q = ↑q.num
-- NNRat.add_def
lemma add_def (q r : ℚ≥0) : q + r = divNat (q.num * r.den + r.num * q.den) (q.den * r.den) 
Arguments: (q r : ℚ≥0)
Goal: q + r = NNRat.divNat (q.num * r.den + r.num * q.den) (q.den * r.den)
-- NNRat.mul_def
lemma mul_def (q r : ℚ≥0) : q * r = divNat (q.num * r.num) (q.den * r.den) 
Arguments: (q r : ℚ≥0)
Goal: q * r = NNRat.divNat (q.num * r.num) (q.den * r.den)
-- NNRat.lt_def
theorem lt_def {p q : ℚ≥0} : p < q ↔ p.num * q.den < q.num * p.den 
Arguments: {p q : ℚ≥0}
Goal: p < q ↔ p.num * q.den < q.num * p.den
-- NNRat.le_def
theorem le_def {p q : ℚ≥0} : p ≤ q ↔ p.num * q.den ≤ q.num * p.den 
Arguments: {p q : ℚ≥0}
Goal: p ≤ q ↔ p.num * q.den ≤ q.num * p.den
-- Set.Icc_mul_Icc_subset'
@[to_additive Icc_add_Icc_subset]
theorem Icc_mul_Icc_subset' (a b c d : α) : Icc a b * Icc c d ⊆ Icc (a * c) (b * d) 
Arguments: {α : Type u_1} [Mul α] [Preorder α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HMul.hMul) LE.le] (a b c d : α)
Goal: Set.Icc a b * Set.Icc c d ⊆ Set.Icc (a * c) (b * d)
-- Set.Icc_add_Icc_subset
@[to_additive Icc_add_Icc_subset]
theorem Icc_mul_Icc_subset' (a b c d : α) : Icc a b * Icc c d ⊆ Icc (a * c) (b * d) 
Arguments: {α : Type u_1} [Add α] [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LE.le] (a b c d : α)
Goal: Set.Icc a b + Set.Icc c d ⊆ Set.Icc (a + c) (b + d)
-- Set.Iic_mul_Iic_subset'
@[to_additive Iic_add_Iic_subset]
theorem Iic_mul_Iic_subset' (a b : α) : Iic a * Iic b ⊆ Iic (a * b) 
Arguments: {α : Type u_1} [Mul α] [Preorder α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HMul.hMul) LE.le] (a b : α)
Goal: Set.Iic a * Set.Iic b ⊆ Set.Iic (a * b)
-- Set.Iic_add_Iic_subset
@[to_additive Iic_add_Iic_subset]
theorem Iic_mul_Iic_subset' (a b : α) : Iic a * Iic b ⊆ Iic (a * b) 
Arguments: {α : Type u_1} [Add α] [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LE.le] (a b : α)
Goal: Set.Iic a + Set.Iic b ⊆ Set.Iic (a + b)
-- Set.Ici_mul_Ici_subset'
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
Arguments: {α : Type u_1} [Mul α] [Preorder α] [CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HMul.hMul) LE.le] (a b : α)
Goal: Set.Ici a * Set.Ici b ⊆ Set.Ici (a * b)
-- Set.Ici_add_Ici_subset
@[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
Arguments: {α : Type u_1} [Add α] [Preorder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [CovariantClass α α (Function.swap HAdd.hAdd) LE.le] (a b : α)
Goal: Set.Ici a + Set.Ici b ⊆ Set.Ici (a + b)