ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Finsupp.support_sup
@[simp]
theorem support_sup [DecidableEq ι] (f g : ι →₀ α) : (f ⊔ g).support = f.support ∪ g.support 
Arguments: {ι : Type u_1} {α : Type u_2} [CanonicallyLinearOrderedAddCommMonoid α] [DecidableEq ι] (f g : ι →₀ α)
Goal: (f ⊔ g).support = f.support ∪ g.support
-- Finsupp.disjoint_iff
nonrec theorem disjoint_iff {f g : ι →₀ α} : Disjoint f g ↔ Disjoint f.support g.support 
Arguments: {ι : Type u_1} {α : Type u_2} [CanonicallyLinearOrderedAddCommMonoid α] {f g : ι →₀ α}
Goal: Disjoint f g ↔ Disjoint f.support g.support
-- Finsupp.sub_single_one_add
theorem sub_single_one_add {a : ι} {u u' : ι →₀ ℕ} (h : u a ≠ 0) :
    u - single a 1 + u' = u + u' - single a 1 
Arguments: {ι : Type u_1} {a : ι} {u u' : ι →₀ ℕ} (h : u a ≠ 0)
Goal: u - Finsupp.single a 1 + u' = u + u' - Finsupp.single a 1
-- Finsupp.add_sub_single_one
theorem add_sub_single_one {a : ι} {u u' : ι →₀ ℕ} (h : u' a ≠ 0) :
    u + (u' - single a 1) = u + u' - single a 1 
Arguments: {ι : Type u_1} {a : ι} {u u' : ι →₀ ℕ} (h : u' a ≠ 0)
Goal: u + (u' - Finsupp.single a 1) = u + u' - Finsupp.single a 1
-- Pi.Icc_eq
theorem Icc_eq : Icc a b = piFinset fun i => Icc (a i) (b i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: Finset.Icc a b = Fintype.piFinset fun i => Finset.Icc (a i) (b i)
-- Pi.card_Icc
theorem card_Icc : (Icc a b).card = ∏ i, (Icc (a i) (b i)).card 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: (Finset.Icc a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card
-- Pi.card_Ico
theorem card_Ico : (Ico a b).card = (∏ i, (Icc (a i) (b i)).card) - 1 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: (Finset.Ico a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 1
-- Pi.card_Ioc
theorem card_Ioc : (Ioc a b).card = (∏ i, (Icc (a i) (b i)).card) - 1 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: (Finset.Ioc a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 1
-- Pi.card_Ioo
theorem card_Ioo : (Ioo a b).card = (∏ i, (Icc (a i) (b i)).card) - 2 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: (Finset.Ioo a b).card = ∏ i : ι, (Finset.Icc (a i) (b i)).card - 2
-- Pi.card_Iic
theorem card_Iic : (Iic b).card = ∏ i, (Iic (b i)).card 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrderBot (α i)] (b : (i : ι) → α i)
Goal: (Finset.Iic b).card = ∏ i : ι, (Finset.Iic (b i)).card
-- Pi.card_Iio
theorem card_Iio : (Iio b).card = (∏ i, (Iic (b i)).card) - 1 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrderBot (α i)] (b : (i : ι) → α i)
Goal: (Finset.Iio b).card = ∏ i : ι, (Finset.Iic (b i)).card - 1
-- Pi.card_Ici
theorem card_Ici : (Ici a).card = ∏ i, (Ici (a i)).card 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrderTop (α i)] (a : (i : ι) → α i)
Goal: (Finset.Ici a).card = ∏ i : ι, (Finset.Ici (a i)).card
-- Pi.card_Ioi
theorem card_Ioi : (Ioi a).card = (∏ i, (Ici (a i)).card) - 1 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → PartialOrder (α i)] [(i : ι) → LocallyFiniteOrderTop (α i)] (a : (i : ι) → α i)
Goal: (Finset.Ioi a).card = ∏ i : ι, (Finset.Ici (a i)).card - 1
-- Pi.uIcc_eq
theorem uIcc_eq : uIcc a b = piFinset fun i => uIcc (a i) (b i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → Lattice (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: Finset.uIcc a b = Fintype.piFinset fun i => Finset.uIcc (a i) (b i)
-- Pi.card_uIcc
theorem card_uIcc : (uIcc a b).card = ∏ i, (uIcc (a i) (b i)).card 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Fintype ι] [DecidableEq ι] [(i : ι) → DecidableEq (α i)] [(i : ι) → Lattice (α i)] [(i : ι) → LocallyFiniteOrder (α i)] (a b : (i : ι) → α i)
Goal: (Finset.uIcc a b).card = ∏ i : ι, (Finset.uIcc (a i) (b i)).card
-- Finsupp.coe_mul
theorem coe_mul (g₁ g₂ : α →₀ β) : ⇑(g₁ * g₂) = g₁ * g₂ 
Arguments: {α : Type u₁} {β : Type u₂} [MulZeroClass β] (g₁ g₂ : α →₀ β)
Goal: ⇑(g₁ * g₂) = ⇑g₁ * ⇑g₂
-- Finsupp.mul_apply
@[simp]
theorem mul_apply {g₁ g₂ : α →₀ β} {a : α} : (g₁ * g₂) a = g₁ a * g₂ a 
Arguments: {α : Type u₁} {β : Type u₂} [MulZeroClass β] {g₁ g₂ : α →₀ β} {a : α}
Goal: (g₁ * g₂) a = g₁ a * g₂ a
-- Finsupp.single_mul
@[simp]
theorem single_mul (a : α) (b₁ b₂ : β) : single a (b₁ * b₂) = single a b₁ * single a b₂ 
Arguments: {α : Type u₁} {β : Type u₂} [MulZeroClass β] (a : α) (b₁ b₂ : β)
Goal: Finsupp.single a (b₁ * b₂) = Finsupp.single a b₁ * Finsupp.single a b₂
-- Finsupp.support_mul
theorem support_mul [DecidableEq α] {g₁ g₂ : α →₀ β} :
    (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support 
Arguments: {α : Type u₁} {β : Type u₂} [MulZeroClass β] [DecidableEq α] {g₁ g₂ : α →₀ β}
Goal: (g₁ * g₂).support ⊆ g₁.support ∩ g₂.support
-- Finsupp.coe_pointwise_smul
@[simp]
theorem coe_pointwise_smul [Semiring β] (f : α → β) (g : α →₀ β) : ⇑(f • g) = f • ⇑g 
Arguments: {α : Type u₁} {β : Type u₂} [Semiring β] (f : α → β) (g : α →₀ β)
Goal: ⇑(f • g) = f • ⇑g
-- Pi.lex_eq_finsupp_lex
theorem _root_.Pi.lex_eq_finsupp_lex {r : α → α → Prop} {s : N → N → Prop} (a b : α →₀ N) :
    Pi.Lex r s a b = Finsupp.Lex r s a b 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] {r : α → α → Prop} {s : N → N → Prop} (a b : α →₀ N)
Goal: Pi.Lex r (fun {i} => s) ⇑a ⇑b = Finsupp.Lex r s a b
-- Finsupp.lex_def
theorem lex_def {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N} :
    Finsupp.Lex r s a b ↔ ∃ j, (∀ d, r d j → a d = b d) ∧ s (a j) (b j) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] {r : α → α → Prop} {s : N → N → Prop} {a b : α →₀ N}
Goal: Finsupp.Lex r s a b ↔ ∃ j, (∀ (d : α), r d j → a d = b d) ∧ s (a j) (b j)
-- Finsupp.lex_eq_invImage_dfinsupp_lex
theorem lex_eq_invImage_dfinsupp_lex (r : α → α → Prop) (s : N → N → Prop) :
    Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun _ ↦ s) toDFinsupp 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] (r : α → α → Prop) (s : N → N → Prop)
Goal: Finsupp.Lex r s = InvImage (DFinsupp.Lex r fun x => s) Finsupp.toDFinsupp
-- Finsupp.lex_lt_of_lt_of_preorder
theorem lex_lt_of_lt_of_preorder [Preorder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
    ∃ i, (∀ j, r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [Preorder N] (r : α → α → Prop) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y)
Goal: ∃ i, (∀ (j : α), r j i → x j ≤ y j ∧ y j ≤ x j) ∧ x i < y i
-- Finsupp.lex_lt_of_lt
theorem lex_lt_of_lt [PartialOrder N] (r) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y) :
    Pi.Lex r (· < ·) x y 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [PartialOrder N] (r : α → α → Prop) [IsStrictOrder α r] {x y : α →₀ N} (hlt : x < y)
Goal: Pi.Lex r (fun {i} x x_1 => x < x_1) ⇑x ⇑y
-- Finsupp.toLex_monotone
theorem toLex_monotone : Monotone (@toLex (α →₀ N)) 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [LinearOrder α] [PartialOrder N]
Goal: Monotone ⇑toLex
-- Finsupp.lt_of_forall_lt_of_lt
theorem lt_of_forall_lt_of_lt (a b : Lex (α →₀ N)) (i : α) :
    (∀ j < i, ofLex a j = ofLex b j) → ofLex a i < ofLex b i → a < b 
Arguments: {α : Type u_1} {N : Type u_2} [Zero N] [LinearOrder α] [PartialOrder N] (a b : Lex (α →₀ N)) (i : α)
Goal: (∀ j < i, (ofLex a) j = (ofLex b) j) → (ofLex a) i < (ofLex b) i → a < b
-- Rat.cast_inv_nat
@[simp]
theorem cast_inv_nat (n : ℕ) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
Arguments: {α : Type u_1} [DivisionRing α] (n : ℕ)
Goal: ↑(↑n)⁻¹ = (↑n)⁻¹
-- Rat.cast_inv_int
@[simp]
theorem cast_inv_int (n : ℤ) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
Arguments: {α : Type u_1} [DivisionRing α] (n : ℤ)
Goal: ↑(↑n)⁻¹ = (↑n)⁻¹
-- Rat.cast_nnratCast
@[simp, norm_cast]
theorem cast_nnratCast {K} [DivisionRing K] (q : ℚ≥0) :
    ((q : ℚ) : K) = (q : K) 
Arguments: {K : Type u_2} [DivisionRing K] (q : ℚ≥0)
Goal: ↑↑q = ↑q
-- Rat.cast_ofScientific
@[simp, norm_cast]
theorem cast_ofScientific {K} [DivisionRing K] (m : ℕ) (s : Bool) (e : ℕ) :
    (OfScientific.ofScientific m s e : ℚ) = (OfScientific.ofScientific m s e : K) 
Arguments: {K : Type u_2} [DivisionRing K] (m : ℕ) (s : Bool) (e : ℕ)
Goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e
-- NNRat.cast_pow
@[simp, norm_cast]
theorem cast_pow {K} [DivisionSemiring K] (q : ℚ≥0) (n : ℕ) :
    NNRat.cast (q ^ n) = (NNRat.cast q : K) ^ n 
Arguments: {K : Type u_1} [DivisionSemiring K] (q : ℚ≥0) (n : ℕ)
Goal: ↑(q ^ n) = ↑q ^ n
-- NNRat.cast_zpow_of_ne_zero
theorem cast_zpow_of_ne_zero {K} [DivisionSemiring K] (q : ℚ≥0) (z : ℤ) (hq : (q.num : K) ≠ 0) :
    NNRat.cast (q ^ z) = (NNRat.cast q : K) ^ z 
Arguments: {K : Type u_1} [DivisionSemiring K] (q : ℚ≥0) (z : ℤ) (hq : ↑q.num ≠ 0)
Goal: ↑(q ^ z) = ↑q ^ z
-- NNRat.Nonneg.coe_ofScientific
theorem Nonneg.coe_ofScientific {K} [LinearOrderedField K] (m : ℕ) (s : Bool) (e : ℕ) :
    (ofScientific m s e : {x : K // 0 ≤ x}).val = ofScientific m s e 
Arguments: {K : Type u_1} [LinearOrderedField K] (m : ℕ) (s : Bool) (e : ℕ)
Goal: ↑(OfScientific.ofScientific m s e) = OfScientific.ofScientific m s e
-- Rat.cast_list_sum
@[simp, norm_cast]
theorem cast_list_sum (s : List ℚ) : (↑s.sum : α) = (s.map (↑)).sum 
Arguments: {α : Type u_2} [DivisionRing α] [CharZero α] (s : List ℚ)
Goal: ↑s.sum = (List.map Rat.cast s).sum
-- Rat.cast_multiset_sum
@[simp, norm_cast]
theorem cast_multiset_sum (s : Multiset ℚ) : (↑s.sum : α) = (s.map (↑)).sum 
Arguments: {α : Type u_2} [DivisionRing α] [CharZero α] (s : Multiset ℚ)
Goal: ↑s.sum = (Multiset.map Rat.cast s).sum
-- Rat.cast_sum
@[simp, norm_cast]
theorem cast_sum (s : Finset ι) (f : ι → ℚ) : ∑ i ∈ s, f i = ∑ i ∈ s, (f i : α) 
Arguments: {ι : Type u_1} {α : Type u_2} [DivisionRing α] [CharZero α] (s : Finset ι) (f : ι → ℚ)
Goal: ↑(∑ i ∈ s, f i) = ∑ i ∈ s, ↑(f i)
-- Rat.cast_list_prod
@[simp, norm_cast]
theorem cast_list_prod (s : List ℚ) : (↑s.prod : α) = (s.map (↑)).prod 
Arguments: {α : Type u_2} [DivisionRing α] [CharZero α] (s : List ℚ)
Goal: ↑s.prod = (List.map Rat.cast s).prod
-- Rat.cast_multiset_prod
@[simp, norm_cast]
theorem cast_multiset_prod (s : Multiset ℚ) : (↑s.prod : α) = (s.map (↑)).prod 
Arguments: {α : Type u_2} [Field α] [CharZero α] (s : Multiset ℚ)
Goal: ↑s.prod = (Multiset.map Rat.cast s).prod
-- Rat.cast_prod
@[simp, norm_cast]
theorem cast_prod (s : Finset ι) (f : ι → ℚ) : ∏ i ∈ s, f i = ∏ i ∈ s, (f i : α) 
Arguments: {ι : Type u_1} {α : Type u_2} [Field α] [CharZero α] (s : Finset ι) (f : ι → ℚ)
Goal: ↑(∏ i ∈ s, f i) = ∏ i ∈ s, ↑(f i)
-- NNRat.num_mk
@[simp] lemma num_mk (q : ℚ) (hq : 0 ≤ q) : num ⟨q, hq⟩ = q.num.natAbs 
Arguments: (q : ℚ) (hq : 0 ≤ q)
Goal: NNRat.num ⟨q, hq⟩ = q.num.natAbs
-- NNRat.den_mk
@[simp] lemma den_mk (q : ℚ) (hq : 0 ≤ q) : den ⟨q, hq⟩ = q.den 
Arguments: (q : ℚ) (hq : 0 ≤ q)
Goal: NNRat.den ⟨q, hq⟩ = q.den
-- NNRat.cast_id
@[norm_cast] lemma cast_id (n : ℚ≥0) : NNRat.cast n = n 
Arguments: (n : ℚ≥0)
Goal: ↑n = n
-- NNRat.cast_eq_id
@[simp] lemma cast_eq_id : NNRat.cast = id 
Goal: NNRat.cast = id
-- Rat.cast_id
@[norm_cast] lemma cast_id (n : ℚ) : Rat.cast n = n 
Arguments: (n : ℚ)
Goal: ↑n = n
-- Rat.cast_eq_id
@[simp] lemma cast_eq_id : Rat.cast = id 
Goal: Rat.cast = id
-- Rat.cast_inj
@[simp, norm_cast]
theorem cast_inj [CharZero α] : ∀ {m n : ℚ}, (m : α) = n ↔ m = n
  
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] {m n : ℚ}
Goal: ↑m = ↑n ↔ m = n
-- Rat.cast_injective
theorem cast_injective [CharZero α] : Function.Injective ((↑) : ℚ → α)
  
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α]
Goal: Function.Injective Rat.cast
-- Rat.cast_eq_zero
@[simp]
theorem cast_eq_zero [CharZero α] {n : ℚ} : (n : α) = 0 ↔ n = 0 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] {n : ℚ}
Goal: ↑n = 0 ↔ n = 0
-- Rat.cast_ne_zero
theorem cast_ne_zero [CharZero α] {n : ℚ} : (n : α) ≠ 0 ↔ n ≠ 0 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] {n : ℚ}
Goal: ↑n ≠ 0 ↔ n ≠ 0
-- Rat.cast_add
@[simp, norm_cast]
theorem cast_add [CharZero α] (m n) : ((m + n : ℚ) : α) = m + n 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (m n : ℚ)
Goal: ↑(m + n) = ↑m + ↑n
-- Rat.cast_sub
@[simp, norm_cast]
theorem cast_sub [CharZero α] (m n) : ((m - n : ℚ) : α) = m - n 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (m n : ℚ)
Goal: ↑(m - n) = ↑m - ↑n
-- Rat.cast_mul
@[simp, norm_cast]
theorem cast_mul [CharZero α] (m n) : ((m * n : ℚ) : α) = m * n 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (m n : ℚ)
Goal: ↑(m * n) = ↑m * ↑n
-- Rat.coe_cast_hom
@[simp]
theorem coe_cast_hom : ⇑(castHom α) = ((↑) : ℚ → α) 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α]
Goal: ⇑(Rat.castHom α) = Rat.cast
-- Rat.cast_inv
@[simp, norm_cast]
theorem cast_inv (n) : ((n⁻¹ : ℚ) : α) = (n : α)⁻¹ 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (n : ℚ)
Goal: ↑n⁻¹ = (↑n)⁻¹
-- Rat.cast_div
@[simp, norm_cast]
theorem cast_div (m n) : ((m / n : ℚ) : α) = m / n 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (m n : ℚ)
Goal: ↑(m / n) = ↑m / ↑n
-- Rat.cast_zpow
@[simp, norm_cast]
theorem cast_zpow (q : ℚ) (n : ℤ) : ((q ^ n : ℚ) : α) = (q : α) ^ n 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (q : ℚ) (n : ℤ)
Goal: ↑(q ^ n) = ↑q ^ n
-- Rat.cast_mk
@[norm_cast]
theorem cast_mk (a b : ℤ) : (a /. b : α) = a / b 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (a b : ℤ)
Goal: ↑(Rat.divInt a b) = ↑a / ↑b
-- Rat.cast_pow
@[simp, norm_cast]
theorem cast_pow (q : ℚ) (k : ℕ) : ↑(q ^ k) = (q : α) ^ k 
Arguments: {α : Type u_3} [DivisionRing α] [CharZero α] (q : ℚ) (k : ℕ)
Goal: ↑(q ^ k) = ↑q ^ k
-- Cardinal.mkRat
theorem Cardinal.mkRat : #ℚ = ℵ₀ 
Goal: #ℚ = ℵ₀
-- Rat.sqrt_eq
theorem sqrt_eq (q : ℚ) : Rat.sqrt (q * q) = |q| 
Arguments: (q : ℚ)
Goal: Rat.sqrt (q * q) = |q|
-- Rat.exists_mul_self
theorem exists_mul_self (x : ℚ) : (∃ q, q * q = x) ↔ Rat.sqrt x * Rat.sqrt x = x 
Arguments: (x : ℚ)
Goal: (∃ q, q * q = x) ↔ Rat.sqrt x * Rat.sqrt x = x
-- Rat.sqrt_nonneg
lemma sqrt_nonneg (q : ℚ) : 0 ≤ Rat.sqrt q 
Arguments: (q : ℚ)
Goal: 0 ≤ Rat.sqrt q
-- Rat.sqrt_intCast
@[simp, norm_cast]
theorem sqrt_intCast (z : ℤ) : Rat.sqrt (z : ℚ) = Int.sqrt z 
Arguments: (z : ℤ)
Goal: Rat.sqrt ↑z = ↑(Int.sqrt z)
-- Rat.sqrt_natCast
@[simp, norm_cast]
theorem sqrt_natCast (n : ℕ) : Rat.sqrt (n : ℚ) = Nat.sqrt n 
Arguments: (n : ℕ)
Goal: Rat.sqrt ↑n = ↑n.sqrt
-- Rat.sqrt_ofNat
@[simp]
theorem sqrt_ofNat (n : ℕ) : Rat.sqrt (no_index (OfNat.ofNat n) : ℚ) = Nat.sqrt (OfNat.ofNat n) 
Arguments: (n : ℕ)
Goal: Rat.sqrt (OfNat.ofNat n) = ↑(Nat.sqrt (OfNat.ofNat n))
-- Rat.castHom_rat
@[simp]
theorem castHom_rat : castHom ℚ = RingHom.id ℚ 
Goal: Rat.castHom ℚ = RingHom.id ℚ
-- Rat.cast_pos_of_pos
theorem cast_pos_of_pos (hq : 0 < q) : (0 : K) < q 
Arguments: {q : ℚ} {K : Type u_5} [LinearOrderedField K] (hq : 0 < q)
Goal: 0 < ↑q
-- Rat.cast_strictMono
@[mono]
theorem cast_strictMono : StrictMono ((↑) : ℚ → K) 
Arguments: {K : Type u_5} [LinearOrderedField K]
Goal: StrictMono Rat.cast
-- Rat.cast_mono
@[mono]
theorem cast_mono : Monotone ((↑) : ℚ → K) 
Arguments: {K : Type u_5} [LinearOrderedField K]
Goal: Monotone Rat.cast
-- Rat.castOrderEmbedding_apply
@[simps!]
def castOrderEmbedding : ℚ ↪o K 
Arguments: {K : Type u_5} [LinearOrderedField K]
Goal: ∀ (a : ℚ), Rat.castOrderEmbedding a = ↑a
-- Rat.cast_le
@[simp, norm_cast] lemma cast_le : (p : K) ≤ q ↔ p ≤ q 
Arguments: {p q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: ↑p ≤ ↑q ↔ p ≤ q
-- Rat.cast_lt
@[simp, norm_cast] lemma cast_lt : (p : K) < q ↔ p < q 
Arguments: {p q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: ↑p < ↑q ↔ p < q
-- Rat.cast_nonneg
@[simp] lemma cast_nonneg : 0 ≤ (q : K) ↔ 0 ≤ q 
Arguments: {q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: 0 ≤ ↑q ↔ 0 ≤ q
-- Rat.cast_nonpos
@[simp] lemma cast_nonpos : (q : K) ≤ 0 ↔ q ≤ 0 
Arguments: {q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: ↑q ≤ 0 ↔ q ≤ 0
-- Rat.cast_pos
@[simp] lemma cast_pos : (0 : K) < q ↔ 0 < q 
Arguments: {q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: 0 < ↑q ↔ 0 < q
-- Rat.cast_lt_zero
@[simp] lemma cast_lt_zero : (q : K) < 0 ↔ q < 0 
Arguments: {q : ℚ} {K : Type u_5} [LinearOrderedField K]
Goal: ↑q < 0 ↔ q < 0
-- Rat.cast_min
@[simp, norm_cast]
lemma cast_min (p q : ℚ) : (↑(min p q) : K) = min (p : K) (q : K) 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: ↑(min p q) = min ↑p ↑q
-- Rat.cast_max
@[simp, norm_cast]
lemma cast_max (p q : ℚ) : (↑(max p q) : K) = max (p : K) (q : K) 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: ↑(max p q) = max ↑p ↑q
-- Rat.cast_abs
@[simp, norm_cast] lemma cast_abs (q : ℚ) : ((|q| : ℚ) : K) = |(q : K)| 
Arguments: {K : Type u_5} [LinearOrderedField K] (q : ℚ)
Goal: ↑|q| = |↑q|
-- Rat.preimage_cast_Icc
@[simp]
theorem preimage_cast_Icc (p q : ℚ) : (↑) ⁻¹' Icc (p : K) q = Icc p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Set.Icc ↑p ↑q = Set.Icc p q
-- Rat.preimage_cast_Ico
@[simp]
theorem preimage_cast_Ico (p q : ℚ) : (↑) ⁻¹' Ico (p : K) q = Ico p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Set.Ico ↑p ↑q = Set.Ico p q
-- Rat.preimage_cast_Ioc
@[simp]
theorem preimage_cast_Ioc (p q : ℚ) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Set.Ioc ↑p ↑q = Set.Ioc p q
-- Rat.preimage_cast_Ioo
@[simp]
theorem preimage_cast_Ioo (p q : ℚ) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Set.Ioo ↑p ↑q = Set.Ioo p q
-- Rat.preimage_cast_Ici
@[simp]
theorem preimage_cast_Ici (q : ℚ) : (↑) ⁻¹' Ici (q : K) = Ici q 
Arguments: {K : Type u_5} [LinearOrderedField K] (q : ℚ)
Goal: Rat.cast ⁻¹' Set.Ici ↑q = Set.Ici q
-- Rat.preimage_cast_Iic
@[simp]
theorem preimage_cast_Iic (q : ℚ) : (↑) ⁻¹' Iic (q : K) = Iic q 
Arguments: {K : Type u_5} [LinearOrderedField K] (q : ℚ)
Goal: Rat.cast ⁻¹' Set.Iic ↑q = Set.Iic q
-- Rat.preimage_cast_Ioi
@[simp]
theorem preimage_cast_Ioi (q : ℚ) : (↑) ⁻¹' Ioi (q : K) = Ioi q 
Arguments: {K : Type u_5} [LinearOrderedField K] (q : ℚ)
Goal: Rat.cast ⁻¹' Set.Ioi ↑q = Set.Ioi q
-- Rat.preimage_cast_Iio
@[simp]
theorem preimage_cast_Iio (q : ℚ) : (↑) ⁻¹' Iio (q : K) = Iio q 
Arguments: {K : Type u_5} [LinearOrderedField K] (q : ℚ)
Goal: Rat.cast ⁻¹' Set.Iio ↑q = Set.Iio q
-- Rat.preimage_cast_uIcc
@[simp]
theorem preimage_cast_uIcc (p q : ℚ) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Set.uIcc ↑p ↑q = Set.uIcc p q
-- Rat.preimage_cast_uIoc
@[simp]
theorem preimage_cast_uIoc (p q : ℚ) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q 
Arguments: {K : Type u_5} [LinearOrderedField K] (p q : ℚ)
Goal: Rat.cast ⁻¹' Ι ↑p ↑q = Ι p q
-- NNRat.cast_strictMono
theorem cast_strictMono : StrictMono ((↑) : ℚ≥0 → K) 
Arguments: {K : Type u_5} [LinearOrderedSemifield K]
Goal: StrictMono NNRat.cast
-- NNRat.cast_mono
@[mono]
theorem cast_mono : Monotone ((↑) : ℚ≥0 → K) 
Arguments: {K : Type u_5} [LinearOrderedSemifield K]
Goal: Monotone NNRat.cast
-- NNRat.castOrderEmbedding_apply
@[simps!]
def castOrderEmbedding : ℚ≥0 ↪o K 
Arguments: {K : Type u_5} [LinearOrderedSemifield K]
Goal: ∀ (a : ℚ≥0), NNRat.castOrderEmbedding a = ↑a
-- NNRat.cast_le
@[simp, norm_cast] lemma cast_le : (p : K) ≤ q ↔ p ≤ q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {p q : ℚ≥0}
Goal: ↑p ≤ ↑q ↔ p ≤ q
-- NNRat.cast_lt
@[simp, norm_cast] lemma cast_lt : (p : K) < q ↔ p < q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {p q : ℚ≥0}
Goal: ↑p < ↑q ↔ p < q
-- NNRat.cast_nonpos
@[simp] lemma cast_nonpos : (q : K) ≤ 0 ↔ q ≤ 0 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {q : ℚ≥0}
Goal: ↑q ≤ 0 ↔ q ≤ 0
-- NNRat.cast_pos
@[simp] lemma cast_pos : (0 : K) < q ↔ 0 < q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {q : ℚ≥0}
Goal: 0 < ↑q ↔ 0 < q
-- NNRat.cast_lt_zero
@[norm_cast] lemma cast_lt_zero : (q : K) < 0 ↔ q < 0 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {q : ℚ≥0}
Goal: ↑q < 0 ↔ q < 0
-- NNRat.not_cast_lt_zero
@[simp] lemma not_cast_lt_zero : ¬(q : K) < 0 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] {q : ℚ≥0}
Goal: ¬↑q < 0
-- NNRat.cast_min
@[simp, norm_cast] lemma cast_min (p q : ℚ≥0) : (↑(min p q) : K) = min (p : K) (q : K) 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: ↑(min p q) = min ↑p ↑q
-- NNRat.cast_max
@[simp, norm_cast] lemma cast_max (p q : ℚ≥0) : (↑(max p q) : K) = max (p : K) (q : K) 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: ↑(max p q) = max ↑p ↑q
-- NNRat.preimage_cast_Icc
@[simp]
theorem preimage_cast_Icc (p q : ℚ≥0) : (↑) ⁻¹' Icc (p : K) q = Icc p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Icc ↑p ↑q = Set.Icc p q
-- NNRat.preimage_cast_Ico
@[simp]
theorem preimage_cast_Ico (p q : ℚ≥0) : (↑) ⁻¹' Ico (p : K) q = Ico p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Ico ↑p ↑q = Set.Ico p q
-- NNRat.preimage_cast_Ioc
@[simp]
theorem preimage_cast_Ioc (p q : ℚ≥0) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Ioc ↑p ↑q = Set.Ioc p q
-- NNRat.preimage_cast_Ioo
@[simp]
theorem preimage_cast_Ioo (p q : ℚ≥0) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Ioo ↑p ↑q = Set.Ioo p q
-- NNRat.preimage_cast_Ici
@[simp]
theorem preimage_cast_Ici (p : ℚ≥0) : (↑) ⁻¹' Ici (p : K) = Ici p 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Ici ↑p = Set.Ici p
-- NNRat.preimage_cast_Iic
@[simp]
theorem preimage_cast_Iic (p : ℚ≥0) : (↑) ⁻¹' Iic (p : K) = Iic p 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Iic ↑p = Set.Iic p
-- NNRat.preimage_cast_Ioi
@[simp]
theorem preimage_cast_Ioi (p : ℚ≥0) : (↑) ⁻¹' Ioi (p : K) = Ioi p 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Ioi ↑p = Set.Ioi p
-- NNRat.preimage_cast_Iio
@[simp]
theorem preimage_cast_Iio (p : ℚ≥0) : (↑) ⁻¹' Iio (p : K) = Iio p 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.Iio ↑p = Set.Iio p
-- NNRat.preimage_cast_uIcc
@[simp]
theorem preimage_cast_uIcc (p q : ℚ≥0) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Set.uIcc ↑p ↑q = Set.uIcc p q
-- NNRat.preimage_cast_uIoc
@[simp]
theorem preimage_cast_uIoc (p q : ℚ≥0) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q 
Arguments: {K : Type u_5} [LinearOrderedSemifield K] (p q : ℚ≥0)
Goal: NNRat.cast ⁻¹' Ι ↑p ↑q = Ι p q
-- Stream'.Seq.val_cons
@[simp]
theorem val_cons (s : Seq α) (x : α) : (cons x s).val = some x::s.val 
Arguments: {α : Type u} (s : Stream'.Seq α) (x : α)
Goal: ↑(Stream'.Seq.cons x s) = Stream'.cons (some x) ↑s
-- Stream'.Seq.get?_mk
@[simp]
theorem get?_mk (f hf) : @get? α ⟨f, hf⟩ = f 
Arguments: {α : Type u} (f : Stream' (Option α)) (hf : f.IsSeq)
Goal: Stream'.Seq.get? ⟨f, hf⟩ = f
-- Stream'.Seq.get?_nil
@[simp]
theorem get?_nil (n : ℕ) : (@nil α).get? n = none 
Arguments: {α : Type u} (n : ℕ)
Goal: Stream'.Seq.nil.get? n = none
-- Stream'.Seq.get?_cons_zero
@[simp]
theorem get?_cons_zero (a : α) (s : Seq α) : (cons a s).get? 0 = some a 
Arguments: {α : Type u} (a : α) (s : Stream'.Seq α)
Goal: (Stream'.Seq.cons a s).get? 0 = some a