Classical reasoning support

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

noncomputable def Classical.choose {α : Sort u} {p : α → Prop} (h : ∃ x, p x) : α

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

theorem Classical.em (p : Prop) : p ∨ ¬p

Diaconescu's theorem: excluded middle from choice, Function extensionality and propositional extensionality.

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

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

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

noncomputable def Classical.propDecidable (a : Prop) : Decidable a

All propositions are Decidable.

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

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

noncomputable def Classical.typeDecidable (α : Sort u) : α ⊕' (α → False)

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

noncomputable def Classical.epsilon {α : Sort u} [h : Nonempty α] (p : α → Prop) : α

the Hilbert epsilon Function

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

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

theorem Classical.epsilon_singleton {α : Sort u} (x : α) : (Classical.epsilon fun y => y = x) = x

theorem Classical.axiomOfChoice {α : Sort u} {β : α → Sort v} {r : (x : α) → β x → Prop} (h : ∀ (x : α), ∃ y, r x y) : ∃ f, (x : α) → r x (f x)

the axiom of choice

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

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

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

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

def Classical.«tacticBy_cases_:_» : Lean.ParserDescr

by_cases (h :)? p splits the main goal into two cases, assuming h : p in the first branch, and h : ¬ p in the second branch.