File: Mathlib/Data/Quot.lean

full_name: Setoid.ext
code: theorem ext {α : Sort*} : ∀ {s t : Setoid α},
    (∀ a b, @Setoid.r α s a b ↔ @Setoid.r α t a b) → s = t
  
goal: (∀ (a b : α), Setoid.r a b ↔ Setoid.r a b) → s = t

full_name: Quot.«_aux_Mathlib_Data_Quot___macroRules_Quot_term⟦_⟧_1»
code: @[inherit_doc Quot.mk]
local notation3:arg "⟦" a "⟧" => Quot.mk _ a
goal: Lean.Macro

full_name: Quot.induction_on
code: @[elab_as_elim]
protected theorem induction_on {α : Sort*} {r : α → α → Prop} {β : Quot r → Prop} (q : Quot r)
    (h : ∀ a, β (Quot.mk r a)) : β q 
goal: β q

full_name: Quot.instInhabited_mathlib
code: instance (r : α → α → Prop) [Inhabited α] : Inhabited (Quot r) 
goal: Inhabited (Quot r)

full_name: Quot.Subsingleton
code: protected instance Subsingleton [Subsingleton α] : Subsingleton (Quot ra) 
goal: Subsingleton (Quot ra)

full_name: Quot.instUnique
code: instance [Unique α] : Unique (Quot ra) 
goal: Unique (Quot ra)

full_name: Quot.hrecOn₂
code: /-- Recursion on two `Quotient` arguments `a` and `b`, result type depends on `⟦a⟧` and `⟦b⟧`. -/
protected def hrecOn₂ (qa : Quot ra) (qb : Quot rb) (f : ∀ a b, φ ⟦a⟧ ⟦b⟧)
    (ca : ∀ {b a₁ a₂}, ra a₁ a₂ → HEq (f a₁ b) (f a₂ b))
    (cb : ∀ {a b₁ b₂}, rb b₁ b₂ → HEq (f a b₁) (f a b₂)) :
    φ qa qb 
goal: φ qa qb

full_name: Quot.map
code: /-- Map a function `f : α → β` such that `ra x y` implies `rb (f x) (f y)`
to a map `Quot ra → Quot rb`. -/
protected def map (f : α → β) (h : (ra ⇒ rb) f f) : Quot ra → Quot rb 
goal: Quot ra → Quot rb

full_name: Quot.mapRight
code: /-- If `ra` is a subrelation of `ra'`, then we have a natural map `Quot ra → Quot ra'`. -/
protected def mapRight {ra' : α → α → Prop} (h : ∀ a₁ a₂, ra a₁ a₂ → ra' a₁ a₂) :
    Quot ra → Quot ra' 
goal: Quot ra → Quot ra'

full_name: Quot.factor
code: /-- Weaken the relation of a quotient. This is the same as `Quot.map id`. -/
def factor {α : Type*} (r s : α → α → Prop) (h : ∀ x y, r x y → s x y) : Quot r → Quot s 
goal: Quot r → Quot s

full_name: Quot.factor_mk_eq
code: theorem factor_mk_eq {α : Type*} (r s : α → α → Prop) (h : ∀ x y, r x y → s x y) :
    factor r s h ∘ Quot.mk _ = Quot.mk _ 
goal: Quot.factor r s h ∘ Quot.mk r = Quot.mk s

full_name: Quot.lift_mk
code: theorem lift_mk (f : α → γ) (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) (a : α) :
    Quot.lift f h (Quot.mk r a) = f a 
goal: Quot.lift f h (Quot.mk r a) = f a

full_name: Quot.liftOn_mk
code: 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 
goal: (Quot.mk r a).liftOn f h = f a

full_name: Quot.surjective_lift
code: @[simp] theorem surjective_lift {f : α → γ} (h : ∀ a₁ a₂, r a₁ a₂ → f a₁ = f a₂) :
    Function.Surjective (lift f h) ↔ Function.Surjective f 
goal: Function.Surjective (Quot.lift f h) ↔ Function.Surjective f

full_name: Quot.lift₂
code: /-- Descends a function `f : α → β → γ` to quotients of `α` and `β`. -/
-- Porting note: removed `@[elab_as_elim]`, gave "unexpected resulting type γ"
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
protected def lift₂ (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) (q₁ : Quot r) (q₂ : Quot s) : γ 
goal: γ

