File: .lake/packages/lean4/src/lean/Init/Classical.lean

full_name: Classical.indefiniteDescription
code: noncomputable def indefiniteDescription {α : Sort u} (p : α → Prop) (h : ∃ x, p x) : {x // p x} 
goal: { x // p x }

full_name: Classical.choose
code: /--
Given that there exists an element satisfying `p`, returns one such element.

This is a straightforward consequence of, and equivalent to, `Classical.choice`.

See also `choose_spec`, which asserts that the returned value has property `p`.
-/
noncomputable def choose {α : Sort u} {p : α → Prop} (h : ∃ x, p x) : α 
goal: α

full_name: Classical.choose_spec
code: theorem choose_spec {α : Sort u} {p : α → Prop} (h : ∃ x, p x) : p (choose h) 
goal: p (Classical.choose h)

full_name: Classical.em
code: /-- **Diaconescu's theorem**: excluded middle from choice, Function extensionality and propositional extensionality. -/
theorem em (p : Prop) : p ∨ ¬p 
goal: p ∨ ¬p

full_name: Classical.exists_true_of_nonempty
code: theorem exists_true_of_nonempty {α : Sort u} : Nonempty α → ∃ _ : α, True
  
goal: Nonempty α → ∃ x, True

full_name: Classical.inhabited_of_nonempty
code: noncomputable def inhabited_of_nonempty {α : Sort u} (h : Nonempty α) : Inhabited α 
goal: Inhabited α

full_name: Classical.inhabited_of_exists
code: noncomputable def inhabited_of_exists {α : Sort u} {p : α → Prop} (h : ∃ x, p x) : Inhabited α 
goal: Inhabited α

full_name: Classical.propDecidable
code: /-- All propositions are `Decidable`. -/
noncomputable scoped instance (priority := low) propDecidable (a : Prop) : Decidable a 
goal: Decidable a

full_name: Classical.decidableInhabited
code: noncomputable def decidableInhabited (a : Prop) : Inhabited (Decidable a) 
goal: Inhabited (Decidable a)

full_name: Classical.typeDecidableEq
code: noncomputable def typeDecidableEq (α : Sort u) : DecidableEq α 
goal: DecidableEq α

full_name: Classical.typeDecidable
code: noncomputable def typeDecidable (α : Sort u) : PSum α (α → False) 
goal: α ⊕' (α → False)

full_name: Classical.strongIndefiniteDescription
code: noncomputable def strongIndefiniteDescription {α : Sort u} (p : α → Prop) (h : Nonempty α) : {x : α // (∃ y : α, p y) → p x} 
goal: { x // (∃ y, p y) → p x }

full_name: Classical.epsilon
code: /-- the Hilbert epsilon Function -/
noncomputable def epsilon {α : Sort u} [h : Nonempty α] (p : α → Prop) : α 
goal: α

full_name: Classical.epsilon_spec_aux
code: theorem epsilon_spec_aux {α : Sort u} (h : Nonempty α) (p : α → Prop) : (∃ y, p y) → p (@epsilon α h p) 
goal: (∃ y, p y) → p (Classical.epsilon p)

full_name: Classical.epsilon_spec
code: theorem epsilon_spec {α : Sort u} {p : α → Prop} (hex : ∃ y, p y) : p (@epsilon α (nonempty_of_exists hex) p) 
goal: p (Classical.epsilon p)

full_name: Classical.epsilon_singleton
code: theorem epsilon_singleton {α : Sort u} (x : α) : @epsilon α ⟨x⟩ (fun y => y = x) = x 
goal: (Classical.epsilon fun y => y = x) = x

full_name: Classical.axiomOfChoice
code: /-- the axiom of choice -/
theorem axiomOfChoice {α : Sort u} {β : α → Sort v} {r : ∀ x, β x → Prop} (h : ∀ x, ∃ y, r x y) : ∃ (f : ∀ x, β x), ∀ x, r x (f x) 
goal: ∃ f, ∀ (x : α), r x (f x)

full_name: Classical.skolem
code: theorem skolem {α : Sort u} {b : α → Sort v} {p : ∀ x, b x → Prop} : (∀ x, ∃ y, p x y) ↔ ∃ (f : ∀ x, b x), ∀ x, p x (f x) 
goal: (∀ (x : α), ∃ y, p x y) ↔ ∃ f, ∀ (x : α), p x (f x)

full_name: Classical.propComplete
code: theorem propComplete (a : Prop) : a = True ∨ a = False 
goal: a = True ∨ a = False

full_name: Classical.byCases
code: theorem byCases {p q : Prop} (hpq : p → q) (hnpq : ¬p → q) : q 
goal: q

full_name: Classical.byContradiction
code: theorem byContradiction {p : Prop} (h : ¬p → False) : p 
goal: p

full_name: Classical.not_not
code: /-- The Double Negation Theorem: `¬¬P` is equivalent to `P`.
The left-to-right direction, double negation elimination (DNE),
is classically true but not constructively. -/
@[simp] theorem not_not : ¬¬a ↔ a 
goal: ¬¬a ↔ a

full_name: Classical.not_forall
code: @[simp low] theorem not_forall {p : α → Prop} : (¬∀ x, p x) ↔ ∃ x, ¬p x 
goal: (¬∀ (x : α), p x) ↔ ∃ x, ¬p x

full_name: Classical.not_forall_not
code: theorem not_forall_not {p : α → Prop} : (¬∀ x, ¬p x) ↔ ∃ x, p x 
goal: (¬∀ (x : α), ¬p x) ↔ ∃ x, p x

full_name: Classical.not_exists_not
code: theorem not_exists_not {p : α → Prop} : (¬∃ x, ¬p x) ↔ ∀ x, p x 
goal: (¬∃ x, ¬p x) ↔ ∀ (x : α), p x

full_name: Classical.forall_or_exists_not
code: theorem forall_or_exists_not (P : α → Prop) : (∀ a, P a) ∨ ∃ a, ¬ P a 
goal: (∀ (a : α), P a) ∨ ∃ a, ¬P a

full_name: Classical.exists_or_forall_not
code: theorem exists_or_forall_not (P : α → Prop) : (∃ a, P a) ∨ ∀ a, ¬ P a 
goal: (∃ a, P a) ∨ ∀ (a : α), ¬P a

full_name: Classical.or_iff_not_imp_left
code: theorem or_iff_not_imp_left  : a ∨ b ↔ (¬a → b) 
goal: a ∨ b ↔ ¬a → b

full_name: Classical.or_iff_not_imp_right
code: theorem or_iff_not_imp_right : a ∨ b ↔ (¬b → a) 
goal: a ∨ b ↔ ¬b → a

full_name: Classical.not_imp_iff_and_not
code: theorem not_imp_iff_and_not : ¬(a → b) ↔ a ∧ ¬b 
goal: ¬(a → b) ↔ a ∧ ¬b

full_name: Classical.not_and_iff_or_not_not
code: theorem not_and_iff_or_not_not : ¬(a ∧ b) ↔ ¬a ∨ ¬b 
goal: ¬(a ∧ b) ↔ ¬a ∨ ¬b

full_name: Classical.not_iff
code: theorem not_iff : ¬(a ↔ b) ↔ (¬a ↔ b) 
goal: ¬(a ↔ b) ↔ (¬a ↔ b)

full_name: Classical.imp_iff_left_iff
code: @[simp] theorem imp_iff_left_iff  : (b ↔ a → b) ↔ a ∨ b 
goal: (b ↔ a → b) ↔ a ∨ b

full_name: Classical.imp_iff_right_iff
code: @[simp] theorem imp_iff_right_iff : (a → b ↔ b) ↔ a ∨ b 
goal: (a → b ↔ b) ↔ a ∨ b

full_name: Classical.and_or_imp
code: @[simp] theorem and_or_imp : a ∧ b ∨ (a → c) ↔ a → b ∨ c 
goal: a ∧ b ∨ (a → c) ↔ a → b ∨ c

full_name: Classical.not_imp
code: @[simp] theorem not_imp : ¬(a → b) ↔ a ∧ ¬b 
goal: ¬(a → b) ↔ a ∧ ¬b

full_name: Classical.imp_and_neg_imp_iff
code: @[simp] theorem imp_and_neg_imp_iff (p q : Prop) : (p → q) ∧ (¬p → q) ↔ q 
goal: (p → q) ∧ (¬p → q) ↔ q

full_name: Exists.choose
code: /-- Extract an element from a existential statement, using `Classical.choose`. -/
-- This enables projection notation.
@[reducible] noncomputable def Exists.choose {p : α → Prop} (P : ∃ a, p a) : α 
goal: α

full_name: Exists.choose_spec
code: /-- Show that an element extracted from `P : ∃ a, p a` using `P.choose` satisfies `p`. -/
theorem Exists.choose_spec {p : α → Prop} (P : ∃ a, p a) : p P.choose 
goal: p P.choose