ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Quot.liftOn_mk
theorem liftOn_mk (a : α) (f : α → γ) (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) :
    Quot.liftOn (Quot.mk r a) f h = f a 
Arguments: {α : Sort u_1} {γ : Sort u_4} {r : α → α → Prop} (a : α) (f : α → γ) (h : ∀ (a₁ a₂ : α), r a₁ a₂ → f a₁ = f a₂)
Goal: (Quot.mk r a).liftOn f h = f a
-- Quot.surjective_lift
@[simp] theorem surjective_lift {f : α → γ} (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) :
    Function.Surjective (lift f h) ↔ Function.Surjective f 
Arguments: {α : Sort u_1} {γ : Sort u_4} {r : α → α → Prop} {f : α → γ} (h : ∀ (a₁ a₂ : α), r a₁ a₂ → f a₁ = f a₂)
Goal: Function.Surjective (Quot.lift f h) ↔ Function.Surjective f
-- Quot.lift₂_mk
@[simp]
theorem lift₂_mk (f : α → β → γ) (hr : ∀ a b₁ b₂, s b₁ b₂ → f a b₁ = f a b₂)
    (hs : ∀ a₁ a₂ b, r a₁ a₂ → f a₁ b = f a₂ b)
    (a : α) (b : β) : Quot.lift₂ f hr hs (Quot.mk r a) (Quot.mk s b) = f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_4} {r : α → α → Prop} {s : β → β → Prop} (f : α → β → γ) (hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂) (hs : ∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b) (a : α) (b : β)
Goal: Quot.lift₂ f hr hs (Quot.mk r a) (Quot.mk s b) = f a b
-- Quot.liftOn₂_mk
@[simp]
theorem liftOn₂_mk (a : α) (b : β) (f : α → β → γ) (hr : ∀ a b₁ b₂, s b₁ b₂ → f a b₁ = f a b₂)
    (hs : ∀ a₁ a₂ b, r a₁ a₂ → f a₁ b = f a₂ b) :
    Quot.liftOn₂ (Quot.mk r a) (Quot.mk s b) f hr hs = f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_4} {r : α → α → Prop} {s : β → β → Prop} (a : α) (b : β) (f : α → β → γ) (hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → f a b₁ = f a b₂) (hs : ∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → f a₁ b = f a₂ b)
Goal: (Quot.mk r a).liftOn₂ (Quot.mk s b) f hr hs = f a b
-- Quot.map₂_mk
@[simp]
theorem map₂_mk (f : α → β → γ) (hr : ∀ a b₁ b₂, s b₁ b₂ → t (f a b₁) (f a b₂))
    (hs : ∀ a₁ a₂ b, r a₁ a₂ → t (f a₁ b) (f a₂ b)) (a : α) (b : β) :
    Quot.map₂ f hr hs (Quot.mk r a) (Quot.mk s b) = Quot.mk t (f a b) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_4} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} (f : α → β → γ) (hr : ∀ (a : α) (b₁ b₂ : β), s b₁ b₂ → t (f a b₁) (f a b₂)) (hs : ∀ (a₁ a₂ : α) (b : β), r a₁ a₂ → t (f a₁ b) (f a₂ b)) (a : α) (b : β)
Goal: Quot.map₂ f hr hs (Quot.mk r a) (Quot.mk s b) = Quot.mk t (f a b)
-- Quot.induction_on₂
@[elab_as_elim]
protected theorem induction_on₂ {δ : Quot r → Quot s → Prop} (q₁ : Quot r) (q₂ : Quot s)
    (h : ∀ a b, δ (Quot.mk r a) (Quot.mk s b)) : δ q₁ q₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {r : α → α → Prop} {s : β → β → Prop} {δ : Quot r → Quot s → Prop} (q₁ : Quot r) (q₂ : Quot s) (h : ∀ (a : α) (b : β), δ (Quot.mk r a) (Quot.mk s b))
Goal: δ q₁ q₂
-- Quot.induction_on₃
@[elab_as_elim]
protected theorem induction_on₃ {δ : Quot r → Quot s → Quot t → Prop} (q₁ : Quot r)
    (q₂ : Quot s) (q₃ : Quot t) (h : ∀ a b c, δ (Quot.mk r a) (Quot.mk s b) (Quot.mk t c)) :
    δ q₁ q₂ q₃ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_4} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} {δ : Quot r → Quot s → Quot t → Prop} (q₁ : Quot r) (q₂ : Quot s) (q₃ : Quot t) (h : ∀ (a : α) (b : β) (c : γ), δ (Quot.mk r a) (Quot.mk s b) (Quot.mk t c))