full_name: Quot.lift₂_mk
code: @[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 
goal: Quot.lift₂ f hr hs (Quot.mk r a) (Quot.mk s b) = f a b

full_name: Quot.liftOn₂
code: /-- Descends a function `f : α → β → γ` to quotients of `α` and `β` and applies it. -/
-- porting note (#11083): removed `@[elab_as_elim]`, gave "unexpected resulting type γ"
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
protected def liftOn₂ (p : Quot r) (q : Quot s) (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: γ

full_name: Quot.liftOn₂_mk
code: @[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 
goal: (Quot.mk r a).liftOn₂ (Quot.mk s b) f hr hs = f a b

full_name: Quot.map₂
code: /-- Descends a function `f : α → β → γ` to quotients of `α` and `β` with values in a quotient of
`γ`. -/
protected def map₂ (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)) (q₁ : Quot r) (q₂ : Quot s) : Quot t 
goal: Quot t

full_name: Quot.map₂_mk
code: @[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) 
goal: Quot.map₂ f hr hs (Quot.mk r a) (Quot.mk s b) = Quot.mk t (f a b)

full_name: Quot.recOnSubsingleton₂
code: /-- A binary version of `Quot.recOnSubsingleton`. -/
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
@[elab_as_elim]
protected def recOnSubsingleton₂ {φ : Quot r → Quot s → Sort*}
    [h : ∀ a b, Subsingleton (φ ⟦a⟧ ⟦b⟧)] (q₁ : Quot r)
    (q₂ : Quot s) (f : ∀ a b, φ ⟦a⟧ ⟦b⟧) : φ q₁ q₂ 
goal: φ q₁ q₂

full_name: Quot.induction_on₂
code: @[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₂ 
goal: δ q₁ q₂

full_name: Quot.induction_on₃
code: @[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₃ 
goal: δ q₁ q₂ q₃

full_name: Quot.lift.decidablePred
code: instance lift.decidablePred (r : α → α → Prop) (f : α → Prop) (h : ∀ a b, r a b → f a = f b)
    [hf : DecidablePred f] :
    DecidablePred (Quot.lift f h) 
goal: DecidablePred (Quot.lift f h)

full_name: Quot.lift₂.decidablePred
code: /-- Note that this provides `DecidableRel (Quot.Lift₂ f ha hb)` when `α = β`. -/
instance lift₂.decidablePred (r : α → α → Prop) (s : β → β → Prop) (f : α → β → Prop)
    (ha : ∀ a b₁ b₂, s b₁ b₂ → f a b₁ = f a b₂) (hb : ∀ a₁ a₂ b, r a₁ a₂ → f a₁ b = f a₂ b)
    [hf : ∀ a, DecidablePred (f a)] (q₁ : Quot r) :
    DecidablePred (Quot.lift₂ f ha hb q₁) 
goal: DecidablePred (Quot.lift₂ f ha hb q₁)

full_name: Quot.instDecidableLiftOnOfDecidablePred_mathlib
code: instance (r : α → α → Prop) (q : Quot r) (f : α → Prop) (h : ∀ a b, r a b → f a = f b)
    [DecidablePred f] :
    Decidable (Quot.liftOn q f h) 
goal: Decidable (q.liftOn f h)

full_name: Quot.instDecidableLiftOn₂OfDecidablePred
code: instance (r : α → α → Prop) (s : β → β → Prop) (q₁ : Quot r) (q₂ : Quot s) (f : α → β → Prop)
    (ha : ∀ a b₁ b₂, s b₁ b₂ → f a b₁ = f a b₂) (hb : ∀ a₁ a₂ b, r a₁ a₂ → f a₁ b = f a₂ b)
    [∀ a, DecidablePred (f a)] :
    Decidable (Quot.liftOn₂ q₁ q₂ f ha hb) 
goal: Decidable (q₁.liftOn₂ q₂ f ha hb)

full_name: Quotient.«_aux_Mathlib_Data_Quot___macroRules_Quotient_term⟦_⟧_1»
code: @[inherit_doc Quotient.mk]
notation3:arg "⟦" a "⟧" => Quotient.mk _ a
goal: Lean.Macro

full_name: Quotient.instInhabitedQuotient
code: instance instInhabitedQuotient (s : Setoid α) [Inhabited α] : Inhabited (Quotient s) 
goal: Inhabited (Quotient s)

full_name: Quotient.instSubsingletonQuotient
code: instance instSubsingletonQuotient (s : Setoid α) [Subsingleton α] : Subsingleton (Quotient s) 
goal: Subsingleton (Quotient s)

full_name: Quotient.instUniqueQuotient
code: instance instUniqueQuotient (s : Setoid α) [Unique α] : Unique (Quotient s) 
goal: Unique (Quotient s)

full_name: Quotient.instIsEquivEquiv
code: instance {α : Type*} [Setoid α] : IsEquiv α (· ≈ ·) 
goal: IsEquiv α fun x x_1 => x ≈ x_1

full_name: Quotient.hrecOn₂
code: /-- Induction on two `Quotient` arguments `a` and `b`, result type depends on `⟦a⟧` and `⟦b⟧`. -/
protected def hrecOn₂ (qa : Quotient sa) (qb : Quotient sb) (f : ∀ a b, φ ⟦a⟧ ⟦b⟧)
    (c : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → HEq (f a₁ b₁) (f a₂ b₂)) : φ qa qb 
goal: φ qa qb

full_name: Quotient.map
code: /-- Map a function `f : α → β` that sends equivalent elements to equivalent elements
to a function `Quotient sa → Quotient sb`. Useful to define unary operations on quotients. -/
protected def map (f : α → β) (h : ((· ≈ ·) ⇒ (· ≈ ·)) f f) : Quotient sa → Quotient sb 
goal: Quotient sa → Quotient sb

full_name: Quotient.map_mk
code: @[simp]
theorem map_mk (f : α → β) (h : ((· ≈ ·) ⇒ (· ≈ ·)) f f) (x : α) :
    Quotient.map f h (⟦x⟧ : Quotient sa) = (⟦f x⟧ : Quotient sb) 
goal: Quotient.map f h ⟦x⟧ = ⟦f x⟧

full_name: Quotient.map₂
code: /-- Map a function `f : α → β → γ` that sends equivalent elements to equivalent elements
to a function `f : Quotient sa → Quotient sb → Quotient sc`.
Useful to define binary operations on quotients. -/
protected def map₂ (f : α → β → γ) (h : ((· ≈ ·) ⇒ (· ≈ ·) ⇒ (· ≈ ·)) f f) :
    Quotient sa → Quotient sb → Quotient sc 
goal: Quotient sa → Quotient sb → Quotient sc

full_name: Quotient.map₂_mk
code: @[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) 
goal: Quotient.map₂ f h ⟦x⟧ ⟦y⟧ = ⟦f x y⟧

full_name: Quotient.lift.decidablePred
code: instance lift.decidablePred (f : α → Prop) (h : ∀ a b, a ≈ b → f a = f b) [DecidablePred f] :
    DecidablePred (Quotient.lift f h) 
goal: DecidablePred (Quotient.lift f h)

full_name: Quotient.lift₂.decidablePred
code: /-- Note that this provides `DecidableRel (Quotient.lift₂ f h)` when `α = β`. -/
instance lift₂.decidablePred (f : α → β → Prop)
    (h : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂)
    [hf : ∀ a, DecidablePred (f a)]
    (q₁ : Quotient sa) : DecidablePred (Quotient.lift₂ f h q₁) 
goal: DecidablePred (Quotient.lift₂ f h q₁)

full_name: Quotient.instDecidableLiftOnOfDecidablePred_mathlib
code: instance (q : Quotient sa) (f : α → Prop) (h : ∀ a b, a ≈ b → f a = f b) [DecidablePred f] :
    Decidable (Quotient.liftOn q f h) 
goal: Decidable (q.liftOn f h)

full_name: Quotient.instDecidableLiftOn₂OfDecidablePred_mathlib
code: instance (q₁ : Quotient sa) (q₂ : Quotient sb) (f : α → β → Prop)
    (h : ∀ a₁ b₁ a₂ b₂, a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂) [∀ a, DecidablePred (f a)] :
    Decidable (Quotient.liftOn₂ q₁ q₂ f h) 
goal: Decidable (q₁.liftOn₂ q₂ f h)

full_name: Quot.eq
code: theorem Quot.eq {α : Type*} {r : α → α → Prop} {x y : α} :
    Quot.mk r x = Quot.mk r y ↔ EqvGen r x y 
goal: Quot.mk r x = Quot.mk r y ↔ EqvGen r x y

full_name: Quotient.eq
code: @[simp]
theorem Quotient.eq [r : Setoid α] {x y : α} : Quotient.mk r x = ⟦y⟧ ↔ x ≈ y 
goal: ⟦x⟧ = ⟦y⟧ ↔ x ≈ y

full_name: Quotient.forall
code: theorem Quotient.forall {α : Sort*} {s : Setoid α} {p : Quotient s → Prop} :
    (∀ a, p a) ↔ ∀ a : α, p ⟦a⟧ 
goal: (∀ (a : Quotient s), p a) ↔ ∀ (a : α), p ⟦a⟧

full_name: Quotient.exists
code: theorem Quotient.exists {α : Sort*} {s : Setoid α} {p : Quotient s → Prop} :
    (∃ a, p a) ↔ ∃ a : α, p ⟦a⟧ 
goal: (∃ a, p a) ↔ ∃ a, p ⟦a⟧

full_name: Quotient.lift_mk
code: @[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 
goal: Quotient.lift f h ⟦x⟧ = f x

full_name: Quotient.lift_comp_mk
code: @[simp]
theorem Quotient.lift_comp_mk [Setoid α] (f : α → β) (h : ∀ a b : α, a ≈ b → f a = f b) :
    Quotient.lift f h ∘ Quotient.mk _ = f 
goal: Quotient.lift f h ∘ Quotient.mk inst✝ = f

full_name: Quotient.lift₂_mk
code: @[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 
goal: Quotient.lift₂ f h ⟦a⟧ ⟦b⟧ = f a b

full_name: Quotient.liftOn_mk
code: 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 
goal: ⟦x⟧.liftOn f h = f x

full_name: Quotient.liftOn₂_mk
code: @[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 
goal: ⟦x⟧.liftOn₂ ⟦y⟧ f h = f x y

full_name: surjective_quot_mk
code: /-- `Quot.mk r` is a surjective function. -/
theorem surjective_quot_mk (r : α → α → Prop) : Function.Surjective (Quot.mk r) 
goal: Function.Surjective (Quot.mk r)

full_name: surjective_quotient_mk
code: /-- `Quotient.mk` is a surjective function. -/
theorem surjective_quotient_mk {α : Sort*} (s : Setoid α) :
    Function.Surjective (Quotient.mk s) 
goal: Function.Surjective (Quotient.mk s)

full_name: surjective_quotient_mk'
code: /-- `Quotient.mk'` is a surjective function. -/
theorem surjective_quotient_mk' (α : Sort*) [s : Setoid α] :
    Function.Surjective (Quotient.mk' : α → Quotient s) 
goal: Function.Surjective Quotient.mk'

full_name: Quot.out
code: /-- Choose an element of the equivalence class using the axiom of choice.
  Sound but noncomputable. -/
noncomputable def Quot.out {r : α → α → Prop} (q : Quot r) : α 
goal: α

full_name: Quot.unquot
code: /-- Unwrap the VM representation of a quotient to obtain an element of the equivalence class.
  Computable but unsound. -/
unsafe def Quot.unquot {r : α → α → Prop} : Quot r → α 
goal: Quot r → α

full_name: Quot.out_eq
code: @[simp]
theorem Quot.out_eq {r : α → α → Prop} (q : Quot r) : Quot.mk r q.out = q 
goal: Quot.mk r q.out = q

full_name: Quotient.out
code: /-- Choose an element of the equivalence class using the axiom of choice.
  Sound but noncomputable. -/
noncomputable def Quotient.out [s : Setoid α] : Quotient s → α 
goal: Quotient s → α

full_name: Quotient.out_eq
code: @[simp]
theorem Quotient.out_eq [s : Setoid α] (q : Quotient s) : ⟦q.out⟧ = q 
goal: ⟦q.out⟧ = q

full_name: Quotient.mk_out
code: theorem Quotient.mk_out [Setoid α] (a : α) : ⟦a⟧.out ≈ a 
goal: ⟦a⟧.out ≈ a

full_name: Quotient.mk_eq_iff_out
code: theorem Quotient.mk_eq_iff_out [s : Setoid α] {x : α} {y : Quotient s} :
    ⟦x⟧ = y ↔ x ≈ Quotient.out y 
goal: ⟦x⟧ = y ↔ x ≈ y.out

full_name: Quotient.eq_mk_iff_out
code: theorem Quotient.eq_mk_iff_out [s : Setoid α] {x : Quotient s} {y : α} :
    x = ⟦y⟧ ↔ Quotient.out x ≈ y 
goal: x = ⟦y⟧ ↔ x.out ≈ y

full_name: Quotient.out_equiv_out
code: @[simp]
theorem Quotient.out_equiv_out {s : Setoid α} {x y : Quotient s} : x.out ≈ y.out ↔ x = y 
goal: x.out ≈ y.out ↔ x = y

full_name: Quotient.out_injective
code: theorem Quotient.out_injective {s : Setoid α} : Function.Injective (@Quotient.out α s) 
goal: Function.Injective Quotient.out

full_name: Quotient.out_inj
code: @[simp]
theorem Quotient.out_inj {s : Setoid α} {x y : Quotient s} : x.out = y.out ↔ x = y 
goal: x.out = y.out ↔ x = y

full_name: piSetoid
code: instance piSetoid {ι : Sort*} {α : ι → Sort*} [∀ i, Setoid (α i)] : Setoid (∀ i, α i) 
goal: Setoid ((i : ι) → α i)

full_name: Quotient.choice
code: /-- Given a function `f : Π i, Quotient (S i)`, returns the class of functions `Π i, α i` sending
each `i` to an element of the class `f i`. -/
noncomputable def Quotient.choice {ι : Type*} {α : ι → Type*} [S : ∀ i, Setoid (α i)]
    (f : ∀ i, Quotient (S i)) :
    @Quotient (∀ i, α i) (by infer_instance) 
goal: Quotient inferInstance

full_name: Quotient.choice_eq
code: @[simp]
theorem Quotient.choice_eq {ι : Type*} {α : ι → Type*} [∀ i, Setoid (α i)] (f : ∀ i, α i) :
    (Quotient.choice fun i ↦ ⟦f i⟧) = ⟦f⟧ 
goal: (Quotient.choice fun i => ⟦f i⟧) = ⟦f⟧

full_name: Quotient.induction_on_pi
code: @[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 
goal: p f

full_name: nonempty_quotient_iff
code: theorem nonempty_quotient_iff (s : Setoid α) : Nonempty (Quotient s) ↔ Nonempty α 
goal: Nonempty (Quotient s) ↔ Nonempty α

full_name: true_equivalence
code: theorem true_equivalence : @Equivalence α fun _ _ ↦ True 
goal: Equivalence fun x x => True

full_name: trueSetoid
code: /-- Always-true relation as a `Setoid`.

Note that in later files the preferred spelling is `⊤ : Setoid α`. -/
def trueSetoid : Setoid α 
goal: Setoid α

full_name: Trunc
code: /-- `Trunc α` is the quotient of `α` by the always-true relation. This
  is related to the propositional truncation in HoTT, and is similar
  in effect to `Nonempty α`, but unlike `Nonempty α`, `Trunc α` is data,
  so the VM representation is the same as `α`, and so this can be used to
  maintain computability. -/
def Trunc.{u} (α : Sort u) : Sort u 
goal: Sort u

full_name: Trunc.mk
code: /-- Constructor for `Trunc α` -/
def mk (a : α) : Trunc α 
goal: Trunc α

full_name: Trunc.instInhabited
code: instance [Inhabited α] : Inhabited (Trunc α) 
goal: Inhabited (Trunc α)

full_name: Trunc.lift
code: /-- Any constant function lifts to a function out of the truncation -/
def lift (f : α → β) (c : ∀ a b : α, f a = f b) : Trunc α → β 
goal: Trunc α → β

full_name: Trunc.ind
code: theorem ind {β : Trunc α → Prop} : (∀ a : α, β (mk a)) → ∀ q : Trunc α, β q 
goal: (∀ (a : α), β (Trunc.mk a)) → ∀ (q : Trunc α), β q

full_name: Trunc.lift_mk
code: protected theorem lift_mk (f : α → β) (c) (a : α) : lift f c (mk a) = f a 
goal: Trunc.lift f c (Trunc.mk a) = f a

full_name: Trunc.liftOn
code: /-- Lift a constant function on `q : Trunc α`. -/
-- Porting note: removed `@[elab_as_elim]` because it gave "unexpected eliminator resulting type"
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
protected def liftOn (q : Trunc α) (f : α → β) (c : ∀ a b : α, f a = f b) : β 
goal: β

full_name: Trunc.induction_on
code: @[elab_as_elim]
protected theorem induction_on {β : Trunc α → Prop} (q : Trunc α) (h : ∀ a, β (mk a)) : β q 
goal: β q

full_name: Trunc.exists_rep
code: theorem exists_rep (q : Trunc α) : ∃ a : α, mk a = q 
goal: ∃ a, Trunc.mk a = q

full_name: Trunc.induction_on₂
code: @[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₂ 
goal: C q₁ q₂

full_name: Trunc.eq
code: protected theorem eq (a b : Trunc α) : a = b 
goal: a = b

full_name: Trunc.instSubsingletonTrunc
code: instance instSubsingletonTrunc : Subsingleton (Trunc α) 
goal: Subsingleton (Trunc α)

full_name: Trunc.bind
code: /-- The `bind` operator for the `Trunc` monad. -/
def bind (q : Trunc α) (f : α → Trunc β) : Trunc β 
goal: Trunc β

full_name: Trunc.map
code: /-- A function `f : α → β` defines a function `map f : Trunc α → Trunc β`. -/
def map (f : α → β) (q : Trunc α) : Trunc β 
goal: Trunc β

full_name: Trunc.instMonad
code: instance : Monad Trunc 
goal: Monad Trunc

full_name: Trunc.instLawfulMonad
code: instance : LawfulMonad Trunc 
goal: LawfulMonad Trunc

full_name: Trunc.rec
code: /-- Recursion/induction principle for `Trunc`. -/
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
@[elab_as_elim]
protected def rec (f : ∀ a, C (mk a))
    (h : ∀ a b : α, (Eq.ndrec (f a) (Trunc.eq (mk a) (mk b)) : C (mk b)) = f b)
    (q : Trunc α) : C q 
goal: C q

full_name: Trunc.recOn
code: /-- A version of `Trunc.rec` taking `q : Trunc α` as the first argument. -/
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
@[elab_as_elim]
protected def recOn (q : Trunc α) (f : ∀ a, C (mk a))
    (h : ∀ a b : α, (Eq.ndrec (f a) (Trunc.eq (mk a) (mk b)) : C (mk b)) = f b) : C q 
goal: C q

full_name: Trunc.recOnSubsingleton
code: /-- A version of `Trunc.recOn` assuming the codomain is a `Subsingleton`. -/
-- porting note (#11083)s: removed `@[reducible]` because it caused extremely slow `simp`
@[elab_as_elim]
protected def recOnSubsingleton [∀ a, Subsingleton (C (mk a))] (q : Trunc α) (f : ∀ a, C (mk a)) :
    C q 
goal: C q

full_name: Trunc.out
code: /-- Noncomputably extract a representative of `Trunc α` (using the axiom of choice). -/
noncomputable def out : Trunc α → α 
goal: Trunc α → α

full_name: Trunc.out_eq
code: @[simp]
theorem out_eq (q : Trunc α) : mk q.out = q 
goal: Trunc.mk q.out = q

full_name: Trunc.nonempty
code: protected theorem nonempty (q : Trunc α) : Nonempty α 
goal: Nonempty α

full_name: Quotient.mk''
code: /-- A version of `Quotient.mk` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. -/
protected def mk'' (a : α) : Quotient s₁ 
goal: Quotient s₁

full_name: Quotient.surjective_Quotient_mk''
code: /-- `Quotient.mk''` is a surjective function. -/
theorem surjective_Quotient_mk'' : Function.Surjective (Quotient.mk'' : α → Quotient s₁) 
goal: Function.Surjective Quotient.mk''

full_name: Quotient.liftOn'
code: /-- A version of `Quotient.liftOn` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. -/
-- Porting note: removed `@[elab_as_elim]` because it gave "unexpected eliminator resulting type"
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
protected def liftOn' (q : Quotient s₁) (f : α → φ) (h : ∀ a b, @Setoid.r α s₁ a b → f a = f b) :
    φ 
goal: φ

full_name: Quotient.liftOn'_mk''
code: @[simp]
protected theorem liftOn'_mk'' (f : α → φ) (h) (x : α) :
    Quotient.liftOn' (@Quotient.mk'' _ s₁ x) f h = f x 
goal: (Quotient.mk'' x).liftOn' f h = f x

full_name: Quotient.surjective_liftOn'
code: @[simp] lemma surjective_liftOn' {f : α → φ} (h) :
    Function.Surjective (fun x : Quotient s₁ ↦ x.liftOn' f h) ↔ Function.Surjective f 
goal: (Function.Surjective fun x => x.liftOn' f h) ↔ Function.Surjective f

full_name: Quotient.liftOn₂'
code: /-- A version of `Quotient.liftOn₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments. -/
-- Porting note: removed `@[elab_as_elim]` because it gave "unexpected eliminator resulting type"
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
protected def liftOn₂' (q₁ : Quotient s₁) (q₂ : Quotient s₂) (f : α → β → γ)
    (h : ∀ a₁ a₂ b₁ b₂, @Setoid.r α s₁ a₁ b₁ → @Setoid.r β s₂ a₂ b₂ → f a₁ a₂ = f b₁ b₂) : γ 
goal: γ

full_name: Quotient.liftOn₂'_mk''
code: @[simp]
protected theorem liftOn₂'_mk'' (f : α → β → γ) (h) (a : α) (b : β) :
    Quotient.liftOn₂' (@Quotient.mk'' _ s₁ a) (@Quotient.mk'' _ s₂ b) f h = f a b 
goal: (Quotient.mk'' a).liftOn₂' (Quotient.mk'' b) f h = f a b

full_name: Quotient.ind'
code: /-- A version of `Quotient.ind` taking `{s : Setoid α}` as an implicit argument instead of an
instance argument. -/
@[elab_as_elim]
protected theorem ind' {p : Quotient s₁ → Prop} (h : ∀ a, p (Quotient.mk'' a)) (q : Quotient s₁) :
    p q 
goal: p q

full_name: Quotient.ind₂'
code: /-- A version of `Quotient.ind₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit arguments
instead of instance arguments. -/
@[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₂ 
goal: p q₁ q₂

full_name: Quotient.inductionOn'
code: /-- A version of `Quotient.inductionOn` taking `{s : Setoid α}` as an implicit argument instead
of an instance argument. -/
@[elab_as_elim]
protected theorem inductionOn' {p : Quotient s₁ → Prop} (q : Quotient s₁)
    (h : ∀ a, p (Quotient.mk'' a)) : p q 
goal: p q

full_name: Quotient.inductionOn₂'
code: /-- A version of `Quotient.inductionOn₂` taking `{s₁ : Setoid α} {s₂ : Setoid β}` as implicit
arguments instead of instance arguments. -/
@[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₂ 
goal: p q₁ q₂

full_name: Quotient.inductionOn₃'
code: /-- A version of `Quotient.inductionOn₃` taking `{s₁ : Setoid α} {s₂ : Setoid β} {s₃ : Setoid γ}`
as implicit arguments instead of instance arguments. -/
@[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₃ 
goal: p q₁ q₂ q₃

full_name: Quotient.recOnSubsingleton'
code: /-- A version of `Quotient.recOnSubsingleton` taking `{s₁ : Setoid α}` as an implicit argument
instead of an instance argument. -/
@[elab_as_elim]
protected def recOnSubsingleton' {φ : Quotient s₁ → Sort*} [∀ a, Subsingleton (φ ⟦a⟧)]
    (q : Quotient s₁)
    (f : ∀ a, φ (Quotient.mk'' a)) : φ q 
goal: φ q

full_name: Quotient.recOnSubsingleton₂'
code: /-- A version of `Quotient.recOnSubsingleton₂` taking `{s₁ : Setoid α} {s₂ : Setoid α}`
as implicit arguments instead of instance arguments. -/
-- porting note (#11083): removed `@[reducible]` because it caused extremely slow `simp`
@[elab_as_elim]
protected def recOnSubsingleton₂' {φ : Quotient s₁ → Quotient s₂ → Sort*}
    [∀ a b, Subsingleton (φ ⟦a⟧ ⟦b⟧)]
    (q₁ : Quotient s₁) (q₂ : Quotient s₂) (f : ∀ a₁ a₂, φ (Quotient.mk'' a₁) (Quotient.mk'' a₂)) :
    φ q₁ q₂ 
goal: φ q₁ q₂

full_name: Quotient.hrecOn'
code: /-- Recursion on a `Quotient` argument `a`, result type depends on `⟦a⟧`. -/
protected def hrecOn' {φ : Quotient s₁ → Sort*} (qa : Quotient s₁) (f : ∀ a, φ (Quotient.mk'' a))
    (c : ∀ a₁ a₂, a₁ ≈ a₂ → HEq (f a₁) (f a₂)) : φ qa 
goal: φ qa

full_name: Quotient.hrecOn'_mk''
code: @[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 
goal: (Quotient.mk'' x).hrecOn' f c = f x

full_name: Quotient.hrecOn₂'
code: /-- Recursion on two `Quotient` arguments `a` and `b`, result type depends on `⟦a⟧` and `⟦b⟧`. -/
protected def hrecOn₂' {φ : Quotient s₁ → Quotient s₂ → Sort*} (qa : Quotient s₁)
    (qb : Quotient s₂) (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₂)) :
    φ qa qb 
goal: φ qa qb

full_name: Quotient.hrecOn₂'_mk''
code: @[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 _) 
goal: (Quotient.mk'' x).hrecOn₂' qb f c = qb.hrecOn' (f x) ⋯

full_name: Quotient.map'
code: /-- Map a function `f : α → β` that sends equivalent elements to equivalent elements
to a function `Quotient sa → Quotient sb`. Useful to define unary operations on quotients. -/
protected def map' (f : α → β) (h : (s₁.r ⇒ s₂.r) f f) : Quotient s₁ → Quotient s₂ 
goal: Quotient s₁ → Quotient s₂

full_name: Quotient.map'_mk''
code: @[simp]
theorem map'_mk'' (f : α → β) (h) (x : α) :
    (Quotient.mk'' x : Quotient s₁).map' f h = (Quotient.mk'' (f x) : Quotient s₂) 
goal: Quotient.map' f h (Quotient.mk'' x) = Quotient.mk'' (f x)

full_name: Quotient.map₂'
code: /-- A version of `Quotient.map₂` using curly braces and unification. -/
protected def map₂' (f : α → β → γ) (h : (s₁.r ⇒ s₂.r ⇒ s₃.r) f f) :
    Quotient s₁ → Quotient s₂ → Quotient s₃ 
goal: Quotient s₁ → Quotient s₂ → Quotient s₃

full_name: Quotient.map₂'_mk''
code: @[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₃) 
goal: Quotient.map₂' f h (Quotient.mk'' x) = Quotient.map' (f x) ⋯

full_name: Quotient.exact'
code: theorem exact' {a b : α} :
    (Quotient.mk'' a : Quotient s₁) = Quotient.mk'' b → @Setoid.r _ s₁ a b 
goal: Quotient.mk'' a = Quotient.mk'' b → Setoid.r a b

full_name: Quotient.sound'
code: theorem sound' {a b : α} : @Setoid.r _ s₁ a b → @Quotient.mk'' α s₁ a = Quotient.mk'' b 
goal: Setoid.r a b → Quotient.mk'' a = Quotient.mk'' b

full_name: Quotient.eq'
code: @[simp]
protected theorem eq' [s₁ : Setoid α] {a b : α} :
    @Quotient.mk' α s₁ a = @Quotient.mk' α s₁ b ↔ @Setoid.r _ s₁ a b 
goal: Quotient.mk' a = Quotient.mk' b ↔ Setoid.r a b

full_name: Quotient.eq''
code: @[simp]
protected theorem eq'' {a b : α} : @Quotient.mk'' α s₁ a = Quotient.mk'' b ↔ @Setoid.r _ s₁ a b 
goal: Quotient.mk'' a = Quotient.mk'' b ↔ Setoid.r a b

full_name: Quotient.out'
code: /-- A version of `Quotient.out` taking `{s₁ : Setoid α}` as an implicit argument instead of an
instance argument. -/
noncomputable def out' (a : Quotient s₁) : α 
goal: α

full_name: Quotient.out_eq'
code: @[simp]
theorem out_eq' (q : Quotient s₁) : Quotient.mk'' q.out' = q 
goal: Quotient.mk'' q.out' = q

full_name: Quotient.mk_out'
code: theorem mk_out' (a : α) : @Setoid.r α s₁ (Quotient.mk'' a : Quotient s₁).out' a 
goal: Setoid.r (Quotient.mk'' a).out' a

full_name: Quotient.mk''_eq_mk
code: protected theorem mk''_eq_mk : Quotient.mk'' = Quotient.mk s 
goal: Quotient.mk'' = Quotient.mk s

full_name: Quotient.liftOn'_mk
code: @[simp]
protected theorem liftOn'_mk (x : α) (f : α → β) (h) : (Quotient.mk s x).liftOn' f h = f x 
goal: ⟦x⟧.liftOn' f h = f x

full_name: Quotient.liftOn₂'_mk
code: @[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 
goal: ⟦a⟧.liftOn₂' ⟦b⟧ f h = f a b

full_name: Quotient.map'_mk
code: @[simp]
theorem map'_mk [t : Setoid β] (f : α → β) (h) (x : α) :
    (Quotient.mk s x).map' f h = (Quotient.mk t (f x)) 
goal: Quotient.map' f h ⟦x⟧ = ⟦f x⟧

full_name: Quotient.instDecidableLiftOn'OfDecidablePred
code: instance (q : Quotient s₁) (f : α → Prop) (h : ∀ a b, @Setoid.r α s₁ a b → f a = f b)
    [DecidablePred f] :
    Decidable (Quotient.liftOn' q f h) 
goal: Decidable (q.liftOn' f h)

full_name: Quotient.instDecidableLiftOn₂'OfDecidablePred
code: instance (q₁ : Quotient s₁) (q₂ : Quotient s₂) (f : α → β → Prop)
    (h : ∀ a₁ b₁ a₂ b₂, @Setoid.r α s₁ a₁ a₂ → @Setoid.r β s₂ b₁ b₂ → f a₁ b₁ = f a₂ b₂)
    [∀ a, DecidablePred (f a)] :
    Decidable (Quotient.liftOn₂' q₁ q₂ f h) 
goal: Decidable (q₁.liftOn₂' q₂ f h)

full_name: Equivalence.quot_mk_eq_iff
code: @[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 
goal: Quot.mk r x = Quot.mk r y ↔ r x y