ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.pairEquiv_apply
@[simps (config := .asFn)]
def pairEquiv : ℕ × ℕ ≃ ℕ 
Goal: ⇑Nat.pairEquiv = Function.uncurry Nat.pair
-- Nat.surjective_unpair
theorem surjective_unpair : Surjective unpair 
Goal: Function.Surjective Nat.unpair
-- Nat.pair_eq_pair
@[simp]
theorem pair_eq_pair {a b c d : ℕ} : pair a b = pair c d ↔ a = c ∧ b = d 
Arguments: {a b c d : ℕ}
Goal: Nat.pair a b = Nat.pair c d ↔ a = c ∧ b = d
-- Nat.unpair_lt
theorem unpair_lt {n : ℕ} (n1 : 1 ≤ n) : (unpair n).1 < n 
Arguments: {n : ℕ} (n1 : 1 ≤ n)
Goal: (Nat.unpair n).1 < n
-- Nat.unpair_zero
@[simp]
theorem unpair_zero : unpair 0 = 0 
Goal: Nat.unpair 0 = 0
-- Nat.unpair_left_le
theorem unpair_left_le : ∀ n : ℕ, (unpair n).1 ≤ n
  
Arguments: (n : ℕ)
Goal: (Nat.unpair n).1 ≤ n
-- Nat.left_le_pair
theorem left_le_pair (a b : ℕ) : a ≤ pair a b 
Arguments: (a b : ℕ)
Goal: a ≤ Nat.pair a b
-- Nat.right_le_pair
theorem right_le_pair (a b : ℕ) : b ≤ pair a b 
Arguments: (a b : ℕ)
Goal: b ≤ Nat.pair a b
-- Nat.unpair_right_le
theorem unpair_right_le (n : ℕ) : (unpair n).2 ≤ n 
Arguments: (n : ℕ)
Goal: (Nat.unpair n).2 ≤ n
-- Nat.pair_lt_pair_left
theorem pair_lt_pair_left {a₁ a₂} (b) (h : a₁ < a₂) : pair a₁ b < pair a₂ b 
Arguments: {a₁ a₂ : ℕ} (b : ℕ) (h : a₁ < a₂)
Goal: Nat.pair a₁ b < Nat.pair a₂ b
-- Nat.pair_lt_pair_right
theorem pair_lt_pair_right (a) {b₁ b₂} (h : b₁ < b₂) : pair a b₁ < pair a b₂ 
Arguments: (a : ℕ) {b₁ b₂ : ℕ} (h : b₁ < b₂)
Goal: Nat.pair a b₁ < Nat.pair a b₂
-- Nat.pair_lt_max_add_one_sq
theorem pair_lt_max_add_one_sq (m n : ℕ) : pair m n < (max m n + 1) ^ 2 
Arguments: (m n : ℕ)
Goal: Nat.pair m n < (max m n + 1) ^ 2
-- Nat.max_sq_add_min_le_pair
theorem max_sq_add_min_le_pair (m n : ℕ) : max m n ^ 2 + min m n ≤ pair m n 
Arguments: (m n : ℕ)
Goal: max m n ^ 2 + min m n ≤ Nat.pair m n
-- Nat.add_le_pair
theorem add_le_pair (m n : ℕ) : m + n ≤ pair m n 
Arguments: (m n : ℕ)
Goal: m + n ≤ Nat.pair m n
-- Nat.unpair_add_le
theorem unpair_add_le (n : ℕ) : (unpair n).1 + (unpair n).2 ≤ n 
Arguments: (n : ℕ)
Goal: (Nat.unpair n).1 + (Nat.unpair n).2 ≤ n
-- iSup_unpair
theorem iSup_unpair {α} [CompleteLattice α] (f : ℕ → ℕ → α) :
    ⨆ n : ℕ, f n.unpair.1 n.unpair.2 = ⨆ (i : ℕ) (j : ℕ), f i j 
