File: Mathlib/Logic/IsEmpty.lean

full_name: IsEmpty
code: /-- `IsEmpty α` expresses that `α` is empty. -/
class IsEmpty (α : Sort*) : Prop where
  protected false : α → False
goal: Prop

full_name: IsEmpty.false
code: /-- `IsEmpty α` expresses that `α` is empty. -/
class IsEmpty (α : Sort*) : Prop where
  protected false : α → False
goal: α → False

full_name: instIsEmptyEmpty
code: instance instIsEmptyEmpty : IsEmpty Empty 
goal: IsEmpty Empty

full_name: instIsEmptyPEmpty
code: instance instIsEmptyPEmpty : IsEmpty PEmpty 
goal: IsEmpty PEmpty.{u_4}

full_name: instIsEmptyFalse
code: instance : IsEmpty False 
goal: IsEmpty False

full_name: Fin.isEmpty
code: instance Fin.isEmpty : IsEmpty (Fin 0) 
goal: IsEmpty (Fin 0)

full_name: Fin.isEmpty'
code: instance Fin.isEmpty' : IsEmpty (Fin Nat.zero) 
goal: IsEmpty (Fin Nat.zero)

full_name: Function.isEmpty
code: protected theorem Function.isEmpty [IsEmpty β] (f : α → β) : IsEmpty α 
goal: IsEmpty α

full_name: Function.Surjective.isEmpty
code: theorem Function.Surjective.isEmpty [IsEmpty α] {f : α → β} (hf : f.Surjective) : IsEmpty β 
goal: IsEmpty β

full_name: instIsEmptyForallOfNonempty
code: instance {p : α → Sort*} [h : Nonempty α] [∀ x, IsEmpty (p x)] : IsEmpty (∀ x, p x) 
goal: IsEmpty ((x : α) → p x)

full_name: PProd.isEmpty_left
code: instance PProd.isEmpty_left [IsEmpty α] : IsEmpty (PProd α β) 
goal: IsEmpty (PProd α β)

full_name: PProd.isEmpty_right
code: instance PProd.isEmpty_right [IsEmpty β] : IsEmpty (PProd α β) 
goal: IsEmpty (PProd α β)

full_name: Prod.isEmpty_left
code: instance Prod.isEmpty_left {α β} [IsEmpty α] : IsEmpty (α × β) 
goal: IsEmpty (α × β)

full_name: Prod.isEmpty_right
code: instance Prod.isEmpty_right {α β} [IsEmpty β] : IsEmpty (α × β) 
goal: IsEmpty (α × β)

full_name: Quot.instIsEmpty
code: instance Quot.instIsEmpty {α : Sort*} [IsEmpty α] {r : α → α → Prop} : IsEmpty (Quot r) 
goal: IsEmpty (Quot r)

full_name: Quotient.instIsEmpty
code: instance Quotient.instIsEmpty {α : Sort*} [IsEmpty α] {s : Setoid α} : IsEmpty (Quotient s) 
goal: IsEmpty (Quotient s)

