statement stringlengths 1 8.65k | proof stringlengths 0 19.6k | type stringclasses 12
values | symbolic_name stringlengths 1 110 | library stringclasses 165
values | filename stringclasses 822
values | imports listlengths 0 19 | deps listlengths 0 64 | docstring stringlengths 0 3.64k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
Bool : Type where
/-- The Boolean value `false`, not to be confused with the proposition `False`. -/
| false : Bool
/-- The Boolean value `true`, not to be confused with the proposition `True`. -/
| true : Bool | inductive | Bool | Init | src/Init/Prelude.lean | [] | [] | The Boolean values, `true` and `false`.
Logically speaking, this is equivalent to `Prop` (the type of propositions). The distinction is
public important for programming: both propositions and their proofs are erased in the code generator,
while `Bool` corresponds to the Boolean type in most programming languages and c... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
isScalarObj {α : Type u} (x : α) : Bool | axiom | isScalarObj | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | Compute whether `x` is a tagged pointer or not. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
id {α : Sort u} (a : α) : α | a | def | id | Init | src/Init/Prelude.lean | [] | [] | The identity function. `id` takes an implicit argument `α : Sort u`
(a type in any universe), and an argument `a : α`, and returns `a`.
Although this may look like a useless function, one application of the identity
function is to explicitly put a type on an expression. If `e` has type `T`,
and `T'` is definitionally ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Function.comp {α : Sort u} {β : Sort v} {δ : Sort w} (f : β → δ) (g : α → β) : α → δ | fun x => f (g x) | def | Function.comp | Init | src/Init/Prelude.lean | [] | [] | Function composition, usually written with the infix operator `∘`. A new function is created from
two existing functions, where one function's output is used as input to the other.
Examples:
* `Function.comp List.reverse (List.drop 2) [3, 2, 4, 1] = [1, 4]`
* `(List.reverse ∘ List.drop 2) [3, 2, 4, 1] = [1, 4]` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Function.const {α : Sort u} (β : Sort v) (a : α) : β → α | fun _ => a | def | Function.const | Init | src/Init/Prelude.lean | [] | [] | The constant function that ignores its argument.
If `a : α`, then `Function.const β a : β → α` is the “constant function with value `a`”. For all
arguments `b : β`, `Function.const β a b = a`. It is often written directly as `fun _ => a`.
Examples:
* `Function.const Bool 10 true = 10`
* `Function.const Bool 10 fals... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
letFun {α : Sort u} {β : α → Sort v} (v : α) (f : (x : α) → β x) : β v | f v | def | letFun | Init | src/Init/Prelude.lean | [] | [] | `letFun v (fun x => b)` is a function version of `have x := v; b`.
This is equal to `(fun x => b) v`, so the value of `x` is not accessible to `b`.
This is in contrast to `let x := v; b`, where the value of `x` is accessible to `b`.
This used to be the way `have`/`let_fun` syntax was encoded,
and there used to be spec... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
inferInstance {α : Sort u} [i : α] : α | i | abbrev | inferInstance | Init | src/Init/Prelude.lean | [] | [] | `inferInstance` synthesizes a value of any target type by typeclass
inference. This function has the same type signature as the identity
function, but the square brackets on the `[i : α]` argument means that it will
attempt to construct this argument by typeclass inference. (This will fail if
`α` is not a `class`.) Exa... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
«inferInstanceAs» (α : Sort u) [i : α] : α | i | abbrev | «inferInstanceAs» | Init | src/Init/Prelude.lean | [] | [] | `inferInstanceAs α` synthesizes an instance of type `α` and then adjusts it to conform to the
expected type `β`, which must be inferable from context.
Example:
```
def D := Nat
instance : Inhabited D := inferInstanceAs (Inhabited Nat)
```
The adjustment will make sure that when the resulting instance will not "leak" ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Unit : Type | PUnit | abbrev | Unit | Init | src/Init/Prelude.lean | [] | [
"PUnit"
] | The canonical type with one element. This element is written `()`.
`Unit` has a number of uses:
* It can be used to model control flow that returns from a function call without providing other
information.
* Monadic actions that return `Unit` have side effects without computing values.
* In polymorphic types, it... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Unit.unit : Unit | PUnit.unit | abbrev | Unit.unit | Init | src/Init/Prelude.lean | [] | [
"Unit"
] | The only element of the unit type.
It can be written as an empty tuple: `()`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
lcProof {α : Prop} : α | axiom | lcProof | Init | src/Init/Prelude.lean | [] | [] | Auxiliary unsafe constant used by the Compiler when erasing proofs from code.
It may look strange to have an axiom that says "every proposition is true",
since this is obviously unsound, but the `unsafe` marker ensures that the
kernel will not let this through into regular proofs. The lower levels of the
code generato... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
lcCast {α : Sort u} {β : Sort v} (a : α) : β | axiom | lcCast | Init | src/Init/Prelude.lean | [] | [] | Auxiliary unsafe constant used by the Compiler when erasing casts. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
lcUnreachable {α : Sort u} : α | axiom | lcUnreachable | Init | src/Init/Prelude.lean | [] | [] | Auxiliary unsafe constant used by the Compiler to mark unreachable code.
Like `lcProof`, this is an `unsafe axiom`, which means that even though it is
not sound, the kernel will not let us use it for regular proofs.
Executing this expression to actually synthesize a value of type `α` causes
**immediate undefined beha... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
True : Prop where
/-- `True` is true, and `True.intro` (or more commonly, `trivial`)
is the proof. -/
| intro : True | inductive | True | Init | src/Init/Prelude.lean | [] | [] | `True` is a proposition and has only an introduction rule, `True.intro : True`.
In other words, `True` is simply true, and has a canonical proof, `True.intro`
For more information: [Propositional Logic](https://lean-lang.org/theorem_proving_in_lean4/propositions_and_proofs.html#propositional-logic) | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
False : Prop | inductive | False | Init | src/Init/Prelude.lean | [] | [] | `False` is the empty proposition. Thus, it has no introduction rules.
It represents a contradiction. `False` elimination rule, `False.rec`,
expresses the fact that anything follows from a contradiction.
This rule is sometimes called ex falso (short for ex falso sequitur quodlibet),
or the principle of explosion.
For mo... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Empty : Type | inductive | Empty | Init | src/Init/Prelude.lean | [] | [] | The empty type. It has no constructors.
Use `Empty.elim` in contexts where a value of type `Empty` is in scope. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
PEmpty : Sort u where | inductive | PEmpty | Init | src/Init/Prelude.lean | [] | [] | The universe-polymorphic empty type, with no constructors.
`PEmpty` can be used in any universe, but this flexibility can lead to worse error messages and more
challenges with universe level unification. Prefer the type `Empty` or the proposition `False` when
possible. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Not (a : Prop) : Prop | a → False | def | Not | Init | src/Init/Prelude.lean | [] | [
"False"
] | `Not p`, or `¬p`, is the negation of `p`. It is defined to be `p → False`,
so if your goal is `¬p` you can use `intro h` to turn the goal into
`h : p ⊢ False`, and if you have `hn : ¬p` and `h : p` then `hn h : False`
and `(hn h).elim` will prove anything.
For more information: [Propositional Logic](https://lean-lang.o... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
False.elim {C : Sort u} (h : False) : C | h.rec | def | False.elim | Init | src/Init/Prelude.lean | [] | [
"False"
] | `False.elim : False → C` says that from `False`, any desired proposition
`C` holds. Also known as ex falso quodlibet (EFQ) or the principle of explosion.
The target type is actually `C : Sort u` which means it works for both
propositions and types. When executed, this acts like an "unreachable"
instruction: it is **un... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
absurd {a : Prop} {b : Sort v} (h₁ : a) (h₂ : Not a) : b | (h₂ h₁).rec | def | absurd | Init | src/Init/Prelude.lean | [] | [
"Not"
] | Anything follows from two contradictory hypotheses. Example:
```
example (hp : p) (hnp : ¬p) : q := absurd hp hnp
```
For more information: [Propositional Logic](https://lean-lang.org/theorem_proving_in_lean4/propositions_and_proofs.html#propositional-logic) | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rfl {α : Sort u} {a : α} : Eq a a | Eq.refl a | def | rfl | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | `rfl : a = a` is the unique constructor of the equality type. This is the
same as `Eq.refl` except that it takes `a` implicitly instead of explicitly.
This is a more powerful theorem than it may appear at first, because although
the statement of the theorem is `a = a`, Lean will allow anything that is
definitionally e... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
id_eq (a : α) : Eq (id a) a | rfl | theorem | id_eq | Init | src/Init/Prelude.lean | [] | [
"Eq",
"id",
"rfl"
] | `id x = x`, as a `@[simp]` lemma. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Eq.subst {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a) : motive b | Eq.ndrec h₂ h₁ | theorem | Eq.subst | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | The substitution principle for equality. If `a = b ` and `P a` holds,
then `P b` also holds. We conventionally use the name `motive` for `P` here,
so that you can specify it explicitly using e.g.
`Eq.subst (motive := fun x => x < 5)` if it is not otherwise inferred correctly.
This theorem is the underlying mechanism b... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Eq.symm {α : Sort u} {a b : α} (h : Eq a b) : Eq b a | h ▸ rfl | theorem | Eq.symm | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Equality is symmetric: if `a = b` then `b = a`.
Because this is in the `Eq` namespace, if you have a variable `h : a = b`,
`h.symm` can be used as shorthand for `Eq.symm h` as a proof of `b = a`.
For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality) | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Eq.ndrec_symm.{u1, u2} {α : Sort u2} {a : α} {motive : α → Sort u1} (m : motive a) {b : α} (h : Eq b a) : motive b | h.symm.ndrec m | abbrev | Eq.ndrec_symm. | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | Non-dependent recursor for the equality type (symmetric variant) | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Eq.trans {α : Sort u} {a b c : α} (h₁ : Eq a b) (h₂ : Eq b c) : Eq a c | h₂ ▸ h₁ | theorem | Eq.trans | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | Equality is transitive: if `a = b` and `b = c` then `a = c`.
Because this is in the `Eq` namespace, if you have variables or expressions
`h₁ : a = b` and `h₂ : b = c`, you can use `h₁.trans h₂ : a = c` as shorthand
for `Eq.trans h₁ h₂`.
For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/q... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
cast {α β : Sort u} (h : Eq α β) (a : α) : β | h.rec a | def | cast | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | Cast across a type equality. If `h : α = β` is an equality of types, and
`a : α`, then `a : β` will usually not typecheck directly, but this function
will allow you to work around this and embed `a` in type `β` as `cast h a : β`.
It is best to avoid this function if you can, because it is more complicated
to reason ab... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
congrArg {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β) (h : Eq a₁ a₂) : Eq (f a₁) (f a₂) | h ▸ rfl | theorem | congrArg | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Congruence in the function argument: if `a₁ = a₂` then `f a₁ = f a₂` for
any (nondependent) function `f`. This is more powerful than it might look at first, because
you can also use a lambda expression for `f` to prove that
`<something containing a₁> = <something containing a₂>`. This function is used
internally by tac... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
congr {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α} (h₁ : Eq f₁ f₂) (h₂ : Eq a₁ a₂) : Eq (f₁ a₁) (f₂ a₂) | h₁ ▸ h₂ ▸ rfl | theorem | congr | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Congruence in both function and argument. If `f₁ = f₂` and `a₁ = a₂` then
`f₁ a₁ = f₂ a₂`. This only works for nondependent functions; the theorem
statement is more complex in the dependent case.
For more information: [Equality](https://lean-lang.org/theorem_proving_in_lean4/quantifiers_and_equality.html#equality) | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
congrFun {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : Eq f g) (a : α) : Eq (f a) (g a) | h ▸ rfl | theorem | congrFun | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Congruence in the function part of an application: If `f = g` then `f a = g a`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
congrFun' {α : Sort u} {β : Sort v} {f g : α → β} (h : Eq f g) (a : α) : Eq (f a) (g a) | h ▸ rfl
/-!
Initialize the Quotient Module, which effectively adds the following definitions:
```
opaque Quot {α : Sort u} (r : α → α → Prop) : Sort u
opaque Quot.mk {α : Sort u} (r : α → α → Prop) (a : α) : Quot r
opaque Quot.lift {α : Sort u} {r : α → α → Prop} {β : Sort v} (f : α → β) :
(∀ a b : α, r a b → Eq (... | theorem | congrFun' | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Similar to `congrFun` but `β` does not depend on `α`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Quot.lcInv {α : Sort u} {r : α → α → Prop} (q : Quot r) : α | axiom | Quot.lcInv | Init | src/Init/Prelude.lean | [] | [] | Unsafe auxiliary constant used by the compiler to erase `Quot.lift`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
HEq.rfl {α : Sort u} {a : α} : HEq a a | HEq.refl a | def | HEq.rfl | Init | src/Init/Prelude.lean | [] | [
"HEq"
] | A version of `HEq.refl` with an implicit argument. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
eq_of_heq {α : Sort u} {a a' : α} (h : HEq a a') : Eq a a' | have : (α β : Sort u) → (a : α) → (b : β) → HEq a b → (h : Eq α β) → Eq (cast h a) b :=
fun _ _ _ _ h₁ =>
h₁.rec (fun _ => rfl)
this α α a a' h rfl | theorem | eq_of_heq | Init | src/Init/Prelude.lean | [] | [
"Eq",
"HEq",
"cast",
"rfl"
] | If two heterogeneously equal terms have the same type, then they are propositionally equal. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
heq_of_eq (h : Eq a a') : HEq a a' | Eq.subst h (HEq.refl a) | theorem | heq_of_eq | Init | src/Init/Prelude.lean | [] | [
"Eq",
"Eq.subst",
"HEq"
] | Propositionally equal terms are also heterogeneously equal. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Prod (α : Type u) (β : Type v) where
/--
Constructs a pair. This is usually written `(x, y)` instead of `Prod.mk x y`.
-/
mk ::
/-- The first element of a pair. -/
fst : α
/-- The second element of a pair. -/
snd : β | structure | Prod | Init | src/Init/Prelude.lean | [] | [] | The product type, usually written `α × β`. Product types are also called pair or tuple types.
Elements of this type are pairs in which the first element is an `α` and the second element is a
`β`.
Products nest to the right, so `(x, y, z) : α × β × γ` is equivalent to `(x, (y, z)) : α × (β × γ)`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
PProd (α : Sort u) (β : Sort v) where
/-- The first element of a pair. -/
fst : α
/-- The second element of a pair. -/
snd : β | structure | PProd | Init | src/Init/Prelude.lean | [] | [] | A product type in which the types may be propositions, usually written `α ×' β`.
This type is primarily used internally and as an implementation detail of proof automation. It is
rarely useful in hand-written code. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
MProd (α β : Type u) where
/-- The first element of a pair. -/
fst : α
/-- The second element of a pair. -/
snd : β | structure | MProd | Init | src/Init/Prelude.lean | [] | [] | A product type in which both `α` and `β` are in the same universe.
It is called `MProd` is because it is the *universe-monomorphic* product type. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
And (a b : Prop) : Prop where
/-- `And.intro : a → b → a ∧ b` is the constructor for the And operation. -/
intro ::
/-- Extract the left conjunct from a conjunction. `h : a ∧ b` then
`h.left`, also notated as `h.1`, is a proof of `a`. -/
left : a
/-- Extract the right conjunct from a conjunction. `h : a ∧ b... | structure | And | Init | src/Init/Prelude.lean | [] | [] | `And a b`, or `a ∧ b`, is the conjunction of propositions. It can be
constructed and destructed like a pair: if `ha : a` and `hb : b` then
`⟨ha, hb⟩ : a ∧ b`, and if `h : a ∧ b` then `h.left : a` and `h.right : b`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Or (a b : Prop) : Prop where
/-- `Or.inl` is "left injection" into an `Or`. If `h : a` then `Or.inl h : a ∨ b`. -/
| inl (h : a) : Or a b
/-- `Or.inr` is "right injection" into an `Or`. If `h : b` then `Or.inr h : a ∨ b`. -/
| inr (h : b) : Or a b | inductive | Or | Init | src/Init/Prelude.lean | [] | [] | `Or a b`, or `a ∨ b`, is the disjunction of propositions. There are two
constructors for `Or`, called `Or.inl : a → a ∨ b` and `Or.inr : b → a ∨ b`,
and you can use `match` or `cases` to destruct an `Or` assumption into the
two cases. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Or.intro_left (b : Prop) (h : a) : Or a b | Or.inl h | theorem | Or.intro_left | Init | src/Init/Prelude.lean | [] | [
"Or"
] | Alias for `Or.inl`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Or.intro_right (a : Prop) (h : b) : Or a b | Or.inr h | theorem | Or.intro_right | Init | src/Init/Prelude.lean | [] | [
"Or"
] | Alias for `Or.inr`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Or.elim {c : Prop} (h : Or a b) (left : a → c) (right : b → c) : c | match h with
| Or.inl h => left h
| Or.inr h => right h | theorem | Or.elim | Init | src/Init/Prelude.lean | [] | [
"Or"
] | Proof by cases on an `Or`. If `a ∨ b`, and both `a` and `b` imply
proposition `c`, then `c` is true. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Or.resolve_left (h: Or a b) (na : Not a) : b | h.elim (absurd · na) id | theorem | Or.resolve_left | Init | src/Init/Prelude.lean | [] | [
"Not",
"Or",
"absurd",
"id"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Or.resolve_right (h: Or a b) (nb : Not b) : a | h.elim id (absurd · nb) | theorem | Or.resolve_right | Init | src/Init/Prelude.lean | [] | [
"Not",
"Or",
"absurd",
"id"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Or.neg_resolve_left (h : Or (Not a) b) (ha : a) : b | h.elim (absurd ha) id | theorem | Or.neg_resolve_left | Init | src/Init/Prelude.lean | [] | [
"Not",
"Or",
"absurd",
"id"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Or.neg_resolve_right (h : Or a (Not b)) (nb : b) : a | h.elim id (absurd nb) | theorem | Or.neg_resolve_right | Init | src/Init/Prelude.lean | [] | [
"Not",
"Or",
"absurd",
"id"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Subtype {α : Sort u} (p : α → Prop) where
/--
The value in the underlying type that satisfies the predicate.
-/
val : α
/--
The proof that `val` satisfies the predicate `p`.
-/
property : p val
grind_pattern Subtype.property => self.val | structure | Subtype | Init | src/Init/Prelude.lean | [] | [] | All the elements of a type that satisfy a predicate.
`Subtype p`, usually written `{ x : α // p x }` or `{ x // p x }`, contains all elements `x : α` for
which `p x` is true. Its constructor is a pair of the value and the proof that it satisfies the
predicate. In run-time code, `{ x : α // p x }` is represented identi... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
optParam (α : Sort u) (default : α) : Sort u | α | def | optParam | Init | src/Init/Prelude.lean | [] | [] | Gadget for optional parameter support.
A binder like `(x : α := default)` in a declaration is syntax sugar for
`x : optParam α default`, and triggers the elaborator to attempt to use
`default` to supply the argument if it is not supplied. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
outParam (α : Sort u) : Sort u | α | def | outParam | Init | src/Init/Prelude.lean | [] | [] | Gadget for marking output parameters in type classes.
For example, the `Membership` class is defined as:
```
class Membership (α : outParam (Type u)) (γ : Type v)
```
This means that whenever a typeclass goal of the form `Membership ?α ?γ` comes
up, Lean will wait to solve it until `?γ` is known, but then it will run
... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
semiOutParam (α : Sort u) : Sort u | α | def | semiOutParam | Init | src/Init/Prelude.lean | [] | [] | Gadget for marking semi output parameters in type classes.
Semi-output parameters influence the order in which arguments to type class
instances are processed. Lean determines an order where all non-(semi-)output
parameters to the instance argument have to be figured out before attempting to
synthesize an argument (t... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
namedPattern {α : Sort u} (x a : α) (h : Eq x a) : α | a | def | namedPattern | Init | src/Init/Prelude.lean | [] | [
"Eq"
] | Auxiliary declaration used to implement named patterns like `x@h:p`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
sorryAx (α : Sort u) (synthetic : Bool) : α | axiom | sorryAx | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | Auxiliary axiom used to implement the `sorry` term and tactic.
The `sorry` term/tactic expands to `sorryAx _ (synthetic := false)`.
It is intended for stubbing-out incomplete parts of a value or proof while still having a syntactically correct skeleton.
Lean will give a warning whenever a declaration uses `sorry`, so ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
eq_false_of_ne_true : {b : Bool} → Not (Eq b true) → Eq b false | | true, h => False.elim (h rfl)
| false, _ => rfl | theorem | eq_false_of_ne_true | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Eq",
"False.elim",
"Not",
"rfl"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
eq_true_of_ne_false : {b : Bool} → Not (Eq b false) → Eq b true | | true, _ => rfl
| false, h => False.elim (h rfl) | theorem | eq_true_of_ne_false | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Eq",
"False.elim",
"Not",
"rfl"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
ne_false_of_eq_true : {b : Bool} → Eq b true → Not (Eq b false) | | true, _ => fun h => Bool.noConfusion h
| false, h => Bool.noConfusion h | theorem | ne_false_of_eq_true | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Eq",
"Not"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
ne_true_of_eq_false : {b : Bool} → Eq b false → Not (Eq b true) | | true, h => Bool.noConfusion h
| false, _ => fun h => Bool.noConfusion h | theorem | ne_true_of_eq_false | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Eq",
"Not"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Inhabited (α : Sort u) where
/-- `default` is a function that produces a "default" element of any
`Inhabited` type. This element does not have any particular specified
properties, but it is often an all-zeroes value. -/
default : α | class | Inhabited | Init | src/Init/Prelude.lean | [] | [] | `Inhabited α` is a typeclass that says that `α` has a designated element,
called `(default : α)`. This is sometimes referred to as a "pointed type".
This class is used by functions that need to return a value of the type
when called "out of domain". For example, `Array.get! arr i : α` returns
a value of type `α` when ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Nonempty (α : Sort u) : Prop where
/-- If `val : α`, then `α` is nonempty. -/
| intro (val : α) : Nonempty α | class inductive | Nonempty | Init | src/Init/Prelude.lean | [] | [] | `Nonempty α` is a typeclass that says that `α` is not an empty type,
that is, there exists an element in the type. It differs from `Inhabited α`
in that `Nonempty α` is a `Prop`, which means that it does not actually carry
an element of `α`, only a proof that *there exists* such an element.
Given `Nonempty α`, you can ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Classical.choice {α : Sort u} : Nonempty α → α | axiom | Classical.choice | Init | src/Init/Prelude.lean | [] | [
"Nonempty"
] | **The axiom of choice**. `Nonempty α` is a proof that `α` has an element,
but the element itself is erased. The axiom `choice` supplies a particular
element of `α` given only this proof.
The textbook axiom of choice normally makes a family of choices all at once,
but that is implied from this formulation, because if `... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Nonempty.elim {α : Sort u} {p : Prop} (h₁ : Nonempty α) (h₂ : α → p) : p | match h₁ with
| intro a => h₂ a | theorem | Nonempty.elim | Init | src/Init/Prelude.lean | [] | [
"Nonempty"
] | The elimination principle for `Nonempty α`. If `Nonempty α`, and we can
prove `p` given any element `x : α`, then `p` holds. Note that it is essential
that `p` is a `Prop` here; the version with `p` being a `Sort u` is equivalent
to `Classical.choice`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Classical.ofNonempty {α : Sort u} [Nonempty α] : α | Classical.choice inferInstance | def | Classical.ofNonempty | Init | src/Init/Prelude.lean | [] | [
"Classical.choice",
"Nonempty",
"inferInstance"
] | A variation on `Classical.choice` that uses typeclass inference to
infer the proof of `Nonempty α`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Pi.instNonempty {α : Sort u} {β : α → Sort v} [(a : α) → Nonempty (β a)] :
Nonempty ((a : α) → β a) | Nonempty.intro fun _ => Classical.ofNonempty | instance | Pi.instNonempty | Init | src/Init/Prelude.lean | [] | [
"Classical.ofNonempty",
"Nonempty"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Pi.instInhabited {α : Sort u} {β : α → Sort v} [(a : α) → Inhabited (β a)] :
Inhabited ((a : α) → β a) | where
default := fun _ => default
deriving instance Inhabited for Bool | instance | Pi.instInhabited | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Inhabited"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
PLift (α : Sort u) : Type u where
/-- Wraps a proof or value to increase its type's universe level by 1. -/
up ::
/-- Extracts a wrapped proof or value from a universe-lifted proposition or type. -/
down : α | structure | PLift | Init | src/Init/Prelude.lean | [] | [] | Lifts a proposition or type to a higher universe level.
`PLift α` wraps a proof or value of type `α`. The resulting type is in the next largest universe
after that of `α`. In particular, propositions become data.
The related type `ULift` can be used to lift a non-proposition type by any number of levels.
Examples:
... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
PLift.up_down {α : Sort u} (b : PLift α) : Eq (up (down b)) b | rfl | theorem | PLift.up_down | Init | src/Init/Prelude.lean | [] | [
"Eq",
"PLift",
"rfl"
] | Bijection between `α` and `PLift α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
PLift.down_up {α : Sort u} (a : α) : Eq (down (up a)) a | rfl | theorem | PLift.down_up | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Bijection between `α` and `PLift α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
NonemptyType | Subtype fun α : Type u => Nonempty α | def | NonemptyType | Init | src/Init/Prelude.lean | [] | [
"Nonempty",
"Subtype"
] | `NonemptyType.{u}` is the type of nonempty types in universe `u`.
It is mainly used in constant declarations where we wish to introduce a type
and simultaneously assert that it is nonempty, but otherwise make the type
opaque. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
NonemptyType.type (type : NonemptyType.{u}) : Type u | type.val | abbrev | NonemptyType.type | Init | src/Init/Prelude.lean | [] | [] | The underlying type of a `NonemptyType`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ULift.{r, s} (α : Type s) : Type (max s r) where
/-- Wraps a value to increase its type's universe level. -/
up ::
/-- Extracts a wrapped value from a universe-lifted type. -/
down : α | structure | ULift. | Init | src/Init/Prelude.lean | [] | [] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | ||
ULift.up_down {α : Type u} (b : ULift.{v} α) : Eq (up (down b)) b | rfl | theorem | ULift.up_down | Init | src/Init/Prelude.lean | [] | [
"Eq",
"ULift.",
"rfl"
] | Bijection between `α` and `ULift.{v} α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ULift.down_up {α : Type u} (a : α) : Eq (down (up.{v} a)) a | rfl | theorem | ULift.down_up | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Bijection between `α` and `ULift.{v} α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
PULift.{r, s} (α : Sort s) : Sort (max s r 1) where
/-- Wraps a value to increase its type's universe level. -/
up ::
/-- Extracts a wrapped value from a universe-lifted type. -/
down : α | structure | PULift. | Init | src/Init/Prelude.lean | [] | [] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | ||
PULift.up_down {α : Sort u} (b : PULift.{v} α) : Eq (up (down b)) b | rfl | theorem | PULift.up_down | Init | src/Init/Prelude.lean | [] | [
"Eq",
"PULift.",
"rfl"
] | Bijection between `α` and `PULift.{v} α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
PULift.down_up {α : Sort u} (a : α) : Eq (down (up.{v} a)) a | rfl | theorem | PULift.down_up | Init | src/Init/Prelude.lean | [] | [
"Eq",
"rfl"
] | Bijection between `α` and `PULift.{v} α` | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Decidable (p : Prop) where
/-- Proves that `p` is decidable by supplying a proof of `¬p` -/
| isFalse (h : Not p) : Decidable p
/-- Proves that `p` is decidable by supplying a proof of `p` -/
| isTrue (h : p) : Decidable p | class inductive | Decidable | Init | src/Init/Prelude.lean | [] | [
"Not"
] | Either a proof that `p` is true or a proof that `p` is false. This is equivalent to a `Bool` paired
with a proof that the `Bool` is `true` if and only if `p` is true.
`Decidable` instances are primarily used via `if`-expressions and the tactic `decide`. In
conditional expressions, the `Decidable` instance for the prop... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Decidable.decide (p : Prop) [h : Decidable p] : Bool | h.casesOn (fun _ => false) (fun _ => true) | def | Decidable.decide | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Decidable"
] | Converts a decidable proposition into a `Bool`.
If `p : Prop` is decidable, then `decide p : Bool` is the Boolean value
that is `true` if `p` is true and `false` if `p` is false. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
DecidablePred {α : Sort u} (r : α → Prop) | (a : α) → Decidable (r a) | abbrev | DecidablePred | Init | src/Init/Prelude.lean | [] | [
"Decidable"
] | A decidable predicate.
A predicate is decidable if the corresponding proposition is `Decidable` for each possible argument. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
DecidableRel {α : Sort u} {β : Sort v} (r : α → β → Prop) | (a : α) → (b : β) → Decidable (r a b) | abbrev | DecidableRel | Init | src/Init/Prelude.lean | [] | [
"Decidable"
] | A decidable relation.
A relation is decidable if the corresponding proposition is `Decidable` for all possible arguments. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
DecidableEq (α : Sort u) | (a b : α) → Decidable (Eq a b) | abbrev | DecidableEq | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Eq"
] | Propositional equality is `Decidable` for all elements of a type.
In other words, an instance of `DecidableEq α` is a means of deciding the proposition `a = b` is
for all `a b : α`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
decEq {α : Sort u} [inst : DecidableEq α] (a b : α) : Decidable (Eq a b) | inst a b | def | decEq | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"DecidableEq",
"Eq"
] | Checks whether two terms of a type are equal using the type's `DecidableEq` instance. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
decide_eq_true : [inst : Decidable p] → p → Eq (decide p) true | | isTrue _, _ => rfl
| isFalse h₁, h₂ => absurd h₂ h₁ | theorem | decide_eq_true | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Eq",
"absurd",
"rfl"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
decide_eq_false : [Decidable p] → Not p → Eq (decide p) false | | isTrue h₁, h₂ => absurd h₁ h₂
| isFalse _, _ => rfl | theorem | decide_eq_false | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Eq",
"Not",
"absurd",
"rfl"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
of_decide_eq_true [inst : Decidable p] : Eq (decide p) true → p | fun h =>
match (generalizing := false) inst with
| isTrue h₁ => h₁
| isFalse h₁ => absurd h (ne_true_of_eq_false (decide_eq_false h₁)) | theorem | of_decide_eq_true | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Eq",
"absurd",
"decide_eq_false",
"ne_true_of_eq_false"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
of_decide_eq_false [inst : Decidable p] : Eq (decide p) false → Not p | fun h =>
match (generalizing := false) inst with
| isTrue h₁ => absurd h (ne_false_of_eq_true (decide_eq_true h₁))
| isFalse h₁ => h₁ | theorem | of_decide_eq_false | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Eq",
"Not",
"absurd",
"decide_eq_true",
"ne_false_of_eq_true"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
of_decide_eq_self_eq_true [inst : DecidableEq α] (a : α) : Eq (decide (Eq a a)) true | match (generalizing := false) inst a a with
| isTrue _ => rfl
| isFalse h₁ => absurd rfl h₁ | theorem | of_decide_eq_self_eq_true | Init | src/Init/Prelude.lean | [] | [
"DecidableEq",
"Eq",
"absurd",
"rfl"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Bool.decEq (a b : Bool) : Decidable (Eq a b) | match a, b with
| false, false => isTrue rfl
| false, true => isFalse (fun h => Bool.noConfusion h)
| true, false => isFalse (fun h => Bool.noConfusion h)
| true, true => isTrue rfl | def | Bool.decEq | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Decidable",
"Eq",
"rfl"
] | Decides whether two Booleans are equal.
This function should normally be called via the `DecidableEq Bool` instance that it exists to
support. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
BEq (α : Type u) where
/-- Boolean equality, notated as `a == b`. -/
beq : α → α → Bool | class | BEq | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | `BEq α` is a typeclass for supplying a boolean-valued equality relation on
`α`, notated as `a == b`. Unlike `DecidableEq α` (which uses `a = b`), this
is `Bool` valued instead of `Prop` valued, and it also does not have any
axioms like being reflexive or agreeing with `=`. It is mainly intended for
programming applicat... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
dite {α : Sort u} (c : Prop) [h : Decidable c] (t : c → α) (e : Not c → α) : α | h.casesOn e t | def | dite | Init | src/Init/Prelude.lean | [] | [
"Decidable",
"Not"
] | "Dependent" if-then-else, normally written via the notation `if h : c then t(h) else e(h)`,
is sugar for `dite c (fun h => t(h)) (fun h => e(h))`, and it is the same as
`if c then t else e` except that `t` is allowed to depend on a proof `h : c`,
and `e` can depend on `h : ¬c`. (Both branches use the same name for the ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ite {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α | h.casesOn (fun _ => e) (fun _ => t) | def | ite | Init | src/Init/Prelude.lean | [] | [
"Decidable"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
cond {α : Sort u} (c : Bool) (x y : α) : α | match c with
| true => x
| false => y | def | cond | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | The conditional function.
`cond c x y` is the same as `if c then x else y`, but optimized for a Boolean condition rather than
a decidable proposition. It can also be written using the notation `bif c then x else y`.
Just like `ite`, `cond` is declared `@[macro_inline]`, which causes applications of `cond` to be
unfol... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Bool.dcond {α : Sort u} (c : Bool) (x : Eq c true → α) (y : Eq c false → α) : α | match c with
| true => x rfl
| false => y rfl | def | Bool.dcond | Init | src/Init/Prelude.lean | [] | [
"Bool",
"Eq",
"rfl"
] | The dependent conditional function, in which each branch is provided with a local assumption about
the condition's value. This allows the value to be used in proofs as well as for control flow.
`dcond c (fun h => x) (fun h => y)` is the same as `if h : c then x else y`, but optimized for a
Boolean condition rather tha... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Bool.or (x y : Bool) : Bool | match x with
| true => true
| false => y | def | Bool.or | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | Boolean “or”, also known as disjunction. `or x y` can be written `x || y`.
The corresponding propositional connective is `Or : Prop → Prop → Prop`, written with the `∨`
operator.
The Boolean `or` is a `@[macro_inline]` function in order to give it short-circuiting evaluation:
if `x` is `true` then `y` is not evaluate... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Bool.and (x y : Bool) : Bool | match x with
| false => false
| true => y | def | Bool.and | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | Boolean “and”, also known as conjunction. `and x y` can be written `x && y`.
The corresponding propositional connective is `And : Prop → Prop → Prop`, written with the `∧`
operator.
The Boolean `and` is a `@[macro_inline]` function in order to give it short-circuiting evaluation:
if `x` is `false` then `y` is not eva... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Bool.not : Bool → Bool | | true => false
| false => true | def | Bool.not | Init | src/Init/Prelude.lean | [] | [
"Bool"
] | Boolean negation, also known as Boolean complement. `not x` can be written `!x`.
This is a function that maps the value `true` to `false` and the value `false` to `true`. The
propositional connective is `Not : Prop → Prop`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Nat where
/--
Zero, the smallest natural number.
Using `Nat.zero` explicitly should usually be avoided in favor of the literal `0`, which is the
[simp normal form](lean-manual://section/simp-normal-forms).
-/
| zero : Nat
/--
The successor of a natural number `n`.
Using `Nat.succ n` should usually b... | inductive | Nat | Init | src/Init/Prelude.lean | [] | [] | The natural numbers, starting at zero.
This type is special-cased by both the kernel and the compiler, and overridden with an efficient
implementation. Both use a fast arbitrary-precision arithmetic library (usually
[GMP](https://gmplib.org/)); at runtime, `Nat` values that are sufficiently small are unboxed. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
OfNat (α : Type u) (_ : Nat) where
/-- The `OfNat.ofNat` function is automatically inserted by the parser when
the user writes a numeric literal like `1 : α`. Implementations of this
typeclass can therefore customize the behavior of `n : α` based on `n` and
`α`. -/
ofNat : α | class | OfNat | Init | src/Init/Prelude.lean | [] | [
"Nat"
] | The class `OfNat α n` powers the numeric literal parser. If you write
`37 : α`, Lean will attempt to synthesize `OfNat α 37`, and will generate
the term `(OfNat.ofNat 37 : α)`.
There is a bit of infinite regress here since the desugaring apparently
still contains a literal `37` in it. The type of expressions contains ... | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
instOfNatNat (n : Nat) : OfNat Nat n | where
ofNat := n | instance | instOfNatNat | Init | src/Init/Prelude.lean | [] | [
"Nat",
"OfNat"
] | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LE (α : Type u) where
/-- The less-equal relation: `x ≤ y` -/
le : α → α → Prop | class | LE | Init | src/Init/Prelude.lean | [] | [] | `LE α` is the typeclass which supports the notation `x ≤ y` where `x y : α`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LT (α : Type u) where
/-- The less-than relation: `x < y` -/
lt : α → α → Prop | class | LT | Init | src/Init/Prelude.lean | [] | [] | `LT α` is the typeclass which supports the notation `x < y` where `x y : α`. | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.