Arguments: {α : Type u_1} [CompleteLattice α] (f : ℕ → ℕ → α)
Goal: ⨆ n, f (Nat.unpair n).1 (Nat.unpair n).2 = ⨆ i, ⨆ j, f i j
-- iInf_unpair
theorem iInf_unpair {α} [CompleteLattice α] (f : ℕ → ℕ → α) :
    ⨅ n : ℕ, f n.unpair.1 n.unpair.2 = ⨅ (i : ℕ) (j : ℕ), f i j 
Arguments: {α : Type u_1} [CompleteLattice α] (f : ℕ → ℕ → α)
Goal: ⨅ n, f (Nat.unpair n).1 (Nat.unpair n).2 = ⨅ i, ⨅ j, f i j
-- Set.iUnion_unpair_prod
theorem iUnion_unpair_prod {α β} {s : ℕ → Set α} {t : ℕ → Set β} :
    ⋃ n : ℕ, s n.unpair.fst ×ˢ t n.unpair.snd = (⋃ n, s n) ×ˢ ⋃ n, t n 
Arguments: {α : Type u_1} {β : Type u_2} {s : ℕ → Set α} {t : ℕ → Set β}
Goal: ⋃ n, s (Nat.unpair n).1 ×ˢ t (Nat.unpair n).2 = (⋃ n, s n) ×ˢ ⋃ n, t n
-- Set.iUnion_unpair
theorem iUnion_unpair {α} (f : ℕ → ℕ → Set α) :
    ⋃ n : ℕ, f n.unpair.1 n.unpair.2 = ⋃ (i : ℕ) (j : ℕ), f i j 
Arguments: {α : Type u_1} (f : ℕ → ℕ → Set α)
Goal: ⋃ n, f (Nat.unpair n).1 (Nat.unpair n).2 = ⋃ i, ⋃ j, f i j
-- Set.iInter_unpair
theorem iInter_unpair {α} (f : ℕ → ℕ → Set α) :
    ⋂ n : ℕ, f n.unpair.1 n.unpair.2 = ⋂ (i : ℕ) (j : ℕ), f i j 
Arguments: {α : Type u_1} (f : ℕ → ℕ → Set α)
Goal: ⋂ n, f (Nat.unpair n).1 (Nat.unpair n).2 = ⋂ i, ⋂ j, f i j
-- Nat.cast_inv_le_one
lemma cast_inv_le_one : ∀ n : ℕ, (n⁻¹ : α) ≤ 1
  