Goal: δ q₁ q₂ q₃
-- Quotient.map_mk
@[simp]
theorem map_mk (f : α → β) (h : ((· ≈ ·) ⇒ (· ≈ ·)) f f) (x : α) :
    Quotient.map f h (⟦x⟧ : Quotient sa) = (⟦f x⟧ : Quotient sb) 
Arguments: {α : Sort u_1} {β : Sort u_2} [sa : Setoid α] [sb : Setoid β] (f : α → β) (h : ((fun x x_1 => x ≈ x_1) ⇒ fun x x_1 => x ≈ x_1) f f) (x : α)
Goal: Quotient.map f h ⟦x⟧ = ⟦f x⟧
-- Quotient.map₂_mk
@[simp]
theorem map₂_mk (f : α → β → γ) (h : ((· ≈ ·) ⇒ (· ≈ ·) ⇒ (· ≈ ·)) f f) (x : α) (y : β) :
    Quotient.map₂ f h (⟦x⟧ : Quotient sa) (⟦y⟧ : Quotient sb) = (⟦f x y⟧ : Quotient sc) 
Arguments: {α : Sort u_1} {β : Sort u_2} [sa : Setoid α] [sb : Setoid β] {γ : Sort u_4} [sc : Setoid γ] (f : α → β → γ) (h : ((fun x x_1 => x ≈ x_1) ⇒ (fun x x_1 => x ≈ x_1) ⇒ fun x x_1 => x ≈ x_1) f f) (x : α) (y : β)
Goal: Quotient.map₂ f h ⟦x⟧ ⟦y⟧ = ⟦f x y⟧
-- Quot.eq
theorem Quot.eq {α : Type*} {r : α → α → Prop} {x y : α} :
    Quot.mk r x = Quot.mk r y ↔ EqvGen r x y 
Arguments: {α : Type u_3} {r : α → α → Prop} {x y : α}
Goal: Quot.mk r x = Quot.mk r y ↔ EqvGen r x y
-- Quotient.eq
@[simp]
theorem Quotient.eq [r : Setoid α] {x y : α} : Quotient.mk r x = ⟦y⟧ ↔ x ≈ y 
Arguments: {α : Sort u_1} [r : Setoid α] {x y : α}
Goal: ⟦x⟧ = ⟦y⟧ ↔ x ≈ y
-- Quotient.forall
theorem Quotient.forall {α : Sort*} {s : Setoid α} {p : Quotient s → Prop} :
    (∀ a, p a) ↔ ∀ a : α, p ⟦a⟧ 
Arguments: {α : Sort u_3} {s : Setoid α} {p : Quotient s → Prop}
Goal: (∀ (a : Quotient s), p a) ↔ ∀ (a : α), p ⟦a⟧
-- Quotient.exists
theorem Quotient.exists {α : Sort*} {s : Setoid α} {p : Quotient s → Prop} :
    (∃ a, p a) ↔ ∃ a : α, p ⟦a⟧ 
Arguments: {α : Sort u_3} {s : Setoid α} {p : Quotient s → Prop}
Goal: (∃ a, p a) ↔ ∃ a, p ⟦a⟧
-- Quotient.lift_mk
@[simp]
theorem Quotient.lift_mk [s : Setoid α] (f : α → β) (h : ∀ a b : α, a ≈ b → f a = f b) (x : α) :
    Quotient.lift f h (Quotient.mk s x) = f x 
Arguments: {α : Sort u_1} {β : Sort u_2} [s : Setoid α] (f : α → β) (h : ∀ (a b : α), a ≈ b → f a = f b) (x : α)
Goal: Quotient.lift f h ⟦x⟧ = f x
-- Quotient.lift_comp_mk
@[simp]
theorem Quotient.lift_comp_mk [Setoid α] (f : α → β) (h : ∀ a b : α, a ≈ b → f a = f b) :
    Quotient.lift f h ∘ Quotient.mk _ = f 
Arguments: {α : Sort u_1} {β : Sort u_2} [Setoid α] (f : α → β) (h : ∀ (a b : α), a ≈ b → f a = f b)
Goal: Quotient.lift f h ∘ Quotient.mk inst✝ = f
-- Quotient.lift₂_mk
@[simp]
theorem Quotient.lift₂_mk {α : Sort*} {β : Sort*} {γ : Sort*} [Setoid α] [Setoid β]
    (f : α → β → γ)
    (h : ∀ (a₁ : α) (a₂ : β) (b₁ : α) (b₂ : β), a₁ ≈ b₁ → a₂ ≈ b₂ → f a₁ a₂ = f b₁ b₂)
    (a : α) (b : β) :
    Quotient.lift₂ f h (Quotient.mk _ a) (Quotient.mk _ b) = f a b 
