File: Mathlib/Logic/Nonempty.lean

full_name: Nonempty.forall
code: @[simp]
theorem Nonempty.forall {α} {p : Nonempty α → Prop} : (∀ h : Nonempty α, p h) ↔ ∀ a, p ⟨a⟩ 
goal: (∀ (h : Nonempty α), p h) ↔ ∀ (a : α), p ⋯

full_name: Nonempty.exists
code: @[simp]
theorem Nonempty.exists {α} {p : Nonempty α → Prop} : (∃ h : Nonempty α, p h) ↔ ∃ a, p ⟨a⟩ 
goal: (∃ h, p h) ↔ ∃ a, p ⋯

full_name: exists_true_iff_nonempty
code: theorem exists_true_iff_nonempty {α : Sort*} : (∃ _ : α, True) ↔ Nonempty α 
goal: (∃ x, True) ↔ Nonempty α

full_name: nonempty_Prop
code: @[simp]
theorem nonempty_Prop {p : Prop} : Nonempty p ↔ p 
goal: Nonempty p ↔ p

full_name: Nonempty.imp
code: theorem Nonempty.imp {α} {p : Prop} : (Nonempty α → p) ↔ (α → p) 
goal: Nonempty α → p ↔ α → p

full_name: not_nonempty_iff_imp_false
code: theorem not_nonempty_iff_imp_false {α : Sort*} : ¬Nonempty α ↔ α → False 
goal: ¬Nonempty α ↔ α → False

full_name: nonempty_psigma
code: @[simp]
theorem nonempty_psigma {α} {β : α → Sort*} : Nonempty (PSigma β) ↔ ∃ a : α, Nonempty (β a) 
goal: Nonempty (PSigma β) ↔ ∃ a, Nonempty (β a)

full_name: nonempty_subtype
code: @[simp]
theorem nonempty_subtype {α} {p : α → Prop} : Nonempty (Subtype p) ↔ ∃ a : α, p a 
goal: Nonempty (Subtype p) ↔ ∃ a, p a

full_name: nonempty_pprod
code: @[simp]
theorem nonempty_pprod {α β} : Nonempty (PProd α β) ↔ Nonempty α ∧ Nonempty β 
goal: Nonempty (PProd α β) ↔ Nonempty α ∧ Nonempty β

full_name: nonempty_psum
code: @[simp]
theorem nonempty_psum {α β} : Nonempty (α ⊕' β) ↔ Nonempty α ∨ Nonempty β 
goal: Nonempty (α ⊕' β) ↔ Nonempty α ∨ Nonempty β

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

full_name: Classical.inhabited_of_nonempty'
code: /-- Using `Classical.choice`, lifts a (`Prop`-valued) `Nonempty` instance to a (`Type`-valued)
  `Inhabited` instance. `Classical.inhabited_of_nonempty` already exists, in
  `Init/Classical.lean`, but the assumption is not a type class argument,
  which makes it unsuitable for some applications. -/
noncomputable def Classical.inhabited_of_nonempty' {α} [h : Nonempty α] : Inhabited α 
goal: Inhabited α

full_name: Nonempty.some
code: /-- Using `Classical.choice`, extracts a term from a `Nonempty` type. -/
protected noncomputable abbrev Nonempty.some {α} (h : Nonempty α) : α 
goal: α

full_name: Classical.arbitrary
code: /-- Using `Classical.choice`, extracts a term from a `Nonempty` type. -/
protected noncomputable abbrev Classical.arbitrary (α) [h : Nonempty α] : α 
goal: α

full_name: Nonempty.map
code: /-- Given `f : α → β`, if `α` is nonempty then `β` is also nonempty.
  `Nonempty` cannot be a `functor`, because `Functor` is restricted to `Type`. -/
theorem Nonempty.map {α β} (f : α → β) : Nonempty α → Nonempty β
  
goal: Nonempty α → Nonempty β

full_name: Nonempty.map2
code: protected theorem Nonempty.map2 {α β γ : Sort*} (f : α → β → γ) :
    Nonempty α → Nonempty β → Nonempty γ
  
goal: Nonempty α → Nonempty β → Nonempty γ

full_name: Nonempty.congr
code: protected theorem Nonempty.congr {α β} (f : α → β) (g : β → α) : Nonempty α ↔ Nonempty β 
goal: Nonempty α ↔ Nonempty β

full_name: Nonempty.elim_to_inhabited
code: theorem Nonempty.elim_to_inhabited {α : Sort*} [h : Nonempty α] {p : Prop} (f : Inhabited α → p) :
    p 
goal: p

full_name: Prod.instNonempty
code: protected instance Prod.instNonempty {α β} [h : Nonempty α] [h2 : Nonempty β] : Nonempty (α × β) 
goal: Nonempty (α × β)

full_name: Pi.instNonempty
code: protected instance Pi.instNonempty {ι : Sort*} {α : ι → Sort*} [∀ i, Nonempty (α i)] :
    Nonempty (∀ i, α i) 
goal: Nonempty ((i : ι) → α i)

full_name: Classical.nonempty_pi
code: theorem Classical.nonempty_pi {ι} {α : ι → Sort*} : Nonempty (∀ i, α i) ↔ ∀ i, Nonempty (α i) 
goal: Nonempty ((i : ι) → α i) ↔ ∀ (i : ι), Nonempty (α i)

full_name: subsingleton_of_not_nonempty
code: theorem subsingleton_of_not_nonempty {α : Sort*} (h : ¬Nonempty α) : Subsingleton α 
goal: Subsingleton α

full_name: Function.Surjective.nonempty
code: theorem Function.Surjective.nonempty [h : Nonempty β] {f : α → β} (hf : Function.Surjective f) :
    Nonempty α 
goal: Nonempty α

full_name: Zero.instNonempty
code: instance (priority := 20) Zero.instNonempty [Zero α] : Nonempty α 
goal: Nonempty α

full_name: One.instNonempty
code: instance (priority := 20) One.instNonempty [One α] : Nonempty α 
goal: Nonempty α

full_name: nonempty_sigma
code: @[simp]
theorem nonempty_sigma : Nonempty (Σa : α, γ a) ↔ ∃ a : α, Nonempty (γ a) 
goal: Nonempty ((a : α) × γ a) ↔ ∃ a, Nonempty (γ a)

full_name: nonempty_sum
code: @[simp]
theorem nonempty_sum : Nonempty (α ⊕ β) ↔ Nonempty α ∨ Nonempty β 
goal: Nonempty (α ⊕ β) ↔ Nonempty α ∨ Nonempty β

full_name: nonempty_prod
code: @[simp]
theorem nonempty_prod : Nonempty (α × β) ↔ Nonempty α ∧ Nonempty β 
goal: Nonempty (α × β) ↔ Nonempty α ∧ Nonempty β

full_name: nonempty_ulift
code: @[simp]
theorem nonempty_ulift : Nonempty (ULift α) ↔ Nonempty α 
goal: Nonempty (ULift.{u_4, u_1} α) ↔ Nonempty α