Arguments: {α : Type u_1} [LinearOrderedSemifield α] (n : ℕ)
Goal: (↑n)⁻¹ ≤ 1
-- Nat.cast_div_le
theorem cast_div_le {m n : ℕ} : ((m / n : ℕ) : α) ≤ m / n 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] {m n : ℕ}
Goal: ↑(m / n) ≤ ↑m / ↑n
-- Nat.inv_pos_of_nat
theorem inv_pos_of_nat {n : ℕ} : 0 < ((n : α) + 1)⁻¹ 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] {n : ℕ}
Goal: 0 < (↑n + 1)⁻¹
-- Nat.one_div_pos_of_nat
theorem one_div_pos_of_nat {n : ℕ} : 0 < 1 / ((n : α) + 1) 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] {n : ℕ}
Goal: 0 < 1 / (↑n + 1)
-- Nat.one_div_le_one_div
theorem one_div_le_one_div {n m : ℕ} (h : n ≤ m) : 1 / ((m : α) + 1) ≤ 1 / ((n : α) + 1) 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] {n m : ℕ} (h : n ≤ m)
Goal: 1 / (↑m + 1) ≤ 1 / (↑n + 1)
-- Nat.one_div_lt_one_div
theorem one_div_lt_one_div {n m : ℕ} (h : n < m) : 1 / ((m : α) + 1) < 1 / ((n : α) + 1) 
Arguments: {α : Type u_1} [LinearOrderedSemifield α] {n m : ℕ} (h : n < m)
Goal: 1 / (↑m + 1) < 1 / (↑n + 1)
-- Nat.mono_cast
@[mono]
theorem mono_cast : Monotone (Nat.cast : ℕ → α) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α]
Goal: Monotone Nat.cast
-- Nat.cast_le_cast
@[deprecated mono_cast (since := "2024-02-10")]
theorem cast_le_cast {a b : ℕ} (h : a ≤ b) : (a : α) ≤ b 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] {a b : ℕ} (h : a ≤ b)
Goal: ↑a ≤ ↑b
-- GCongr.natCast_le_natCast
@[gcongr]
theorem _root_.GCongr.natCast_le_natCast {a b : ℕ} (h : a ≤ b) : (a : α) ≤ b 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] {a b : ℕ} (h : a ≤ b)
Goal: ↑a ≤ ↑b
-- Nat.cast_nonneg'
@[simp low]
theorem cast_nonneg' (n : ℕ) : 0 ≤ (n : α) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] (n : ℕ)
Goal: 0 ≤ ↑n
-- Nat.ofNat_nonneg'
-- See note [no_index around OfNat.ofNat]
@[simp low]
theorem ofNat_nonneg' (n : ℕ) [n.AtLeastTwo] : 0 ≤ (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] (n : ℕ) [n.AtLeastTwo]
Goal: 0 ≤ OfNat.ofNat n
-- Nat.cast_add_one_pos
theorem cast_add_one_pos (n : ℕ) : 0 < (n : α) + 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [NeZero 1] (n : ℕ)
Goal: 0 < ↑n + 1
-- Nat.cast_pos'
@[simp low]
theorem cast_pos' {n : ℕ} : (0 : α) < n ↔ 0 < n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [NeZero 1] {n : ℕ}
Goal: 0 < ↑n ↔ 0 < n
-- Nat.strictMono_cast
theorem strictMono_cast : StrictMono (Nat.cast : ℕ → α) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α]
Goal: StrictMono Nat.cast
-- Nat.castOrderEmbedding_apply
@[simps! (config := .asFn)]
def castOrderEmbedding : ℕ ↪o α 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α]
Goal: ⇑Nat.castOrderEmbedding = Nat.cast
-- Nat.cast_le
@[simp, norm_cast]
theorem cast_le : (m : α) ≤ n ↔ m ≤ n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ}
Goal: ↑m ≤ ↑n ↔ m ≤ n
-- Nat.cast_lt
@[simp, norm_cast, mono]
theorem cast_lt : (m : α) < n ↔ m < n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ}
Goal: ↑m < ↑n ↔ m < n
-- Nat.one_lt_cast
@[simp, norm_cast]
theorem one_lt_cast : 1 < (n : α) ↔ 1 < n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ}
Goal: 1 < ↑n ↔ 1 < n
-- Nat.one_le_cast
@[simp, norm_cast]
theorem one_le_cast : 1 ≤ (n : α) ↔ 1 ≤ n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ}
Goal: 1 ≤ ↑n ↔ 1 ≤ n
-- Nat.cast_lt_one
@[simp, norm_cast]
theorem cast_lt_one : (n : α) < 1 ↔ n = 0 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ}
Goal: ↑n < 1 ↔ n = 0
-- Nat.cast_le_one
@[simp, norm_cast]
theorem cast_le_one : (n : α) ≤ 1 ↔ n ≤ 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ}
Goal: ↑n ≤ 1 ↔ n ≤ 1
-- Nat.ofNat_le
theorem ofNat_le :
    (no_index (OfNat.ofNat m : α)) ≤ (no_index (OfNat.ofNat n)) ↔
      (OfNat.ofNat m : ℕ) ≤ OfNat.ofNat n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [m.AtLeastTwo] [n.AtLeastTwo]
Goal: OfNat.ofNat m ≤ OfNat.ofNat n ↔ OfNat.ofNat m ≤ OfNat.ofNat n
-- Nat.ofNat_lt
theorem ofNat_lt :
    (no_index (OfNat.ofNat m : α)) < (no_index (OfNat.ofNat n)) ↔
      (OfNat.ofNat m : ℕ) < OfNat.ofNat n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [m.AtLeastTwo] [n.AtLeastTwo]