Arguments: {α : Sort u_3} {β : Sort u_4} {γ : Sort u_5} [Setoid α] [Setoid β] (f : α → β → γ) (h : ∀ (a₁ : α) (a₂ : β) (b₁ : α) (b₂ : β), a₁ ≈ b₁ → a₂ ≈ b₂ → f a₁ a₂ = f b₁ b₂) (a : α) (b : β)
Goal: Quotient.lift₂ f h ⟦a⟧ ⟦b⟧ = f a b
-- Quotient.liftOn_mk
theorem Quotient.liftOn_mk [s : Setoid α] (f : α → β) (h : ∀ a b : α, a ≈ b → f a = f b) (x : α) :
    Quotient.liftOn (Quotient.mk s x) f h = f x 
Arguments: {α : Sort u_1} {β : Sort u_2} [s : Setoid α] (f : α → β) (h : ∀ (a b : α), a ≈ b → f a = f b) (x : α)
Goal: ⟦x⟧.liftOn f h = f x
-- Quotient.liftOn₂_mk
@[simp]
theorem Quotient.liftOn₂_mk {α : Sort*} {β : Sort*} [Setoid α] (f : α → α → β)
    (h : ∀ a₁ a₂ b₁ b₂ : α, a₁ ≈ b₁ → a₂ ≈ b₂ → f a₁ a₂ = f b₁ b₂) (x y : α) :
    Quotient.liftOn₂ (Quotient.mk _ x) (Quotient.mk _ y) f h = f x y 
Arguments: {α : Sort u_3} {β : Sort u_4} [Setoid α] (f : α → α → β) (h : ∀ (a₁ a₂ b₁ b₂ : α), a₁ ≈ b₁ → a₂ ≈ b₂ → f a₁ a₂ = f b₁ b₂) (x y : α)
Goal: ⟦x⟧.liftOn₂ ⟦y⟧ f h = f x y
-- surjective_quot_mk
theorem surjective_quot_mk (r : α → α → Prop) : Function.Surjective (Quot.mk r) 
Arguments: {α : Sort u_1} (r : α → α → Prop)
Goal: Function.Surjective (Quot.mk r)
-- surjective_quotient_mk
theorem surjective_quotient_mk {α : Sort*} (s : Setoid α) :
    Function.Surjective (Quotient.mk s) 