full_name: instIsEmptyPSum
code: instance [IsEmpty α] [IsEmpty β] : IsEmpty (α ⊕' β) 
goal: IsEmpty (α ⊕' β)

full_name: instIsEmptySum
code: instance instIsEmptySum {α β} [IsEmpty α] [IsEmpty β] : IsEmpty (α ⊕ β) 
goal: IsEmpty (α ⊕ β)

full_name: instIsEmptySubtype
code: /-- subtypes of an empty type are empty -/
instance [IsEmpty α] (p : α → Prop) : IsEmpty (Subtype p) 
goal: IsEmpty (Subtype p)

full_name: Subtype.isEmpty_of_false
code: /-- subtypes by an all-false predicate are false. -/
theorem Subtype.isEmpty_of_false {p : α → Prop} (hp : ∀ a, ¬p a) : IsEmpty (Subtype p) 
goal: IsEmpty (Subtype p)

full_name: Subtype.isEmpty_false
code: /-- subtypes by false are false. -/
instance Subtype.isEmpty_false : IsEmpty { _a : α // False } 
goal: IsEmpty { _a // False }

full_name: Sigma.isEmpty_left
code: instance Sigma.isEmpty_left {α} [IsEmpty α] {E : α → Type*} : IsEmpty (Sigma E) 
goal: IsEmpty (Sigma E)

full_name: isEmptyElim
code: /-- Eliminate out of a type that `IsEmpty` (without using projection notation). -/
@[elab_as_elim]
def isEmptyElim [IsEmpty α] {p : α → Sort*} (a : α) : p a 
goal: p a

full_name: isEmpty_iff
code: theorem isEmpty_iff : IsEmpty α ↔ α → False 
goal: IsEmpty α ↔ α → False

full_name: IsEmpty.elim
code: /-- Eliminate out of a type that `IsEmpty` (using projection notation). -/
@[elab_as_elim]
protected def elim {α : Sort u} (_ : IsEmpty α) {p : α → Sort*} (a : α) : p a 
goal: IsEmpty α → {p : α → Sort u_4} → (a : α) → p a

full_name: IsEmpty.elim'
code: /-- Non-dependent version of `IsEmpty.elim`. Helpful if the elaborator cannot elaborate `h.elim a`
  correctly. -/
protected def elim' {β : Sort*} (h : IsEmpty α) (a : α) : β 
goal: β

full_name: IsEmpty.prop_iff
code: protected theorem prop_iff {p : Prop} : IsEmpty p ↔ ¬p 
goal: IsEmpty p ↔ ¬p

full_name: IsEmpty.forall_iff
code: @[simp]
theorem forall_iff {p : α → Prop} : (∀ a, p a) ↔ True 
goal: (∀ (a : α), p a) ↔ True

full_name: IsEmpty.exists_iff
code: @[simp]
theorem exists_iff {p : α → Prop} : (∃ a, p a) ↔ False 
goal: (∃ a, p a) ↔ False

full_name: IsEmpty.instSubsingleton
code: instance (priority := 100) : Subsingleton α 
goal: Subsingleton α

full_name: not_nonempty_iff
code: @[simp]
theorem not_nonempty_iff : ¬Nonempty α ↔ IsEmpty α 
goal: ¬Nonempty α ↔ IsEmpty α

full_name: not_isEmpty_iff
code: @[simp]
theorem not_isEmpty_iff : ¬IsEmpty α ↔ Nonempty α 
goal: ¬IsEmpty α ↔ Nonempty α

full_name: isEmpty_Prop
code: @[simp]
theorem isEmpty_Prop {p : Prop} : IsEmpty p ↔ ¬p 
goal: IsEmpty p ↔ ¬p

full_name: isEmpty_pi
code: @[simp]
theorem isEmpty_pi {π : α → Sort*} : IsEmpty (∀ a, π a) ↔ ∃ a, IsEmpty (π a) 
goal: IsEmpty ((a : α) → π a) ↔ ∃ a, IsEmpty (π a)

full_name: isEmpty_fun
code: theorem isEmpty_fun : IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β 
goal: IsEmpty (α → β) ↔ Nonempty α ∧ IsEmpty β

full_name: nonempty_fun
code: @[simp]
theorem nonempty_fun : Nonempty (α → β) ↔ IsEmpty α ∨ Nonempty β 
goal: Nonempty (α → β) ↔ IsEmpty α ∨ Nonempty β

full_name: isEmpty_sigma
code: @[simp]
theorem isEmpty_sigma {α} {E : α → Type*} : IsEmpty (Sigma E) ↔ ∀ a, IsEmpty (E a) 
goal: IsEmpty (Sigma E) ↔ ∀ (a : α), IsEmpty (E a)

full_name: isEmpty_psigma
code: @[simp]
theorem isEmpty_psigma {α} {E : α → Sort*} : IsEmpty (PSigma E) ↔ ∀ a, IsEmpty (E a) 
goal: IsEmpty (PSigma E) ↔ ∀ (a : α), IsEmpty (E a)

full_name: isEmpty_subtype
code: @[simp]
theorem isEmpty_subtype (p : α → Prop) : IsEmpty (Subtype p) ↔ ∀ x, ¬p x 
goal: IsEmpty (Subtype p) ↔ ∀ (x : α), ¬p x

full_name: isEmpty_prod
code: @[simp]
theorem isEmpty_prod {α β : Type*} : IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β 
goal: IsEmpty (α × β) ↔ IsEmpty α ∨ IsEmpty β

full_name: isEmpty_pprod
code: @[simp]
theorem isEmpty_pprod : IsEmpty (PProd α β) ↔ IsEmpty α ∨ IsEmpty β 
goal: IsEmpty (PProd α β) ↔ IsEmpty α ∨ IsEmpty β

full_name: isEmpty_sum
code: @[simp]
theorem isEmpty_sum {α β} : IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β 
goal: IsEmpty (α ⊕ β) ↔ IsEmpty α ∧ IsEmpty β

full_name: isEmpty_psum
code: @[simp]
theorem isEmpty_psum {α β} : IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β 
goal: IsEmpty (α ⊕' β) ↔ IsEmpty α ∧ IsEmpty β

full_name: isEmpty_ulift
code: @[simp]
theorem isEmpty_ulift {α} : IsEmpty (ULift α) ↔ IsEmpty α 
goal: IsEmpty (ULift.{u_5, u_4} α) ↔ IsEmpty α

full_name: isEmpty_plift
code: @[simp]
theorem isEmpty_plift {α} : IsEmpty (PLift α) ↔ IsEmpty α 
goal: IsEmpty (PLift α) ↔ IsEmpty α

full_name: wellFounded_of_isEmpty
code: theorem wellFounded_of_isEmpty {α} [IsEmpty α] (r : α → α → Prop) : WellFounded r 
goal: WellFounded r

full_name: isEmpty_or_nonempty
code: theorem isEmpty_or_nonempty : IsEmpty α ∨ Nonempty α 
goal: IsEmpty α ∨ Nonempty α

full_name: not_isEmpty_of_nonempty
code: @[simp]
theorem not_isEmpty_of_nonempty [h : Nonempty α] : ¬IsEmpty α 
goal: ¬IsEmpty α

full_name: Function.extend_of_isEmpty
code: theorem Function.extend_of_isEmpty [IsEmpty α] (f : α → β) (g : α → γ) (h : β → γ) :
    Function.extend f g h = h 
goal: Function.extend f g h = h