Goal: OfNat.ofNat m < OfNat.ofNat n ↔ OfNat.ofNat m < OfNat.ofNat n
-- Nat.ofNat_le_cast
@[simp]
theorem ofNat_le_cast : (no_index (OfNat.ofNat m : α)) ≤ n ↔ (OfNat.ofNat m : ℕ) ≤ n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [m.AtLeastTwo]
Goal: OfNat.ofNat m ≤ ↑n ↔ OfNat.ofNat m ≤ n
-- Nat.ofNat_lt_cast
@[simp]
theorem ofNat_lt_cast : (no_index (OfNat.ofNat m : α)) < n ↔ (OfNat.ofNat m : ℕ) < n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [m.AtLeastTwo]
Goal: OfNat.ofNat m < ↑n ↔ OfNat.ofNat m < n
-- Nat.cast_le_ofNat
@[simp]
theorem cast_le_ofNat : (m : α) ≤ (no_index (OfNat.ofNat n)) ↔ m ≤ OfNat.ofNat n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [n.AtLeastTwo]
Goal: ↑m ≤ OfNat.ofNat n ↔ m ≤ OfNat.ofNat n
-- Nat.cast_lt_ofNat
@[simp]
theorem cast_lt_ofNat : (m : α) < (no_index (OfNat.ofNat n)) ↔ m < OfNat.ofNat n 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {m n : ℕ} [n.AtLeastTwo]
Goal: ↑m < OfNat.ofNat n ↔ m < OfNat.ofNat n
-- Nat.one_lt_ofNat
@[simp]
theorem one_lt_ofNat : 1 < (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ} [n.AtLeastTwo]
Goal: 1 < OfNat.ofNat n
-- Nat.one_le_ofNat
@[simp]
theorem one_le_ofNat : 1 ≤ (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ} [n.AtLeastTwo]
Goal: 1 ≤ OfNat.ofNat n
-- Nat.not_ofNat_le_one
@[simp]
theorem not_ofNat_le_one : ¬(no_index (OfNat.ofNat n : α)) ≤ 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ} [n.AtLeastTwo]
Goal: ¬OfNat.ofNat n ≤ 1
-- Nat.not_ofNat_lt_one
@[simp]
theorem not_ofNat_lt_one : ¬(no_index (OfNat.ofNat n : α)) < 1 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [CharZero α] {n : ℕ} [n.AtLeastTwo]
Goal: ¬OfNat.ofNat n < 1
-- NeZero.nat_of_injective
theorem NeZero.nat_of_injective {n : ℕ} [h : NeZero (n : R)] [RingHomClass F R S] {f : F}
    (hf : Function.Injective f) : NeZero (n : S) 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [NonAssocSemiring R] [NonAssocSemiring S] [FunLike F R S] {n : ℕ} [h : NeZero ↑n] [RingHomClass F R S] {f : F} (hf : Function.Injective ⇑f)
Goal: NeZero ↑n
-- Nat.cast_div
@[simp]
theorem cast_div [DivisionSemiring α] {m n : ℕ} (n_dvd : n ∣ m) (hn : (n : α) ≠ 0) :
    ((m / n : ℕ) : α) = m / n 
Arguments: {α : Type u_1} [DivisionSemiring α] {m n : ℕ} (n_dvd : n ∣ m) (hn : ↑n ≠ 0)
Goal: ↑(m / n) = ↑m / ↑n
-- Nat.cast_div_div_div_cancel_right
theorem cast_div_div_div_cancel_right [DivisionSemiring α] [CharZero α] {m n d : ℕ}
    (hn : d ∣ n) (hm : d ∣ m) :
    (↑(m / d) : α) / (↑(n / d) : α) = (m : α) / n 
Arguments: {α : Type u_1} [DivisionSemiring α] [CharZero α] {m n d : ℕ} (hn : d ∣ n) (hm : d ∣ m)
Goal: ↑(m / d) / ↑(n / d) = ↑m / ↑n
-- MvQPF.corecF_eq
theorem corecF_eq {α : TypeVec n} {β : Type u} (g : β → F (α.append1 β)) (x : β) :
    M.dest q.P (corecF g x) = appendFun id (corecF g) <$$> repr (g x) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : β → F (α ::: β)) (x : β)