Arguments: {α : Sort u_3} (s : Setoid α)
Goal: Function.Surjective (Quotient.mk s)
-- surjective_quotient_mk'
theorem surjective_quotient_mk' (α : Sort*) [s : Setoid α] :
    Function.Surjective (Quotient.mk' : α → Quotient s) 
Arguments: (α : Sort u_3) [s : Setoid α]
Goal: Function.Surjective Quotient.mk'
-- Quot.out_eq
@[simp]
theorem Quot.out_eq {r : α → α → Prop} (q : Quot r) : Quot.mk r q.out = q 
Arguments: {α : Sort u_1} {r : α → α → Prop} (q : Quot r)
Goal: Quot.mk r q.out = q
-- Quotient.out_eq
@[simp]
theorem Quotient.out_eq [s : Setoid α] (q : Quotient s) : ⟦q.out⟧ = q 
Arguments: {α : Sort u_1} [s : Setoid α] (q : Quotient s)
Goal: ⟦q.out⟧ = q
-- Quotient.mk_out
theorem Quotient.mk_out [Setoid α] (a : α) : ⟦a⟧.out ≈ a 
Arguments: {α : Sort u_1} [Setoid α] (a : α)
Goal: ⟦a⟧.out ≈ a
-- Quotient.mk_eq_iff_out
theorem Quotient.mk_eq_iff_out [s : Setoid α] {x : α} {y : Quotient s} :
    ⟦x⟧ = y ↔ x ≈ Quotient.out y 
Arguments: {α : Sort u_1} [s : Setoid α] {x : α} {y : Quotient s}
Goal: ⟦x⟧ = y ↔ x ≈ y.out
-- Quotient.eq_mk_iff_out
theorem Quotient.eq_mk_iff_out [s : Setoid α] {x : Quotient s} {y : α} :
    x = ⟦y⟧ ↔ Quotient.out x ≈ y 
Arguments: {α : Sort u_1} [s : Setoid α] {x : Quotient s} {y : α}
Goal: x = ⟦y⟧ ↔ x.out ≈ y
-- Quotient.out_equiv_out
@[simp]
theorem Quotient.out_equiv_out {s : Setoid α} {x y : Quotient s} : x.out ≈ y.out ↔ x = y 
Arguments: {α : Sort u_1} {s : Setoid α} {x y : Quotient s}
Goal: x.out ≈ y.out ↔ x = y
-- Quotient.out_injective
theorem Quotient.out_injective {s : Setoid α} : Function.Injective (@Quotient.out α s) 
Arguments: {α : Sort u_1} {s : Setoid α}
Goal: Function.Injective Quotient.out
-- Quotient.out_inj
@[simp]
theorem Quotient.out_inj {s : Setoid α} {x y : Quotient s} : x.out = y.out ↔ x = y 
Arguments: {α : Sort u_1} {s : Setoid α} {x y : Quotient s}
Goal: x.out = y.out ↔ x = y
-- Quotient.choice_eq
@[simp]
theorem Quotient.choice_eq {ι : Type*} {α : ι → Type*} [∀ i, Setoid (α i)] (f : ∀ i, α i) :
    (Quotient.choice fun i ↦ ⟦f i⟧) = ⟦f⟧ 
Arguments: {ι : Type u_3} {α : ι → Type u_4} [(i : ι) → Setoid (α i)] (f : (i : ι) → α i)
Goal: (Quotient.choice fun i => ⟦f i⟧) = ⟦f⟧
-- Quotient.induction_on_pi
@[elab_as_elim]
theorem Quotient.induction_on_pi {ι : Type*} {α : ι → Sort*} [s : ∀ i, Setoid (α i)]
    {p : (∀ i, Quotient (s i)) → Prop} (f : ∀ i, Quotient (s i))
    (h : ∀ a : ∀ i, α i, p fun i ↦ ⟦a i⟧) : p f 
Arguments: {ι : Type u_3} {α : ι → Sort u_4} [s : (i : ι) → Setoid (α i)] {p : ((i : ι) → Quotient (s i)) → Prop} (f : (i : ι) → Quotient (s i)) (h : ∀ (a : (i : ι) → α i), p fun i => ⟦a i⟧)
Goal: p f
-- nonempty_quotient_iff
theorem nonempty_quotient_iff (s : Setoid α) : Nonempty (Quotient s) ↔ Nonempty α 
Arguments: {α : Sort u_1} (s : Setoid α)
Goal: Nonempty (Quotient s) ↔ Nonempty α
-- true_equivalence
theorem true_equivalence : @Equivalence α fun _ _ ↦ True 
Arguments: {α : Sort u_1}
Goal: Equivalence fun x x => True
-- Trunc.ind
theorem ind {β : Trunc α → Prop} : (∀ a : α, β (mk a)) → ∀ q : Trunc α, β q 
Arguments: {α : Sort u_1} {β : Trunc α → Prop}
Goal: (∀ (a : α), β (Trunc.mk a)) → ∀ (q : Trunc α), β q
-- Trunc.lift_mk
protected theorem lift_mk (f : α → β) (c) (a : α) : lift f c (mk a) = f a 
Arguments: {α : Sort u_1} {β : Sort u_2} (f : α → β) (c : ∀ (a b : α), f a = f b) (a : α)
Goal: Trunc.lift f c (Trunc.mk a) = f a
-- Trunc.induction_on
@[elab_as_elim]
protected theorem induction_on {β : Trunc α → Prop} (q : Trunc α) (h : ∀ a, β (mk a)) : β q 
Arguments: {α : Sort u_1} {β : Trunc α → Prop} (q : Trunc α) (h : ∀ (a : α), β (Trunc.mk a))
Goal: β q
-- Trunc.exists_rep
theorem exists_rep (q : Trunc α) : ∃ a : α, mk a = q 
Arguments: {α : Sort u_1} (q : Trunc α)
Goal: ∃ a, Trunc.mk a = q
-- Trunc.induction_on₂
@[elab_as_elim]
protected theorem induction_on₂ {C : Trunc α → Trunc β → Prop} (q₁ : Trunc α) (q₂ : Trunc β)
    (h : ∀ a b, C (mk a) (mk b)) : C q₁ q₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {C : Trunc α → Trunc β → Prop} (q₁ : Trunc α) (q₂ : Trunc β) (h : ∀ (a : α) (b : β), C (Trunc.mk a) (Trunc.mk b))
Goal: C q₁ q₂
-- Trunc.eq
protected theorem eq (a b : Trunc α) : a = b 
Arguments: {α : Sort u_1} (a b : Trunc α)
Goal: a = b
-- Trunc.out_eq
@[simp]
theorem out_eq (q : Trunc α) : mk q.out = q 
Arguments: {α : Sort u_1} (q : Trunc α)
Goal: Trunc.mk q.out = q
-- Trunc.nonempty
protected theorem nonempty (q : Trunc α) : Nonempty α 
Arguments: {α : Sort u_1} (q : Trunc α)
Goal: Nonempty α
-- Quotient.surjective_Quotient_mk''
theorem surjective_Quotient_mk'' : Function.Surjective (Quotient.mk'' : α → Quotient s₁) 
Arguments: {α : Sort u_1} {s₁ : Setoid α}
Goal: Function.Surjective Quotient.mk''
-- Quotient.liftOn'_mk''
@[simp]
protected theorem liftOn'_mk'' (f : α → φ) (h) (x : α) :
    Quotient.liftOn' (@Quotient.mk'' _ s₁ x) f h = f x 
Arguments: {α : Sort u_1} {φ : Sort u_4} {s₁ : Setoid α} (f : α → φ) (h : ∀ (a b : α), Setoid.r a b → f a = f b) (x : α)
Goal: (Quotient.mk'' x).liftOn' f h = f x
-- Quotient.surjective_liftOn'
@[simp] lemma surjective_liftOn' {f : α → φ} (h) :
    Function.Surjective (fun x : Quotient s₁ ↦ x.liftOn' f h) ↔ Function.Surjective f 
Arguments: {α : Sort u_1} {φ : Sort u_4} {s₁ : Setoid α} {f : α → φ} (h : ∀ (a b : α), Setoid.r a b → f a = f b)
Goal: (Function.Surjective fun x => x.liftOn' f h) ↔ Function.Surjective f
-- Quotient.liftOn₂'_mk''
@[simp]
protected theorem liftOn₂'_mk'' (f : α → β → γ) (h) (a : α) (b : β) :
    Quotient.liftOn₂' (@Quotient.mk'' _ s₁ a) (@Quotient.mk'' _ s₂ b) f h = f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {s₁ : Setoid α} {s₂ : Setoid β} (f : α → β → γ) (h : ∀ (a₁ : α) (a₂ : β) (b₁ : α) (b₂ : β), Setoid.r a₁ b₁ → Setoid.r a₂ b₂ → f a₁ a₂ = f b₁ b₂) (a : α) (b : β)
Goal: (Quotient.mk'' a).liftOn₂' (Quotient.mk'' b) f h = f a b
-- Quotient.ind'
@[elab_as_elim]
protected theorem ind' {p : Quotient s₁ → Prop} (h : ∀ a, p (Quotient.mk'' a)) (q : Quotient s₁) :
    p q 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {p : Quotient s₁ → Prop} (h : ∀ (a : α), p (Quotient.mk'' a)) (q : Quotient s₁)
Goal: p q
-- Quotient.ind₂'
@[elab_as_elim]
protected theorem ind₂' {p : Quotient s₁ → Quotient s₂ → Prop}
    (h : ∀ a₁ a₂, p (Quotient.mk'' a₁) (Quotient.mk'' a₂))
    (q₁ : Quotient s₁) (q₂ : Quotient s₂) : p q₁ q₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} {p : Quotient s₁ → Quotient s₂ → Prop} (h : ∀ (a₁ : α) (a₂ : β), p (Quotient.mk'' a₁) (Quotient.mk'' a₂)) (q₁ : Quotient s₁) (q₂ : Quotient s₂)
Goal: p q₁ q₂
-- Quotient.inductionOn'
@[elab_as_elim]
protected theorem inductionOn' {p : Quotient s₁ → Prop} (q : Quotient s₁)
    (h : ∀ a, p (Quotient.mk'' a)) : p q 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {p : Quotient s₁ → Prop} (q : Quotient s₁) (h : ∀ (a : α), p (Quotient.mk'' a))
Goal: p q
-- Quotient.inductionOn₂'
@[elab_as_elim]
protected theorem inductionOn₂' {p : Quotient s₁ → Quotient s₂ → Prop} (q₁ : Quotient s₁)
    (q₂ : Quotient s₂)
    (h : ∀ a₁ a₂, p (Quotient.mk'' a₁) (Quotient.mk'' a₂)) : p q₁ q₂ 
Arguments: {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} {p : Quotient s₁ → Quotient s₂ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂) (h : ∀ (a₁ : α) (a₂ : β), p (Quotient.mk'' a₁) (Quotient.mk'' a₂))
Goal: p q₁ q₂
-- Quotient.inductionOn₃'
@[elab_as_elim]
protected theorem inductionOn₃' {p : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
    (q₁ : Quotient s₁) (q₂ : Quotient s₂) (q₃ : Quotient s₃)
    (h : ∀ a₁ a₂ a₃, p (Quotient.mk'' a₁) (Quotient.mk'' a₂) (Quotient.mk'' a₃)) :
    p q₁ q₂ q₃ 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ} {p : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop} (q₁ : Quotient s₁) (q₂ : Quotient s₂) (q₃ : Quotient s₃) (h : ∀ (a₁ : α) (a₂ : β) (a₃ : γ), p (Quotient.mk'' a₁) (Quotient.mk'' a₂) (Quotient.mk'' a₃))
Goal: p q₁ q₂ q₃
-- Quotient.hrecOn'_mk''
@[simp]
theorem hrecOn'_mk'' {φ : Quotient s₁ → Sort*} (f : ∀ a, φ (Quotient.mk'' a))
    (c : ∀ a₁ a₂, a₁ ≈ a₂ → HEq (f a₁) (f a₂))
    (x : α) : (Quotient.mk'' x).hrecOn' f c = f x 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {φ : Quotient s₁ → Sort u_5} (f : (a : α) → φ (Quotient.mk'' a)) (c : ∀ (a₁ a₂ : α), a₁ ≈ a₂ → HEq (f a₁) (f a₂)) (x : α)
Goal: (Quotient.mk'' x).hrecOn' f c = f x
-- Quotient.hrecOn₂'_mk''
@[simp]
theorem hrecOn₂'_mk'' {φ : Quotient s₁ → Quotient s₂ → Sort*}
    (f : ∀ a b, φ (Quotient.mk'' a) (Quotient.mk'' b))
    (c : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → HEq (f a₁ b₁) (f a₂ b₂)) (x : α) (qb : Quotient s₂) :
    (Quotient.mk'' x).hrecOn₂' qb f c = qb.hrecOn' (f x) fun _ _ ↦ c _ _ _ _ (Setoid.refl _) 
Arguments: {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} {φ : Quotient s₁ → Quotient s₂ → Sort u_5} (f : (a : α) → (b : β) → φ (Quotient.mk'' a) (Quotient.mk'' b)) (c : ∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → HEq (f a₁ b₁) (f a₂ b₂)) (x : α) (qb : Quotient s₂)
Goal: (Quotient.mk'' x).hrecOn₂' qb f c = qb.hrecOn' (f x) ⋯
-- Quotient.map'_mk''
@[simp]
theorem map'_mk'' (f : α → β) (h) (x : α) :
    (Quotient.mk'' x : Quotient s₁).map' f h = (Quotient.mk'' (f x) : Quotient s₂) 
Arguments: {α : Sort u_1} {β : Sort u_2} {s₁ : Setoid α} {s₂ : Setoid β} (f : α → β) (h : (Setoid.r ⇒ Setoid.r) f f) (x : α)
Goal: Quotient.map' f h (Quotient.mk'' x) = Quotient.mk'' (f x)
-- Quotient.map₂'_mk''
@[simp]
theorem map₂'_mk'' (f : α → β → γ) (h) (x : α) :
    (Quotient.mk'' x : Quotient s₁).map₂' f h =
      (Quotient.map' (f x) (h (Setoid.refl x)) : Quotient s₂ → Quotient s₃) 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ} (f : α → β → γ) (h : (Setoid.r ⇒ Setoid.r ⇒ Setoid.r) f f) (x : α)
Goal: Quotient.map₂' f h (Quotient.mk'' x) = Quotient.map' (f x) ⋯
-- Quotient.exact'
theorem exact' {a b : α} :
    (Quotient.mk'' a : Quotient s₁) = Quotient.mk'' b → @Setoid.r _ s₁ a b 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {a b : α}
Goal: Quotient.mk'' a = Quotient.mk'' b → Setoid.r a b
-- Quotient.sound'
theorem sound' {a b : α} : @Setoid.r _ s₁ a b → @Quotient.mk'' α s₁ a = Quotient.mk'' b 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {a b : α}
Goal: Setoid.r a b → Quotient.mk'' a = Quotient.mk'' b
-- Quotient.eq'
@[simp]
protected theorem eq' [s₁ : Setoid α] {a b : α} :
    @Quotient.mk' α s₁ a = @Quotient.mk' α s₁ b ↔ @Setoid.r _ s₁ a b 
Arguments: {α : Sort u_1} [s₁ : Setoid α] {a b : α}
Goal: Quotient.mk' a = Quotient.mk' b ↔ Setoid.r a b
-- Quotient.eq''
@[simp]
protected theorem eq'' {a b : α} : @Quotient.mk'' α s₁ a = Quotient.mk'' b ↔ @Setoid.r _ s₁ a b 
Arguments: {α : Sort u_1} {s₁ : Setoid α} {a b : α}
Goal: Quotient.mk'' a = Quotient.mk'' b ↔ Setoid.r a b
-- Quotient.out_eq'
@[simp]
theorem out_eq' (q : Quotient s₁) : Quotient.mk'' q.out' = q 
Arguments: {α : Sort u_1} {s₁ : Setoid α} (q : Quotient s₁)
Goal: Quotient.mk'' q.out' = q
-- Quotient.mk_out'
theorem mk_out' (a : α) : @Setoid.r α s₁ (Quotient.mk'' a : Quotient s₁).out' a 
Arguments: {α : Sort u_1} {s₁ : Setoid α} (a : α)
Goal: Setoid.r (Quotient.mk'' a).out' a
-- Quotient.mk''_eq_mk
protected theorem mk''_eq_mk : Quotient.mk'' = Quotient.mk s 
Arguments: {α : Sort u_1} [s : Setoid α]
Goal: Quotient.mk'' = Quotient.mk s
-- Quotient.liftOn'_mk
@[simp]
protected theorem liftOn'_mk (x : α) (f : α → β) (h) : (Quotient.mk s x).liftOn' f h = f x 
Arguments: {α : Sort u_1} {β : Sort u_2} [s : Setoid α] (x : α) (f : α → β) (h : ∀ (a b : α), Setoid.r a b → f a = f b)
Goal: ⟦x⟧.liftOn' f h = f x
-- Quotient.liftOn₂'_mk
@[simp]
protected theorem liftOn₂'_mk [t : Setoid β] (f : α → β → γ) (h) (a : α) (b : β) :
    Quotient.liftOn₂' (Quotient.mk s a) (Quotient.mk t b) f h = f a b 
Arguments: {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} [s : Setoid α] [t : Setoid β] (f : α → β → γ) (h : ∀ (a₁ : α) (a₂ : β) (b₁ : α) (b₂ : β), Setoid.r a₁ b₁ → Setoid.r a₂ b₂ → f a₁ a₂ = f b₁ b₂) (a : α) (b : β)
Goal: ⟦a⟧.liftOn₂' ⟦b⟧ f h = f a b
-- Quotient.map'_mk
@[simp]
theorem map'_mk [t : Setoid β] (f : α → β) (h) (x : α) :
    (Quotient.mk s x).map' f h = (Quotient.mk t (f x)) 
Arguments: {α : Sort u_1} {β : Sort u_2} [s : Setoid α] [t : Setoid β] (f : α → β) (h : (Setoid.r ⇒ Setoid.r) f f) (x : α)
Goal: Quotient.map' f h ⟦x⟧ = ⟦f x⟧
-- Equivalence.quot_mk_eq_iff
@[simp]
lemma Equivalence.quot_mk_eq_iff {α : Type*} {r : α → α → Prop} (h : Equivalence r) (x y : α) :
    Quot.mk r x = Quot.mk r y ↔ r x y 
Arguments: {α : Type u_3} {r : α → α → Prop} (h : Equivalence r) (x y : α)
Goal: Quot.mk r x = Quot.mk r y ↔ r x y
-- Sym.card_sym_fin_eq_multichoose
theorem card_sym_fin_eq_multichoose : ∀ n k : ℕ, card (Sym (Fin n) k) = multichoose n k
  
Arguments: (n k : ℕ)
Goal: Fintype.card (Sym (Fin n) k) = n.multichoose k
-- Sym.card_sym_eq_multichoose
theorem card_sym_eq_multichoose (α : Type*) (k : ℕ) [Fintype α] [Fintype (Sym α k)] :
    card (Sym α k) = multichoose (card α) k 
Arguments: (α : Type u_3) (k : ℕ) [Fintype α] [Fintype (Sym α k)]
Goal: Fintype.card (Sym α k) = (Fintype.card α).multichoose k
-- Sym.card_sym_eq_choose
theorem card_sym_eq_choose {α : Type*} [Fintype α] (k : ℕ) [Fintype (Sym α k)] :
    card (Sym α k) = (card α + k - 1).choose k 
Arguments: {α : Type u_3} [Fintype α] (k : ℕ) [Fintype (Sym α k)]
Goal: Fintype.card (Sym α k) = (Fintype.card α + k - 1).choose k
-- Sym2.card_image_diag
theorem card_image_diag (s : Finset α) : (s.diag.image Sym2.mk).card = s.card 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: (Finset.image Sym2.mk s.diag).card = s.card
-- Sym2.two_mul_card_image_offDiag
theorem two_mul_card_image_offDiag (s : Finset α) :
    2 * (s.offDiag.image Sym2.mk).card = s.offDiag.card 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: 2 * (Finset.image Sym2.mk s.offDiag).card = s.offDiag.card
-- Sym2.card_image_offDiag
theorem card_image_offDiag (s : Finset α) :
    (s.offDiag.image Sym2.mk).card = s.card.choose 2 
Arguments: {α : Type u_1} [DecidableEq α] (s : Finset α)
Goal: (Finset.image Sym2.mk s.offDiag).card = s.card.choose 2
-- Sym2.card_subtype_diag
theorem card_subtype_diag [Fintype α] : card { a : Sym2 α // a.IsDiag } = card α 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: Fintype.card { a // a.IsDiag } = Fintype.card α
-- Sym2.card_subtype_not_diag
theorem card_subtype_not_diag [Fintype α] :
    card { a : Sym2 α // ¬a.IsDiag } = (card α).choose 2 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α]
Goal: Fintype.card { a // ¬a.IsDiag } = (Fintype.card α).choose 2
-- Sym2.card
protected theorem card [Fintype α] : card (Sym2 α) = Nat.choose (card α + 1) 2 
Arguments: {α : Type u_1} [Fintype α]
Goal: Fintype.card (Sym2 α) = (Fintype.card α + 1).choose 2
-- Stream'.eta
protected theorem eta (s : Stream' α) : (head s::tail s) = s 
Arguments: {α : Type u} (s : Stream' α)
Goal: Stream'.cons s.head s.tail = s
-- Stream'.ext
@[ext]
protected theorem ext {s₁ s₂ : Stream' α} : (∀ n, get s₁ n = get s₂ n) → s₁ = s₂ 
Arguments: {α : Type u} {s₁ s₂ : Stream' α}
Goal: (∀ (n : ℕ), s₁.get n = s₂.get n) → s₁ = s₂
-- Stream'.get_zero_cons
@[simp]
theorem get_zero_cons (a : α) (s : Stream' α) : get (a::s) 0 = a 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: (Stream'.cons a s).get 0 = a
-- Stream'.head_cons
@[simp]
theorem head_cons (a : α) (s : Stream' α) : head (a::s) = a 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: (Stream'.cons a s).head = a
-- Stream'.tail_cons
@[simp]
theorem tail_cons (a : α) (s : Stream' α) : tail (a::s) = s 
Arguments: {α : Type u} (a : α) (s : Stream' α)
Goal: (Stream'.cons a s).tail = s
-- Stream'.get_drop
@[simp]
theorem get_drop (n m : ℕ) (s : Stream' α) : get (drop m s) n = get s (n + m) 
Arguments: {α : Type u} (n m : ℕ) (s : Stream' α)
Goal: (Stream'.drop m s).get n = s.get (n + m)
-- Stream'.tail_eq_drop
theorem tail_eq_drop (s : Stream' α) : tail s = drop 1 s 
Arguments: {α : Type u} (s : Stream' α)
Goal: s.tail = Stream'.drop 1 s
-- Stream'.drop_drop
@[simp]
theorem drop_drop (n m : ℕ) (s : Stream' α) : drop n (drop m s) = drop (n + m) s 
Arguments: {α : Type u} (n m : ℕ) (s : Stream' α)
Goal: Stream'.drop n (Stream'.drop m s) = Stream'.drop (n + m) s
-- Stream'.get_tail
@[simp] theorem get_tail {n : ℕ} {s : Stream' α} : s.tail.get n = s.get (n + 1) 
Arguments: {α : Type u} {n : ℕ} {s : Stream' α}
Goal: s.tail.get n = s.get (n + 1)
-- Stream'.tail_drop'
@[simp] theorem tail_drop' {i : ℕ} {s : Stream' α} : tail (drop i s) = s.drop (i+1) 
Arguments: {α : Type u} {i : ℕ} {s : Stream' α}
Goal: (Stream'.drop i s).tail = Stream'.drop (i + 1) s
-- Stream'.drop_tail'
@[simp] theorem drop_tail' {i : ℕ} {s : Stream' α} : drop i (tail s) = s.drop (i+1) 
Arguments: {α : Type u} {i : ℕ} {s : Stream' α}
Goal: Stream'.drop i s.tail = Stream'.drop (i + 1) s
-- Stream'.tail_drop
theorem tail_drop (n : ℕ) (s : Stream' α) : tail (drop n s) = drop n (tail s) 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: (Stream'.drop n s).tail = Stream'.drop n s.tail
-- Stream'.get_succ
theorem get_succ (n : ℕ) (s : Stream' α) : get s (succ n) = get (tail s) n 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α)
Goal: s.get n.succ = s.tail.get n
-- Stream'.get_succ_cons
@[simp]
theorem get_succ_cons (n : ℕ) (s : Stream' α) (x : α) : get (x::s) n.succ = get s n 
Arguments: {α : Type u} (n : ℕ) (s : Stream' α) (x : α)
Goal: (Stream'.cons x s).get n.succ = s.get n