Goal: MvPFunctor.M.dest (MvQPF.P F) (MvQPF.corecF g x) = (TypeVec.id ::: MvQPF.corecF g) <$$> MvQPF.repr (g x)
-- MvQPF.Cofix.dest_corec
theorem Cofix.dest_corec {α : TypeVec n} {β : Type u} (g : β → F (α.append1 β)) (x : β) :
    Cofix.dest (Cofix.corec g x) = appendFun id (Cofix.corec g) <$$> g x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : β → F (α ::: β)) (x : β)
Goal: (MvQPF.Cofix.corec g x).dest = (TypeVec.id ::: MvQPF.Cofix.corec g) <$$> g x
-- _private.Mathlib.Data.QPF.Multivariate.Constructions.Cofix.0.MvQPF.Cofix.bisim_aux
private theorem Cofix.bisim_aux {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop) (h' : ∀ x, r x x)
    (h : ∀ x y, r x y →
      appendFun id (Quot.mk r) <$$> Cofix.dest x = appendFun id (Quot.mk r) <$$> Cofix.dest y) :
    ∀ x y, r x y → x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (r : MvQPF.Cofix F α → MvQPF.Cofix F α → Prop) (h' : ∀ (x : MvQPF.Cofix F α), r x x) (h : ∀ (x y : MvQPF.Cofix F α), r x y → (TypeVec.id ::: Quot.mk r) <$$> x.dest = (TypeVec.id ::: Quot.mk r) <$$> y.dest) (x y : MvQPF.Cofix F α)
Goal: r x y → x = y
-- MvQPF.Cofix.bisim_rel
theorem Cofix.bisim_rel {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop)
    (h : ∀ x y, r x y →
      appendFun id (Quot.mk r) <$$> Cofix.dest x = appendFun id (Quot.mk r) <$$> Cofix.dest y) :
    ∀ x y, r x y → x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (r : MvQPF.Cofix F α → MvQPF.Cofix F α → Prop) (h : ∀ (x y : MvQPF.Cofix F α), r x y → (TypeVec.id ::: Quot.mk r) <$$> x.dest = (TypeVec.id ::: Quot.mk r) <$$> y.dest) (x y : MvQPF.Cofix F α)
Goal: r x y → x = y
-- MvQPF.Cofix.bisim
theorem Cofix.bisim {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop)
    (h : ∀ x y, r x y → LiftR (RelLast α r (i := _)) (Cofix.dest x) (Cofix.dest y)) :
    ∀ x y, r x y → x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (r : MvQPF.Cofix F α → MvQPF.Cofix F α → Prop) (h : ∀ (x y : MvQPF.Cofix F α), r x y → MvFunctor.LiftR (fun {i} => α.RelLast r) x.dest y.dest) (x y : MvQPF.Cofix F α)
Goal: r x y → x = y
-- MvQPF.Cofix.bisim₂
theorem Cofix.bisim₂ {α : TypeVec n} (r : Cofix F α → Cofix F α → Prop)
    (h : ∀ x y, r x y → LiftR' (RelLast' α r) (Cofix.dest x) (Cofix.dest y)) :
    ∀ x y, r x y → x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (r : MvQPF.Cofix F α → MvQPF.Cofix F α → Prop) (h : ∀ (x y : MvQPF.Cofix F α), r x y → MvFunctor.LiftR' (α.RelLast' r) x.dest y.dest) (x y : MvQPF.Cofix F α)
Goal: r x y → x = y
-- MvQPF.Cofix.bisim'
theorem Cofix.bisim' {α : TypeVec n} {β : Type*} (Q : β → Prop) (u v : β → Cofix F α)
    (h : ∀ x, Q x → ∃ a f' f₀ f₁,
      Cofix.dest (u x) = q.abs ⟨a, q.P.appendContents f' f₀⟩ ∧
        Cofix.dest (v x) = q.abs ⟨a, q.P.appendContents f' f₁⟩ ∧
          ∀ i, ∃ x', Q x' ∧ f₀ i = u x' ∧ f₁ i = v x') :
    ∀ x, Q x → u x = v x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u_1} (Q : β → Prop) (u v : β → MvQPF.Cofix F α) (h :
  ∀ (x : β),
    Q x →
      ∃ a f' f₀ f₁,
        (u x).dest = MvQPF.abs ⟨a, (MvQPF.P F).appendContents f' f₀⟩ ∧
          (v x).dest = MvQPF.abs ⟨a, (MvQPF.P F).appendContents f' f₁⟩ ∧
            ∀ (i : (MvQPF.P F).last.B a), ∃ x', Q x' ∧ f₀ i = u x' ∧ f₁ i = v x') (x : β)
Goal: Q x → u x = v x
-- MvQPF.Cofix.mk_dest
theorem Cofix.mk_dest {α : TypeVec n} (x : Cofix F α) : Cofix.mk (Cofix.dest x) = x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : MvQPF.Cofix F α)
Goal: MvQPF.Cofix.mk x.dest = x
-- MvQPF.Cofix.dest_mk
theorem Cofix.dest_mk {α : TypeVec n} (x : F (α.append1 <| Cofix F α)) :
    Cofix.dest (Cofix.mk x) = x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : F (α ::: MvQPF.Cofix F α))
Goal: (MvQPF.Cofix.mk x).dest = x
-- MvQPF.Cofix.ext
theorem Cofix.ext {α : TypeVec n} (x y : Cofix F α) (h : x.dest = y.dest) : x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x y : MvQPF.Cofix F α) (h : x.dest = y.dest)
Goal: x = y
-- MvQPF.Cofix.ext_mk
theorem Cofix.ext_mk {α : TypeVec n} (x y : F (α ::: Cofix F α)) (h : Cofix.mk x = Cofix.mk y) :
    x = y 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x y : F (α ::: MvQPF.Cofix F α)) (h : MvQPF.Cofix.mk x = MvQPF.Cofix.mk y)
Goal: x = y
-- MvQPF.liftR_map
theorem liftR_map {α β : TypeVec n} {F' : TypeVec n → Type u} [MvFunctor F'] [LawfulMvFunctor F']
    (R : β ⊗ β ⟹ «repeat» n Prop) (x : F' α) (f g : α ⟹ β) (h : α ⟹ Subtype_ R)
    (hh : subtypeVal _ ⊚ h = (f ⊗' g) ⊚ prod.diag) : LiftR' R (f <$$> x) (g <$$> x) 
Arguments: {n : ℕ} {α β : TypeVec.{u_1} n} {F' : TypeVec.{u_1} n → Type u} [MvFunctor F'] [LawfulMvFunctor F'] (R : β ⊗ β ⟹ TypeVec.repeat n Prop) (x : F' α) (f g : α ⟹ β) (h : α ⟹ TypeVec.Subtype_ R) (hh : TypeVec.subtypeVal R ⊚ h = (f ⊗' g) ⊚ TypeVec.prod.diag)
Goal: MvFunctor.LiftR' R (f <$$> x) (g <$$> x)
-- MvQPF.liftR_map_last
theorem liftR_map_last [lawful : LawfulMvFunctor F]
    {α : TypeVec n} {ι ι'} (R : ι' → ι' → Prop)
    (x : F (α ::: ι)) (f g : ι → ι') (hh : ∀ x : ι, R (f x) (g x)) :
    LiftR' (RelLast' _ R) ((id ::: f) <$$> x) ((id ::: g) <$$> x) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] [lawful : LawfulMvFunctor F] {α : TypeVec.{u} n} {ι ι' : Type u} (R : ι' → ι' → Prop) (x : F (α ::: ι)) (f g : ι → ι') (hh : ∀ (x : ι), R (f x) (g x))
Goal: MvFunctor.LiftR' (α.RelLast' R) ((TypeVec.id ::: f) <$$> x) ((TypeVec.id ::: g) <$$> x)
-- MvQPF.liftR_map_last'
theorem liftR_map_last' [LawfulMvFunctor F] {α : TypeVec n} {ι} (R : ι → ι → Prop) (x : F (α ::: ι))
    (f : ι → ι) (hh : ∀ x : ι, R (f x) x) : LiftR' (RelLast' _ R) ((id ::: f) <$$> x) x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] [LawfulMvFunctor F] {α : TypeVec.{u} n} {ι : Type u} (R : ι → ι → Prop) (x : F (α ::: ι)) (f : ι → ι) (hh : ∀ (x : ι), R (f x) x)
Goal: MvFunctor.LiftR' (α.RelLast' R) ((TypeVec.id ::: f) <$$> x) x
-- MvQPF.Cofix.abs_repr
theorem Cofix.abs_repr {α} (x : Cofix F α) : Quot.mk _ (Cofix.repr x) = x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (x : MvQPF.Cofix F α)
Goal: Quot.mk MvQPF.Mcongr x.repr = x
-- MvQPF.corec_roll
theorem corec_roll {α : TypeVec n} {X Y} {x₀ : X} (f : X → Y) (g : Y → F (α ::: X)) :
    Cofix.corec (g ∘ f) x₀ = Cofix.corec (MvFunctor.map (id ::: f) ∘ g) (f x₀) 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {X Y : Type u} {x₀ : X} (f : X → Y) (g : Y → F (α ::: X))
Goal: MvQPF.Cofix.corec (g ∘ f) x₀ = MvQPF.Cofix.corec (MvFunctor.map (TypeVec.id ::: f) ∘ g) (f x₀)
-- MvQPF.Cofix.dest_corec'
theorem Cofix.dest_corec' {α : TypeVec.{u} n} {β : Type u}
    (g : β → F (α.append1 (Cofix F α ⊕ β))) (x : β) :
    Cofix.dest (Cofix.corec' g x) =
      appendFun id (Sum.elim _root_.id (Cofix.corec' g)) <$$> g x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : β → F (α ::: (MvQPF.Cofix F α ⊕ β))) (x : β)
Goal: (MvQPF.Cofix.corec' g x).dest = (TypeVec.id ::: Sum.elim id (MvQPF.Cofix.corec' g)) <$$> g x
-- MvQPF.Cofix.dest_corec₁
theorem Cofix.dest_corec₁ {α : TypeVec n} {β : Type u}
    (g : ∀ {X}, (Cofix F α → X) → (β → X) → β → F (α.append1 X)) (x : β)
    (h : ∀ (X Y) (f : Cofix F α → X) (f' : β → X) (k : X → Y),
      g (k ∘ f) (k ∘ f') x = (id ::: k) <$$> g f f' x) :
    Cofix.dest (Cofix.corec₁ (@g) x) = g id (Cofix.corec₁ @g) x 
Arguments: {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} {β : Type u} (g : {X : Type u} → (MvQPF.Cofix F α → X) → (β → X) → β → F (α ::: X)) (x : β) (h :
  ∀ (X Y : Type u) (f : MvQPF.Cofix F α → X) (f' : β → X) (k : X → Y),
    g (k ∘ f) (k ∘ f') x = (TypeVec.id ::: k) <$$> g f f' x)
Goal: (MvQPF.Cofix.corec₁ g x).dest = g id (MvQPF.Cofix.corec₁ g) x
-- Nat.cast_withTop
theorem Nat.cast_withTop (n : ℕ) :  Nat.cast n = WithTop.some n 
Arguments: (n : ℕ)
Goal: ↑n = ↑n
-- Nat.cast_withBot
theorem Nat.cast_withBot (n : ℕ) : Nat.cast n = WithBot.some n 
Arguments: (n : ℕ)
Goal: ↑n = ↑n
-- Nat.cast_nonneg
@[simp]
theorem cast_nonneg {α} [OrderedSemiring α] (n : ℕ) : 0 ≤ (n : α) 
Arguments: {α : Type u_3} [OrderedSemiring α] (n : ℕ)
Goal: 0 ≤ ↑n
-- Nat.ofNat_nonneg
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_nonneg {α} [OrderedSemiring α] (n : ℕ) [n.AtLeastTwo] :
    0 ≤ (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_3} [OrderedSemiring α] (n : ℕ) [n.AtLeastTwo]
Goal: 0 ≤ OfNat.ofNat n
-- Nat.cast_min
@[simp, norm_cast]
theorem cast_min {α} [LinearOrderedSemiring α] {a b : ℕ} : ((min a b : ℕ) : α) = min (a : α) b 
Arguments: {α : Type u_3} [LinearOrderedSemiring α] {a b : ℕ}
Goal: ↑(min a b) = min ↑a ↑b
-- Nat.cast_max
@[simp, norm_cast]
theorem cast_max {α} [LinearOrderedSemiring α] {a b : ℕ} : ((max a b : ℕ) : α) = max (a : α) b 
Arguments: {α : Type u_3} [LinearOrderedSemiring α] {a b : ℕ}
Goal: ↑(max a b) = max ↑a ↑b
-- Nat.cast_pos
@[simp]
theorem cast_pos {α} [OrderedSemiring α] [Nontrivial α] {n : ℕ} : (0 : α) < n ↔ 0 < n 
Arguments: {α : Type u_3} [OrderedSemiring α] [Nontrivial α] {n : ℕ}
Goal: 0 < ↑n ↔ 0 < n
-- Nat.ofNat_pos'
-- See note [no_index around OfNat.ofNat]
@[simp low]
theorem ofNat_pos' {n : ℕ} [n.AtLeastTwo] : 0 < (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] [PartialOrder α] [CovariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] [ZeroLEOneClass α] [NeZero 1] {n : ℕ} [n.AtLeastTwo]
Goal: 0 < OfNat.ofNat n
-- Nat.ofNat_pos
-- See note [no_index around OfNat.ofNat]
@[simp]
theorem ofNat_pos {α} [OrderedSemiring α] [Nontrivial α] {n : ℕ} [n.AtLeastTwo] :
    0 < (no_index (OfNat.ofNat n : α)) 
Arguments: {α : Type u_3} [OrderedSemiring α] [Nontrivial α] {n : ℕ} [n.AtLeastTwo]
Goal: 0 < OfNat.ofNat n
-- Nat.cast_tsub
@[simp, norm_cast]
theorem cast_tsub [CanonicallyOrderedCommSemiring α] [Sub α] [OrderedSub α]
    [ContravariantClass α α (· + ·) (· ≤ ·)] (m n : ℕ) : ↑(m - n) = (m - n : α) 
Arguments: {α : Type u_1} [CanonicallyOrderedCommSemiring α] [Sub α] [OrderedSub α] [ContravariantClass α α (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1] (m n : ℕ)
Goal: ↑(m - n) = ↑m - ↑n
-- Nat.abs_cast
@[simp, norm_cast]
theorem abs_cast [LinearOrderedRing α] (a : ℕ) : |(a : α)| = a 
Arguments: {α : Type u_1} [LinearOrderedRing α] (a : ℕ)
Goal: |↑a| = ↑a
-- Nat.abs_ofNat
@[simp]
theorem abs_ofNat [LinearOrderedRing α] (n : ℕ) [n.AtLeastTwo] :
    |(no_index (OfNat.ofNat n : α))| = OfNat.ofNat n 
Arguments: {α : Type u_1} [LinearOrderedRing α] (n : ℕ) [n.AtLeastTwo]
Goal: |OfNat.ofNat n| = OfNat.ofNat n
-- Nat.coe_castAddMonoidHom
@[simp]
theorem coe_castAddMonoidHom [AddMonoidWithOne α] : (castAddMonoidHom α : ℕ → α) = Nat.cast 
Arguments: {α : Type u_1} [AddMonoidWithOne α]
Goal: ⇑(Nat.castAddMonoidHom α) = Nat.cast