fact stringlengths 10 19.8k | statement stringlengths 1 9.7k | proof stringlengths 0 19.6k | type stringclasses 14
values | symbolic_name stringlengths 0 110 | library stringclasses 165
values | filename stringclasses 857
values | imports listlengths 0 19 | deps listlengths 0 64 | docstring stringlengths 10 3.64k ⌀ | line_start int64 13 10.9k | line_end int64 15 10.9k | has_proof bool 2
classes | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
imp_iff_right {a : Prop} (ha : a) : (a → b) ↔ b := Iff.intro (· ha) (fun a _ => a) | imp_iff_right {a : Prop} (ha : a) : (a → b) ↔ b | Iff.intro (· ha) (fun a _ => a) | theorem | imp_iff_right | Init | src/Init/Core.lean | [] | [] | null | 1,740 | 1,740 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_true_iff (α : Sort u) : (α → True) ↔ True := iff_true_intro (fun _ => trivial) | imp_true_iff (α : Sort u) : (α → True) ↔ True | iff_true_intro (fun _ => trivial) | theorem | imp_true_iff | Init | src/Init/Core.lean | [] | [
"True",
"iff_true_intro",
"trivial"
] | null | 1,743 | 1,743 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
false_imp_iff (a : Prop) : (False → a) ↔ True := iff_true_intro False.elim | false_imp_iff (a : Prop) : (False → a) ↔ True | iff_true_intro False.elim | theorem | false_imp_iff | Init | src/Init/Core.lean | [] | [
"False",
"False.elim",
"True",
"iff_true_intro"
] | null | 1,745 | 1,745 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
true_imp_iff {α : Prop} : (True → α) ↔ α := imp_iff_right True.intro | true_imp_iff {α : Prop} : (True → α) ↔ α | imp_iff_right True.intro | theorem | true_imp_iff | Init | src/Init/Core.lean | [] | [
"True",
"imp_iff_right"
] | null | 1,747 | 1,747 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_self : (a → a) ↔ True := iff_true_intro id | imp_self : (a → a) ↔ True | iff_true_intro id | theorem | imp_self | Init | src/Init/Core.lean | [] | [
"True",
"id",
"iff_true_intro"
] | null | 1,749 | 1,749 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_false : (a → False) ↔ ¬a := Iff.rfl | imp_false : (a → False) ↔ ¬a | Iff.rfl | theorem | imp_false | Init | src/Init/Core.lean | [] | [
"False",
"Iff.rfl"
] | null | 1,751 | 1,751 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp.swap : (a → b → c) ↔ (b → a → c) := Iff.intro flip flip | imp.swap : (a → b → c) ↔ (b → a → c) | Iff.intro flip flip | theorem | imp.swap | Init | src/Init/Core.lean | [] | [
"flip"
] | null | 1,753 | 1,753 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_not_comm : (a → ¬b) ↔ (b → ¬a) := imp.swap | imp_not_comm : (a → ¬b) ↔ (b → ¬a) | imp.swap | theorem | imp_not_comm | Init | src/Init/Core.lean | [] | [
"imp.swap"
] | null | 1,755 | 1,755 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c) := Iff.intro (· ∘ h.mpr) (· ∘ h.mp) | imp_congr_left (h : a ↔ b) : (a → c) ↔ (b → c) | Iff.intro (· ∘ h.mpr) (· ∘ h.mp) | theorem | imp_congr_left | Init | src/Init/Core.lean | [] | [] | null | 1,757 | 1,757 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c) :=
Iff.intro (fun hab ha => (h ha).mp (hab ha)) (fun hcd ha => (h ha).mpr (hcd ha)) | imp_congr_right (h : a → (b ↔ c)) : (a → b) ↔ (a → c) | Iff.intro (fun hab ha => (h ha).mp (hab ha)) (fun hcd ha => (h ha).mpr (hcd ha)) | theorem | imp_congr_right | Init | src/Init/Core.lean | [] | [] | null | 1,759 | 1,760 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_congr_ctx (h₁ : a ↔ c) (h₂ : c → (b ↔ d)) : (a → b) ↔ (c → d) :=
Iff.trans (imp_congr_left h₁) (imp_congr_right h₂) | imp_congr_ctx (h₁ : a ↔ c) (h₂ : c → (b ↔ d)) : (a → b) ↔ (c → d) | Iff.trans (imp_congr_left h₁) (imp_congr_right h₂) | theorem | imp_congr_ctx | Init | src/Init/Core.lean | [] | [
"Iff.trans",
"imp_congr_left",
"imp_congr_right"
] | null | 1,762 | 1,763 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_congr (h₁ : a ↔ c) (h₂ : b ↔ d) : (a → b) ↔ (c → d) := imp_congr_ctx h₁ fun _ => h₂ | imp_congr (h₁ : a ↔ c) (h₂ : b ↔ d) : (a → b) ↔ (c → d) | imp_congr_ctx h₁ fun _ => h₂ | theorem | imp_congr | Init | src/Init/Core.lean | [] | [
"imp_congr_ctx"
] | null | 1,765 | 1,765 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
imp_iff_not (hb : ¬b) : a → b ↔ ¬a := imp_congr_right fun _ => iff_false_intro hb | imp_iff_not (hb : ¬b) : a → b ↔ ¬a | imp_congr_right fun _ => iff_false_intro hb | theorem | imp_iff_not | Init | src/Init/Core.lean | [] | [
"iff_false_intro",
"imp_congr_right"
] | null | 1,767 | 1,767 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
sound : ∀ {α : Sort u} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b | sound : ∀ {α : Sort u} {r : α → α → Prop} {a b : α}, r a b → Quot.mk r a = Quot.mk r b | axiom | Quot.sound | Init | src/Init/Core.lean | [] | [] | The **quotient axiom**, which asserts the equality of elements related by the quotient's relation.
The relation `r` does not need to be an equivalence relation to use this axiom. When `r` is not an
equivalence relation, the quotient is with respect to the equivalence relation generated by `r`.
`Quot.sound` is part of... | 1,789 | 1,789 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
liftBeta {α : Sort u} {r : α → α → Prop} {β : Sort v}
(f : α → β)
(c : (a b : α) → r a b → f a = f b)
(a : α)
: lift f c (Quot.mk r a) = f a :=
rfl | liftBeta {α : Sort u} {r : α → α → Prop} {β : Sort v}
(f : α → β)
(c : (a b : α) → r a b → f a = f b)
(a : α)
: lift f c (Quot.mk r a) = f a | rfl | theorem | Quot.liftBeta | Init | src/Init/Core.lean | [] | [
"rfl"
] | null | 1,791 | 1,796 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
indBeta {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
(p : (a : α) → motive (Quot.mk r a))
(a : α)
: (ind p (Quot.mk r a) : motive (Quot.mk r a)) = p a :=
rfl | indBeta {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
(p : (a : α) → motive (Quot.mk r a))
(a : α)
: (ind p (Quot.mk r a) : motive (Quot.mk r a)) = p a | rfl | theorem | Quot.indBeta | Init | src/Init/Core.lean | [] | [
"rfl"
] | null | 1,798 | 1,802 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
liftOn {α : Sort u} {β : Sort v} {r : α → α → Prop}
(q : Quot r) (f : α → β) (c : (a b : α) → r a b → f a = f b) : β :=
lift f c q | liftOn {α : Sort u} {β : Sort v} {r : α → α → Prop}
(q : Quot r) (f : α → β) (c : (a b : α) → r a b → f a = f b) : β | lift f c q | abbrev | Quot.liftOn | Init | src/Init/Core.lean | [] | [] | Lifts a function from an underlying type to a function on a quotient, requiring that it respects the
quotient's relation.
Given a relation `r : α → α → Prop` and a quotient's value `q : Quot r`, applying a `f : α → β`
requires a proof `c` that `f` respects `r`. In this case, `Quot.liftOn q f h : β` evaluates
to the re... | 1,817 | 1,819 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
inductionOn {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
(q : Quot r)
(h : (a : α) → motive (Quot.mk r a))
: motive q :=
ind h q | inductionOn {α : Sort u} {r : α → α → Prop} {motive : Quot r → Prop}
(q : Quot r)
(h : (a : α) → motive (Quot.mk r a))
: motive q | ind h q | theorem | Quot.inductionOn | Init | src/Init/Core.lean | [] | [] | null | 1,821 | 1,826 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
exists_rep {α : Sort u} {r : α → α → Prop} (q : Quot r) : Exists (fun a => (Quot.mk r a) = q) :=
q.inductionOn (fun a => ⟨a, rfl⟩) | exists_rep {α : Sort u} {r : α → α → Prop} (q : Quot r) : Exists (fun a => (Quot.mk r a) = q) | q.inductionOn (fun a => ⟨a, rfl⟩) | theorem | Quot.exists_rep | Init | src/Init/Core.lean | [] | [
"Exists"
] | null | 1,828 | 1,829 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
indep (f : (a : α) → motive (Quot.mk r a)) (a : α) : PSigma motive :=
⟨Quot.mk r a, f a⟩ | indep (f : (a : α) → motive (Quot.mk r a)) (a : α) : PSigma motive | ⟨Quot.mk r a, f a⟩ | def | Quot.indep | Init | src/Init/Core.lean | [] | [
"PSigma"
] | Auxiliary definition for `Quot.rec`. | 1,837 | 1,839 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
indepCoherent
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
: (a b : α) → r a b → Quot.indep f a = Quot.indep f b :=
fun a b e => PSigma.eta (sound e) (h a b e) | indepCoherent
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
: (a b : α) → r a b → Quot.indep f a = Quot.indep f b | fun a b e => PSigma.eta (sound e) (h a b e) | theorem | Quot.indepCoherent | Init | src/Init/Core.lean | [] | [
"PSigma.eta",
"Quot.indep"
] | null | 1,841 | 1,845 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
liftIndepPr1
(f : (a : α) → motive (Quot.mk r a))
(h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) (sound p) = f b)
(q : Quot r)
: (lift (Quot.indep f) (Quot.indepCoherent f h) q).1 = q := by
induction q using Quot.ind
exact rfl | liftIndepPr1
(f : (a : α) → motive (Quot.mk r a))
(h : ∀ (a b : α) (p : r a b), Eq.ndrec (f a) (sound p) = f b)
(q : Quot r)
: (lift (Quot.indep f) (Quot.indepCoherent f h) q).1 = q | by
induction q using Quot.ind
exact rfl | theorem | Quot.liftIndepPr1 | Init | src/Init/Core.lean | [] | [
"Quot.indep",
"Quot.indepCoherent",
"rfl"
] | null | 1,847 | 1,853 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rec
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
(q : Quot r) : motive q :=
Eq.ndrecOn (Quot.liftIndepPr1 f h q) ((lift (Quot.indep f) (Quot.indepCoherent f h) q).2) | rec
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
(q : Quot r) : motive q | Eq.ndrecOn (Quot.liftIndepPr1 f h q) ((lift (Quot.indep f) (Quot.indepCoherent f h) q).2) | abbrev | Quot.rec | Init | src/Init/Core.lean | [] | [
"Quot.indep",
"Quot.indepCoherent",
"Quot.liftIndepPr1"
] | A dependent recursion principle for `Quot`. It is analogous to the
[recursor](lean-manual://section/recursors) for a structure, and can be used when the resulting type
is not necessarily a proposition.
While it is very general, this recursor can be tricky to use. The following simpler alternatives may
be easier to use... | 1,870 | 1,874 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
recOn
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
: motive q :=
q.rec f h | recOn
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
(h : (a b : α) → (p : r a b) → Eq.ndrec (f a) (sound p) = f b)
: motive q | q.rec f h | abbrev | Quot.recOn | Init | src/Init/Core.lean | [] | [] | A dependent recursion principle for `Quot` that takes the quotient first. It is analogous to the
[recursor](lean-manual://section/recursors) for a structure, and can be used when the resulting type
is not necessarily a proposition.
While it is very general, this recursor can be tricky to use. The following simpler alt... | 1,891 | 1,896 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
recOnSubsingleton
[h : (a : α) → Subsingleton (motive (Quot.mk r a))]
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
: motive q := by
induction q using Quot.rec
apply f
apply Subsingleton.elim | recOnSubsingleton
[h : (a : α) → Subsingleton (motive (Quot.mk r a))]
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
: motive q | by
induction q using Quot.rec
apply f
apply Subsingleton.elim | abbrev | Quot.recOnSubsingleton | Init | src/Init/Core.lean | [] | [
"Quot.rec",
"Subsingleton",
"Subsingleton.elim"
] | An alternative induction principle for quotients that can be used when the target type is a
subsingleton, in which all elements are equal.
In these cases, the proof that the function respects the quotient's relation is trivial, so any
function can be lifted.
`Quot.rec` does not assume that the type is a subsingleton. | 1,907 | 1,914 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
hrecOn
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
(c : (a b : α) → (p : r a b) → f a ≍ f b)
: motive q :=
Quot.recOn q f fun a b p => eq_of_heq (eqRec_heq_iff.mpr (c a b p)) | hrecOn
(q : Quot r)
(f : (a : α) → motive (Quot.mk r a))
(c : (a b : α) → (p : r a b) → f a ≍ f b)
: motive q | Quot.recOn q f fun a b p => eq_of_heq (eqRec_heq_iff.mpr (c a b p)) | abbrev | Quot.hrecOn | Init | src/Init/Core.lean | [] | [
"Quot.recOn",
"eq_of_heq"
] | A dependent recursion principle for `Quot` that uses [heterogeneous
equality](lean-manual://section/HEq), analogous to a [recursor](lean-manual://section/recursors) for
a structure.
`Quot.recOn` is a version of this recursor that uses `Eq` instead of `HEq`. | 1,923 | 1,928 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Quotient {α : Sort u} (s : Setoid α) :=
@Quot α Setoid.r | Quotient {α : Sort u} (s : Setoid α) | @Quot α Setoid.r | def | Quotient | Init | src/Init/Core.lean | [] | [
"Setoid"
] | Quotient types coarsen the propositional equality for a type so that terms related by some
equivalence relation are considered equal. The equivalence relation is given by an instance of
`Setoid`.
Set-theoretically, `Quotient s` can seen as the set of equivalence classes of `α` modulo the
`Setoid` instance's relation `... | 1,955 | 1,956 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
mk {α : Sort u} (s : Setoid α) (a : α) : Quotient s :=
Quot.mk Setoid.r a | mk {α : Sort u} (s : Setoid α) (a : α) : Quotient s | Quot.mk Setoid.r a | def | Quotient.mk | Init | src/Init/Core.lean | [] | [
"Quotient",
"Setoid"
] | Places an element of a type into the quotient that equates terms according to an equivalence
relation.
The setoid instance is provided explicitly. `Quotient.mk'` uses instance synthesis instead.
Given `v : α`, `Quotient.mk s v : Quotient s` is like `v`, except all observations of `v`'s value
must respect `s.r`. `Quot... | 1,970 | 1,972 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
mk' {α : Sort u} [s : Setoid α] (a : α) : Quotient s :=
Quotient.mk s a | mk' {α : Sort u} [s : Setoid α] (a : α) : Quotient s | Quotient.mk s a | def | Quotient.mk' | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.mk",
"Setoid"
] | Places an element of a type into the quotient that equates terms according to an equivalence
relation.
The equivalence relation is found by synthesizing a `Setoid` instance. `Quotient.mk` instead expects
the instance to be provided explicitly.
Given `v : α`, `Quotient.mk' v : Quotient s` is like `v`, except all obser... | 1,986 | 1,987 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
sound {α : Sort u} {s : Setoid α} {a b : α} : a ≈ b → Quotient.mk s a = Quotient.mk s b :=
Quot.sound | sound {α : Sort u} {s : Setoid α} {a b : α} : a ≈ b → Quotient.mk s a = Quotient.mk s b | Quot.sound | theorem | Quotient.sound | Init | src/Init/Core.lean | [] | [
"Quot.sound",
"Quotient.mk",
"Setoid"
] | The **quotient axiom**, which asserts the equality of elements related in the setoid.
Because `Quotient` is built on a lower-level type `Quot`, `Quotient.sound` is implemented as a
theorem. It is derived from `Quot.sound`, the soundness axiom for the lower-level quotient type
`Quot`. | 1,996 | 1,997 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
lift {α : Sort u} {β : Sort v} {s : Setoid α} (f : α → β) : ((a b : α) → a ≈ b → f a = f b) → Quotient s → β :=
Quot.lift f | lift {α : Sort u} {β : Sort v} {s : Setoid α} (f : α → β) : ((a b : α) → a ≈ b → f a = f b) → Quotient s → β | Quot.lift f | abbrev | Quotient.lift | Init | src/Init/Core.lean | [] | [
"Quotient",
"Setoid"
] | Lifts a function from an underlying type to a function on a quotient, requiring that it respects the
quotient's equivalence relation.
Given `s : Setoid α` and a quotient `Quotient s`, applying a function `f : α → β` requires a proof
`h` that `f` respects the equivalence relation `s.r`. In this case, the function
`Quot... | 2,010 | 2,011 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ind {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} : ((a : α) → motive (Quotient.mk s a)) → (q : Quotient s) → motive q :=
Quot.ind | ind {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop} : ((a : α) → motive (Quotient.mk s a)) → (q : Quotient s) → motive q | Quot.ind | theorem | Quotient.ind | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.mk",
"Setoid"
] | A reasoning principle for quotients that allows proofs about quotients to assume that all values are
constructed with `Quotient.mk`. | 2,017 | 2,018 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
liftOn {α : Sort u} {β : Sort v} {s : Setoid α} (q : Quotient s) (f : α → β) (c : (a b : α) → a ≈ b → f a = f b) : β :=
Quot.liftOn q f c | liftOn {α : Sort u} {β : Sort v} {s : Setoid α} (q : Quotient s) (f : α → β) (c : (a b : α) → a ≈ b → f a = f b) : β | Quot.liftOn q f c | abbrev | Quotient.liftOn | Init | src/Init/Core.lean | [] | [
"Quot.liftOn",
"Quotient",
"Setoid"
] | Lifts a function from an underlying type to a function on a quotient, requiring that it respects the
quotient's equivalence relation.
Given `s : Setoid α` and a quotient value `q : Quotient s`, applying a function `f : α → β` requires
a proof `c` that `f` respects the equivalence relation `s.r`. In this case, the term... | 2,031 | 2,032 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
inductionOn {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop}
(q : Quotient s)
(h : (a : α) → motive (Quotient.mk s a))
: motive q :=
Quot.inductionOn q h | inductionOn {α : Sort u} {s : Setoid α} {motive : Quotient s → Prop}
(q : Quotient s)
(h : (a : α) → motive (Quotient.mk s a))
: motive q | Quot.inductionOn q h | theorem | Quotient.inductionOn | Init | src/Init/Core.lean | [] | [
"Quot.inductionOn",
"Quotient",
"Quotient.mk",
"Setoid"
] | The analogue of `Quot.inductionOn`: every element of `Quotient s` is of the form `Quotient.mk s a`. | 2,035 | 2,040 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
exists_rep {α : Sort u} {s : Setoid α} (q : Quotient s) : Exists (fun (a : α) => Quotient.mk s a = q) :=
Quot.exists_rep q | exists_rep {α : Sort u} {s : Setoid α} (q : Quotient s) : Exists (fun (a : α) => Quotient.mk s a = q) | Quot.exists_rep q | theorem | Quotient.exists_rep | Init | src/Init/Core.lean | [] | [
"Exists",
"Quot.exists_rep",
"Quotient",
"Quotient.mk",
"Setoid"
] | null | 2,042 | 2,043 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rec
(f : (a : α) → motive (Quotient.mk s a))
(h : (a b : α) → (p : a ≈ b) → Eq.ndrec (f a) (Quotient.sound p) = f b)
(q : Quotient s)
: motive q :=
Quot.rec f h q | rec
(f : (a : α) → motive (Quotient.mk s a))
(h : (a b : α) → (p : a ≈ b) → Eq.ndrec (f a) (Quotient.sound p) = f b)
(q : Quotient s)
: motive q | Quot.rec f h q | def | Quotient.rec | Init | src/Init/Core.lean | [] | [
"Quot.rec",
"Quotient",
"Quotient.mk",
"Quotient.sound"
] | A dependent recursion principle for `Quotient`. It is analogous to the
[recursor](lean-manual://section/recursors) for a structure, and can be used when the resulting type
is not necessarily a proposition.
While it is very general, this recursor can be tricky to use. The following simpler alternatives may
be easier to... | 2,065 | 2,071 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
recOn
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
(h : (a b : α) → (p : a ≈ b) → Eq.ndrec (f a) (Quotient.sound p) = f b)
: motive q :=
Quot.recOn q f h | recOn
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
(h : (a b : α) → (p : a ≈ b) → Eq.ndrec (f a) (Quotient.sound p) = f b)
: motive q | Quot.recOn q f h | abbrev | Quotient.recOn | Init | src/Init/Core.lean | [] | [
"Quot.recOn",
"Quotient",
"Quotient.mk",
"Quotient.sound"
] | A dependent recursion principle for `Quotient`. It is analogous to the
[recursor](lean-manual://section/recursors) for a structure, and can be used when the resulting type
is not necessarily a proposition.
While it is very general, this recursor can be tricky to use. The following simpler alternatives may
be easier to... | 2,088 | 2,094 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
recOnSubsingleton
[h : (a : α) → Subsingleton (motive (Quotient.mk s a))]
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
: motive q :=
Quot.recOnSubsingleton (h := h) q f | recOnSubsingleton
[h : (a : α) → Subsingleton (motive (Quotient.mk s a))]
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
: motive q | Quot.recOnSubsingleton (h := h) q f | abbrev | Quotient.recOnSubsingleton | Init | src/Init/Core.lean | [] | [
"Quot.recOnSubsingleton",
"Quotient",
"Quotient.mk",
"Subsingleton"
] | An alternative recursion or induction principle for quotients that can be used when the target type
is a subsingleton, in which all elements are equal.
In these cases, the proof that the function respects the quotient's equivalence relation is trivial,
so any function can be lifted.
`Quotient.rec` does not assume tha... | 2,105 | 2,111 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
hrecOn
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
(c : (a b : α) → (p : a ≈ b) → f a ≍ f b)
: motive q :=
Quot.hrecOn q f c | hrecOn
(q : Quotient s)
(f : (a : α) → motive (Quotient.mk s a))
(c : (a b : α) → (p : a ≈ b) → f a ≍ f b)
: motive q | Quot.hrecOn q f c | abbrev | Quotient.hrecOn | Init | src/Init/Core.lean | [] | [
"Quot.hrecOn",
"Quotient",
"Quotient.mk"
] | A dependent recursion principle for `Quotient` that uses [heterogeneous
equality](lean-manual://section/HEq), analogous to a [recursor](lean-manual://section/recursors) for
a structure.
`Quotient.recOn` is a version of this recursor that uses `Eq` instead of `HEq`. | 2,120 | 2,126 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
lift₂
(f : α → β → φ)
(c : (a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂)
(q₁ : Quotient s₁) (q₂ : Quotient s₂)
: φ := by
apply Quotient.lift (fun (a₁ : α) => Quotient.lift (f a₁) (fun (a b : β) => c a₁ a a₁ b (Setoid.refl a₁)) q₂) _ q₁
intros
induction q₂ using... | lift₂
(f : α → β → φ)
(c : (a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂)
(q₁ : Quotient s₁) (q₂ : Quotient s₂)
: φ | by
apply Quotient.lift (fun (a₁ : α) => Quotient.lift (f a₁) (fun (a b : β) => c a₁ a a₁ b (Setoid.refl a₁)) q₂) _ q₁
intros
induction q₂ using Quotient.ind
apply c; assumption; apply Setoid.refl | abbrev | Quotient.lift₂ | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.ind",
"Quotient.lift",
"Setoid.refl"
] | Lifts a binary function from the underlying types to a binary function on quotients. The function
must respect both quotients' equivalence relations.
`Quotient.lift` is a version of this operation for unary functions. `Quotient.liftOn₂` is a version
that take the quotient parameters first. | 2,141 | 2,149 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
liftOn₂
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(f : α → β → φ)
(c : (a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂)
: φ :=
Quotient.lift₂ f c q₁ q₂ | liftOn₂
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(f : α → β → φ)
(c : (a₁ : α) → (b₁ : β) → (a₂ : α) → (b₂ : β) → a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂)
: φ | Quotient.lift₂ f c q₁ q₂ | abbrev | Quotient.liftOn₂ | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.lift₂"
] | Lifts a binary function from the underlying types to a binary function on quotients. The function
must respect both quotients' equivalence relations.
`Quotient.liftOn` is a version of this operation for unary functions. `Quotient.lift₂` is a version
that take the quotient parameters last. | 2,158 | 2,164 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ind₂
{motive : Quotient s₁ → Quotient s₂ → Prop}
(h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
: motive q₁ q₂ := by
induction q₁ using Quotient.ind
induction q₂ using Quotient.ind
apply h | ind₂
{motive : Quotient s₁ → Quotient s₂ → Prop}
(h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
: motive q₁ q₂ | by
induction q₁ using Quotient.ind
induction q₂ using Quotient.ind
apply h | theorem | Quotient.ind₂ | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.ind",
"Quotient.mk"
] | null | 2,166 | 2,175 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
inductionOn₂
{motive : Quotient s₁ → Quotient s₂ → Prop}
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
: motive q₁ q₂ := by
induction q₁ using Quotient.ind
induction q₂ using Quotient.ind
apply h | inductionOn₂
{motive : Quotient s₁ → Quotient s₂ → Prop}
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(h : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
: motive q₁ q₂ | by
induction q₁ using Quotient.ind
induction q₂ using Quotient.ind
apply h | theorem | Quotient.inductionOn₂ | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.ind",
"Quotient.mk"
] | null | 2,177 | 2,186 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
inductionOn₃
{s₃ : Setoid φ}
{motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(q₃ : Quotient s₃)
(h : (a : α) → (b : β) → (c : φ) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c))
: motive q₁ q₂ q₃ := by
induction q₁ using Quo... | inductionOn₃
{s₃ : Setoid φ}
{motive : Quotient s₁ → Quotient s₂ → Quotient s₃ → Prop}
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(q₃ : Quotient s₃)
(h : (a : α) → (b : β) → (c : φ) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b) (Quotient.mk s₃ c))
: motive q₁ q₂ q₃ | by
induction q₁ using Quotient.ind
induction q₂ using Quotient.ind
induction q₃ using Quotient.ind
apply h | theorem | Quotient.inductionOn₃ | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.ind",
"Quotient.mk",
"Setoid"
] | null | 2,188 | 2,200 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rel {s : Setoid α} (q₁ q₂ : Quotient s) : Prop :=
Quotient.liftOn₂ q₁ q₂
(fun a₁ a₂ => a₁ ≈ a₂)
(fun _ _ _ _ a₁b₁ a₂b₂ =>
propext (Iff.intro
(fun a₁a₂ => Setoid.trans (Setoid.symm a₁b₁) (Setoid.trans a₁a₂ a₂b₂))
(fun b₁b₂ => Setoid.trans a₁b₁ (Setoid.trans b₁b₂ (Setoid.symm a₂b₂))))) | rel {s : Setoid α} (q₁ q₂ : Quotient s) : Prop | Quotient.liftOn₂ q₁ q₂
(fun a₁ a₂ => a₁ ≈ a₂)
(fun _ _ _ _ a₁b₁ a₂b₂ =>
propext (Iff.intro
(fun a₁a₂ => Setoid.trans (Setoid.symm a₁b₁) (Setoid.trans a₁a₂ a₂b₂))
(fun b₁b₂ => Setoid.trans a₁b₁ (Setoid.trans b₁b₂ (Setoid.symm a₂b₂))))) | def | Quotient.rel | Init | src/Init/Core.lean | [] | [
"Quotient",
"Quotient.liftOn₂",
"Setoid",
"Setoid.symm",
"Setoid.trans",
"propext"
] | null | 2,208 | 2,214 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rel.refl {s : Setoid α} (q : Quotient s) : rel q q :=
q.inductionOn Setoid.refl | rel.refl {s : Setoid α} (q : Quotient s) : rel q q | q.inductionOn Setoid.refl | theorem | Quotient.rel.refl | Init | src/Init/Core.lean | [] | [
"Quotient",
"Setoid",
"Setoid.refl"
] | null | 2,216 | 2,217 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
rel_of_eq {s : Setoid α} {q₁ q₂ : Quotient s} : q₁ = q₂ → rel q₁ q₂ :=
fun h => Eq.ndrecOn h (rel.refl q₁) | rel_of_eq {s : Setoid α} {q₁ q₂ : Quotient s} : q₁ = q₂ → rel q₁ q₂ | fun h => Eq.ndrecOn h (rel.refl q₁) | theorem | Quotient.rel_of_eq | Init | src/Init/Core.lean | [] | [
"Quotient",
"Setoid"
] | null | 2,219 | 2,220 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
exact {s : Setoid α} {a b : α} : Quotient.mk s a = Quotient.mk s b → a ≈ b :=
fun h => rel_of_eq h | exact {s : Setoid α} {a b : α} : Quotient.mk s a = Quotient.mk s b → a ≈ b | fun h => rel_of_eq h | theorem | Quotient.exact | Init | src/Init/Core.lean | [] | [
"Quotient.mk",
"Setoid"
] | If two values are equal in a quotient, then they are related by its equivalence relation. | 2,225 | 2,226 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
recOnSubsingleton₂
{motive : Quotient s₁ → Quotient s₂ → Sort uC}
[s : (a : α) → (b : β) → Subsingleton (motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))]
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(g : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
: motive q₁ q₂ := by
induction q₁... | recOnSubsingleton₂
{motive : Quotient s₁ → Quotient s₂ → Sort uC}
[s : (a : α) → (b : β) → Subsingleton (motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))]
(q₁ : Quotient s₁)
(q₂ : Quotient s₂)
(g : (a : α) → (b : β) → motive (Quotient.mk s₁ a) (Quotient.mk s₂ b))
: motive q₁ q₂ | by
induction q₁ using Quot.recOnSubsingleton
induction q₂ using Quot.recOnSubsingleton
apply g
intro a; apply s
induction q₂ using Quot.recOnSubsingleton
intro a; apply s
infer_instance | abbrev | Quotient.recOnSubsingleton₂ | Init | src/Init/Core.lean | [] | [
"Quot.recOnSubsingleton",
"Quotient",
"Quotient.mk",
"Subsingleton"
] | An alternative induction or recursion operator for defining binary operations on quotients that can
be used when the target type is a subsingleton.
In these cases, the proof that the function respects the quotient's equivalence relation is trivial,
so any function can be lifted. | 2,242 | 2,256 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Quotient.decidableEq {α : Sort u} {s : Setoid α} [d : ∀ (a b : α), Decidable (a ≈ b)]
: DecidableEq (Quotient s) :=
fun (q₁ q₂ : Quotient s) =>
Quotient.recOnSubsingleton₂ q₁ q₂
fun a₁ a₂ =>
match d a₁ a₂ with
| isTrue h₁ => isTrue (Quotient.sound h₁)
| isFalse h₂ => isFalse fun... | Quotient.decidableEq {α : Sort u} {s : Setoid α} [d : ∀ (a b : α), Decidable (a ≈ b)]
: DecidableEq (Quotient s) | fun (q₁ q₂ : Quotient s) =>
Quotient.recOnSubsingleton₂ q₁ q₂
fun a₁ a₂ =>
match d a₁ a₂ with
| isTrue h₁ => isTrue (Quotient.sound h₁)
| isFalse h₂ => isFalse fun h => absurd (Quotient.exact h) h₂ | instance | Quotient.decidableEq | Init | src/Init/Core.lean | [] | [
"Decidable",
"DecidableEq",
"Quotient",
"Quotient.exact",
"Quotient.recOnSubsingleton₂",
"Quotient.sound",
"Setoid",
"absurd"
] | null | 2,261 | 2,268 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
funext {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}
(h : ∀ x, f x = g x) : f = g := by
let eqv (f g : (x : α) → β x) := ∀ x, f x = g x
let extfunApp (f : Quot eqv) (x : α) : β x :=
Quot.liftOn f
(fun (f : ∀ (x : α), β x) => f x)
(fun _ _ h => h x)
change extfunApp (Quot.mk eqv f) = extf... | funext {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}
(h : ∀ x, f x = g x) : f = g | by
let eqv (f g : (x : α) → β x) := ∀ x, f x = g x
let extfunApp (f : Quot eqv) (x : α) : β x :=
Quot.liftOn f
(fun (f : ∀ (x : α), β x) => f x)
(fun _ _ h => h x)
change extfunApp (Quot.mk eqv f) = extfunApp (Quot.mk eqv g)
exact congrArg extfunApp (Quot.sound h) | theorem | funext | Init | src/Init/Core.lean | [] | [
"Quot.liftOn",
"Quot.sound",
"congrArg"
] | **Function extensionality.** If two functions return equal results for all possible arguments, then
they are equal.
It is called “extensionality” because it provides a way to prove two objects equal based on the
properties of the underlying mathematical functions, rather than based on the syntax used to denote
them. F... | 2,281 | 2,289 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Quot.pliftOn {α : Sort u} {r : α → α → Prop}
(q : Quot r)
(f : (a : α) → q = Quot.mk r a → β)
(h : ∀ (a b : α) (h h'), r a b → f a h = f b h') : β :=
q.rec (motive := fun q' => q = q' → β) f
(fun a b p => funext fun h' =>
(apply_eqRec (motive := fun b _ => q = b)).trans
(@h a b (h'.trans... | Quot.pliftOn {α : Sort u} {r : α → α → Prop}
(q : Quot r)
(f : (a : α) → q = Quot.mk r a → β)
(h : ∀ (a b : α) (h h'), r a b → f a h = f b h') : β | q.rec (motive := fun q' => q = q' → β) f
(fun a b p => funext fun h' =>
(apply_eqRec (motive := fun b _ => q = b)).trans
(@h a b (h'.trans (sound p).symm) h' p)) rfl | abbrev | Quot.pliftOn | Init | src/Init/Core.lean | [] | [
"apply_eqRec",
"funext",
"rfl"
] | Like `Quot.liftOn q f h` but allows `f a` to "know" that `q = Quot.mk r a`. | 2,294 | 2,301 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Quotient.pliftOn {α : Sort u} {s : Setoid α}
(q : Quotient s)
(f : (a : α) → q = Quotient.mk s a → β)
(h : ∀ (a b : α) (h h'), a ≈ b → f a h = f b h') : β :=
Quot.pliftOn q f h | Quotient.pliftOn {α : Sort u} {s : Setoid α}
(q : Quotient s)
(f : (a : α) → q = Quotient.mk s a → β)
(h : ∀ (a b : α) (h h'), a ≈ b → f a h = f b h') : β | Quot.pliftOn q f h | abbrev | Quotient.pliftOn | Init | src/Init/Core.lean | [] | [
"Quot.pliftOn",
"Quotient",
"Quotient.mk",
"Setoid"
] | Like `Quotient.liftOn q f h` but allows `f a` to "know" that `q = Quotient.mk s a`. | 2,306 | 2,310 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Pi.instSubsingleton {α : Sort u} {β : α → Sort v} [∀ a, Subsingleton (β a)] :
Subsingleton (∀ a, β a) where
allEq f g := funext fun a => Subsingleton.elim (f a) (g a) | Pi.instSubsingleton {α : Sort u} {β : α → Sort v} [∀ a, Subsingleton (β a)] :
Subsingleton (∀ a, β a) where
allEq f g := funext fun a => Subsingleton.elim (f a) (g a) | instance | Pi.instSubsingleton | Init | src/Init/Core.lean | [] | [
"Subsingleton",
"Subsingleton.elim",
"funext"
] | null | 2,312 | 2,314 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
equivalence_true (α : Sort u) : Equivalence fun _ _ : α => True :=
⟨fun _ => trivial, fun _ => trivial, fun _ _ => trivial⟩ | equivalence_true (α : Sort u) : Equivalence fun _ _ : α => True | ⟨fun _ => trivial, fun _ => trivial, fun _ _ => trivial⟩ | theorem | equivalence_true | Init | src/Init/Core.lean | [] | [
"Equivalence",
"True",
"trivial"
] | null | 2,318 | 2,319 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Setoid.trivial (α : Sort u) : Setoid α :=
⟨_, equivalence_true α⟩ | Setoid.trivial (α : Sort u) : Setoid α | ⟨_, equivalence_true α⟩ | def | Setoid.trivial | Init | src/Init/Core.lean | [] | [
"Setoid",
"equivalence_true"
] | Always-true relation as a `Setoid`. | 2,322 | 2,323 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Squash (α : Sort u) := Quotient (Setoid.trivial α) | Squash (α : Sort u) | Quotient (Setoid.trivial α) | def | Squash | Init | src/Init/Core.lean | [] | [
"Quotient",
"Setoid.trivial"
] | The quotient of `α` by the universal relation. The elements of `Squash α` are those of `α`, but all
of them are equal and cannot be distinguished.
`Squash α` is a `Subsingleton`: it is empty if `α` is empty, otherwise it has just one element. It
is the “universal `Subsingleton`” mapped from `α`.
`Nonempty α` also has... | 2,342 | 2,342 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Squash.mk {α : Sort u} (x : α) : Squash α := Quot.mk _ x | Squash.mk {α : Sort u} (x : α) : Squash α | Quot.mk _ x | def | Squash.mk | Init | src/Init/Core.lean | [] | [
"Squash"
] | Places a value into its squash type, in which it cannot be distinguished from any other. | 2,347 | 2,347 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Squash.ind {α : Sort u} {motive : Squash α → Prop} (h : ∀ (a : α), motive (Squash.mk a)) : ∀ (q : Squash α), motive q :=
Quot.ind h | Squash.ind {α : Sort u} {motive : Squash α → Prop} (h : ∀ (a : α), motive (Squash.mk a)) : ∀ (q : Squash α), motive q | Quot.ind h | theorem | Squash.ind | Init | src/Init/Core.lean | [] | [
"Squash",
"Squash.mk"
] | A reasoning principle that allows proofs about squashed types to assume that all values are
constructed with `Squash.mk`. | 2,353 | 2,354 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Squash.lift {α β} [Subsingleton β] (s : Squash α) (f : α → β) : β :=
Quot.lift f (fun _ _ _ => Subsingleton.elim _ _) s | Squash.lift {α β} [Subsingleton β] (s : Squash α) (f : α → β) : β | Quot.lift f (fun _ _ _ => Subsingleton.elim _ _) s | def | Squash.lift | Init | src/Init/Core.lean | [] | [
"Squash",
"Subsingleton",
"Subsingleton.elim"
] | Extracts a squashed value into any subsingleton type.
If `β` is a subsingleton, a function `α → β` cannot distinguish between elements of `α` and thus
automatically respects the universal relation that `Squash` quotients with. | 2,362 | 2,363 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
: Subsingleton (Squash α) where
allEq a b := by
induction a using Squash.ind
induction b using Squash.ind
apply Quot.sound
trivial | : Subsingleton (Squash α) where
allEq a b := by
induction a using Squash.ind
induction b using Squash.ind
apply Quot.sound
trivial | instance | Init | src/Init/Core.lean | [] | [
"Quot.sound",
"Squash",
"Squash.ind",
"Subsingleton",
"trivial"
] | null | 2,365 | 2,370 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | ||
trustCompiler : True | trustCompiler : True | axiom | Lean.trustCompiler | Init | src/Init/Core.lean | [] | [
"True"
] | Depends on the correctness of the Lean compiler, interpreter, and all `[implemented_by ...]` and `[extern ...]` annotations. | 2,378 | 2,379 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
reduceBool (b : Bool) : Bool :=
-- This ensures that `#print axioms` will track use of `reduceBool`.
have := trustCompiler
b | reduceBool (b : Bool) : Bool | -- This ensures that `#print axioms` will track use of `reduceBool`.
have := trustCompiler
b | opaque | Lean.reduceBool | Init | src/Init/Core.lean | [] | [
"Bool"
] | When the kernel tries to reduce a term `Lean.reduceBool c`, it will invoke the Lean interpreter to evaluate `c`.
The kernel will not use the interpreter if `c` is not a constant.
This feature is useful for performing proofs by reflection.
Remark: the Lean frontend allows terms of the from `Lean.reduceBool t` where `t`... | 2,401 | 2,405 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
reduceNat (n : Nat) : Nat :=
-- This ensures that `#print axioms` will track use of `reduceNat`.
have := trustCompiler
n | reduceNat (n : Nat) : Nat | -- This ensures that `#print axioms` will track use of `reduceNat`.
have := trustCompiler
n | opaque | Lean.reduceNat | Init | src/Init/Core.lean | [] | [
"Nat"
] | Similar to `Lean.reduceBool` for closed `Nat` terms.
Remark: we do not have plans for supporting a generic `reduceValue {α} (a : α) : α := a`.
The main issue is that it is non-trivial to convert an arbitrary runtime object back into a Lean expression.
We believe `Lean.reduceBool` enables most interesting applications ... | 2,415 | 2,419 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ofReduceBool (a b : Bool) (h : reduceBool a = b) : a = b | ofReduceBool (a b : Bool) (h : reduceBool a = b) : a = b | axiom | Lean.ofReduceBool | Init | src/Init/Core.lean | [] | [
"Bool"
] | The axiom `ofReduceBool` is used to perform proofs by reflection. See `reduceBool`.
This axiom is usually not used directly, because it has some syntactic restrictions.
Instead, the `native_decide` tactic can be used to prove any proposition whose
decidability instance can be evaluated to `true` using the lean compile... | 2,436 | 2,437 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
ofReduceNat (a b : Nat) (h : reduceNat a = b) : a = b | ofReduceNat (a b : Nat) (h : reduceNat a = b) : a = b | axiom | Lean.ofReduceNat | Init | src/Init/Core.lean | [] | [
"Nat"
] | The axiom `ofReduceNat` is used to perform proofs by reflection. See `reduceBool`.
Warning: by using this feature, the Lean compiler and interpreter become part of your trusted code base.
This is extra 30k lines of code. More importantly, you will probably not be able to check your development using
external type chec... | 2,449 | 2,450 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
opaqueId {α : Sort u} (x : α) : α := x | opaqueId {α : Sort u} (x : α) : α | x | opaque | Lean.opaqueId | Init | src/Init/Core.lean | [] | [] | The term `opaqueId x` will not be reduced by the kernel. | 2,456 | 2,456 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
ge_iff_le [LE α] {x y : α} : x ≥ y ↔ y ≤ x := Iff.rfl | ge_iff_le [LE α] {x y : α} : x ≥ y ↔ y ≤ x | Iff.rfl | theorem | ge_iff_le | Init | src/Init/Core.lean | [] | [
"Iff.rfl",
"LE"
] | null | 2,460 | 2,460 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
gt_iff_lt [LT α] {x y : α} : x > y ↔ y < x := Iff.rfl | gt_iff_lt [LT α] {x y : α} : x > y ↔ y < x | Iff.rfl | theorem | gt_iff_lt | Init | src/Init/Core.lean | [] | [
"Iff.rfl",
"LT"
] | null | 2,462 | 2,462 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
le_of_eq_of_le {a b c : α} [LE α] (h₁ : a = b) (h₂ : b ≤ c) : a ≤ c := h₁ ▸ h₂ | le_of_eq_of_le {a b c : α} [LE α] (h₁ : a = b) (h₂ : b ≤ c) : a ≤ c | h₁ ▸ h₂ | theorem | le_of_eq_of_le | Init | src/Init/Core.lean | [] | [
"LE"
] | null | 2,464 | 2,464 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
le_of_le_of_eq {a b c : α} [LE α] (h₁ : a ≤ b) (h₂ : b = c) : a ≤ c := h₂ ▸ h₁ | le_of_le_of_eq {a b c : α} [LE α] (h₁ : a ≤ b) (h₂ : b = c) : a ≤ c | h₂ ▸ h₁ | theorem | le_of_le_of_eq | Init | src/Init/Core.lean | [] | [
"LE"
] | null | 2,466 | 2,466 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
lt_of_eq_of_lt {a b c : α} [LT α] (h₁ : a = b) (h₂ : b < c) : a < c := h₁ ▸ h₂ | lt_of_eq_of_lt {a b c : α} [LT α] (h₁ : a = b) (h₂ : b < c) : a < c | h₁ ▸ h₂ | theorem | lt_of_eq_of_lt | Init | src/Init/Core.lean | [] | [
"LT"
] | null | 2,468 | 2,468 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
lt_of_lt_of_eq {a b c : α} [LT α] (h₁ : a < b) (h₂ : b = c) : a < c := h₂ ▸ h₁ | lt_of_lt_of_eq {a b c : α} [LT α] (h₁ : a < b) (h₂ : b = c) : a < c | h₂ ▸ h₁ | theorem | lt_of_lt_of_eq | Init | src/Init/Core.lean | [] | [
"LT"
] | null | 2,470 | 2,470 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
Associative (op : α → α → α) : Prop where
/-- An associative operation satisfies `(a ∘ b) ∘ c = a ∘ (b ∘ c)`. -/
assoc : (a b c : α) → op (op a b) c = op a (op b c) | Associative (op : α → α → α) : Prop where
/-- An associative operation satisfies `(a ∘ b) ∘ c = a ∘ (b ∘ c)`. -/
assoc : (a b c : α) → op (op a b) c = op a (op b c) | class | Std.Associative | Init | src/Init/Core.lean | [] | [] | `Associative op` indicates `op` is an associative operation,
i.e. `(a ∘ b) ∘ c = a ∘ (b ∘ c)`. | 2,479 | 2,481 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Commutative (op : α → α → α) : Prop where
/-- A commutative operation satisfies `a ∘ b = b ∘ a`. -/
comm : (a b : α) → op a b = op b a | Commutative (op : α → α → α) : Prop where
/-- A commutative operation satisfies `a ∘ b = b ∘ a`. -/
comm : (a b : α) → op a b = op b a | class | Std.Commutative | Init | src/Init/Core.lean | [] | [] | `Commutative op` says that `op` is a commutative operation,
i.e. `a ∘ b = b ∘ a`. | 2,487 | 2,489 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
IdempotentOp (op : α → α → α) : Prop where
/-- An idempotent operation satisfies `a ∘ a = a`. -/
idempotent : (x : α) → op x x = x | IdempotentOp (op : α → α → α) : Prop where
/-- An idempotent operation satisfies `a ∘ a = a`. -/
idempotent : (x : α) → op x x = x | class | Std.IdempotentOp | Init | src/Init/Core.lean | [] | [] | `IdempotentOp op` indicates `op` is an idempotent binary operation.
i.e. `a ∘ a = a`. | 2,495 | 2,497 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LeftIdentity (op : α → β → β) (o : outParam α) : Prop | LeftIdentity (op : α → β → β) (o : outParam α) : Prop | class | Std.LeftIdentity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `LeftIdentity op o` indicates `o` is a left identity of `op`.
This class does not require a proof that `o` is an identity, and
is used primarily for inferring the identity using class resolution. | 2,505 | 2,505 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LawfulLeftIdentity (op : α → β → β) (o : outParam α) : Prop extends LeftIdentity op o where
/-- Left identity `o` is an identity. -/
left_id : ∀ a, op o a = a | LawfulLeftIdentity (op : α → β → β) (o : outParam α) : Prop extends LeftIdentity op o where
/-- Left identity `o` is an identity. -/
left_id : ∀ a, op o a = a | class | Std.LawfulLeftIdentity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `LawfulLeftIdentity op o` indicates `o` is a verified left identity of
`op`. | 2,511 | 2,513 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
RightIdentity (op : α → β → α) (o : outParam β) : Prop | RightIdentity (op : α → β → α) (o : outParam β) : Prop | class | Std.RightIdentity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `RightIdentity op o` indicates `o` is a right identity `o` of `op`.
This class does not require a proof that `o` is an identity, and is used
primarily for inferring the identity using class resolution. | 2,521 | 2,521 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LawfulRightIdentity (op : α → β → α) (o : outParam β) : Prop extends RightIdentity op o where
/-- Right identity `o` is an identity. -/
right_id : ∀ a, op a o = a | LawfulRightIdentity (op : α → β → α) (o : outParam β) : Prop extends RightIdentity op o where
/-- Right identity `o` is an identity. -/
right_id : ∀ a, op a o = a | class | Std.LawfulRightIdentity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `LawfulRightIdentity op o` indicates `o` is a verified right identity of
`op`. | 2,527 | 2,529 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Identity (op : α → α → α) (o : outParam α) : Prop extends LeftIdentity op o, RightIdentity op o | Identity (op : α → α → α) (o : outParam α) : Prop extends LeftIdentity op o, RightIdentity op o | class | Std.Identity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `Identity op o` indicates `o` is a left and right identity of `op`.
This class does not require a proof that `o` is an identity, and is used
primarily for inferring the identity using class resolution. | 2,537 | 2,537 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LawfulIdentity (op : α → α → α) (o : outParam α) : Prop extends Identity op o, LawfulLeftIdentity op o, LawfulRightIdentity op o | LawfulIdentity (op : α → α → α) (o : outParam α) : Prop extends Identity op o, LawfulLeftIdentity op o, LawfulRightIdentity op o | class | Std.LawfulIdentity | Init | src/Init/Core.lean | [] | [
"outParam"
] | `LawfulIdentity op o` indicates `o` is a verified left and right
identity of `op`. | 2,543 | 2,543 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
LawfulCommIdentity (op : α → α → α) (o : outParam α) [hc : Commutative op] : Prop extends LawfulIdentity op o where
left_id a := Eq.trans (hc.comm o a) (right_id a)
right_id a := Eq.trans (hc.comm a o) (left_id a) | LawfulCommIdentity (op : α → α → α) (o : outParam α) [hc : Commutative op] : Prop extends LawfulIdentity op o where
left_id a := Eq.trans (hc.comm o a) (right_id a)
right_id a := Eq.trans (hc.comm a o) (left_id a) | class | Std.LawfulCommIdentity | Init | src/Init/Core.lean | [] | [
"Eq.trans",
"outParam"
] | `LawfulCommIdentity` can simplify defining instances of `LawfulIdentity`
on commutative functions by requiring only a left or right identity
proof.
This class is intended for simplifying defining instances of
`LawfulIdentity` and functions needed commutative operations with
identity should just add a `LawfulIdentity` ... | 2,554 | 2,556 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
: Commutative Or := ⟨fun _ _ => propext or_comm⟩ | : Commutative Or | ⟨fun _ _ => propext or_comm⟩ | instance | Init | src/Init/Core.lean | [] | [
"Or",
"propext"
] | null | 2,558 | 2,558 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
: Commutative And := ⟨fun _ _ => propext and_comm⟩ | : Commutative And | ⟨fun _ _ => propext and_comm⟩ | instance | Init | src/Init/Core.lean | [] | [
"And",
"propext"
] | null | 2,559 | 2,559 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
: Commutative Iff := ⟨fun _ _ => propext iff_comm⟩ | : Commutative Iff | ⟨fun _ _ => propext iff_comm⟩ | instance | Init | src/Init/Core.lean | [] | [
"Iff",
"propext"
] | null | 2,560 | 2,560 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Refl (r : α → α → Prop) : Prop where
/-- A reflexive relation satisfies `r a a`. -/
refl : ∀ a, r a a | Refl (r : α → α → Prop) : Prop where
/-- A reflexive relation satisfies `r a a`. -/
refl : ∀ a, r a a | class | Std.Refl | Init | src/Init/Core.lean | [] | [] | `Refl r` means the binary relation `r` is reflexive, that is, `r x x` always holds. | 2,563 | 2,565 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Antisymm (r : α → α → Prop) : Prop where
/-- An antisymmetric relation `r` satisfies `r a b → r b a → a = b`. -/
antisymm (a b : α) : r a b → r b a → a = b | Antisymm (r : α → α → Prop) : Prop where
/-- An antisymmetric relation `r` satisfies `r a b → r b a → a = b`. -/
antisymm (a b : α) : r a b → r b a → a = b | class | Std.Antisymm | Init | src/Init/Core.lean | [] | [] | `Antisymm r` says that `r` is antisymmetric, that is, `r a b → r b a → a = b`. | 2,568 | 2,570 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Asymm (r : α → α → Prop) : Prop where
/-- An asymmetric relation satisfies `r a b → ¬ r b a`. -/
asymm : ∀ a b, r a b → ¬r b a | Asymm (r : α → α → Prop) : Prop where
/-- An asymmetric relation satisfies `r a b → ¬ r b a`. -/
asymm : ∀ a b, r a b → ¬r b a | class | Std.Asymm | Init | src/Init/Core.lean | [] | [] | `Asymm r` means that the binary relation `r` is asymmetric, that is, `r a b → ¬ r b a`. | 2,573 | 2,575 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Symm (r : α → α → Prop) : Prop where
/-- A symmetric relation satisfies `r a b → r b a`. -/
symm : ∀ a b, r a b → r b a | Symm (r : α → α → Prop) : Prop where
/-- A symmetric relation satisfies `r a b → r b a`. -/
symm : ∀ a b, r a b → r b a | class | Std.Symm | Init | src/Init/Core.lean | [] | [] | `Symm r` means that the binary relation `r` is symmetric, that is, `r a b → r b a`. | 2,578 | 2,580 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Total (r : α → α → Prop) : Prop where
/-- A total relation satisfies `r a b` or `r b a`. -/
total : ∀ a b, r a b ∨ r b a | Total (r : α → α → Prop) : Prop where
/-- A total relation satisfies `r a b` or `r b a`. -/
total : ∀ a b, r a b ∨ r b a | class | Std.Total | Init | src/Init/Core.lean | [] | [] | `Total X r` means that the binary relation `r` on `X` is total, that is, `r a b` or `r b a`. | 2,583 | 2,585 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Irrefl (r : α → α → Prop) : Prop where
/-- An irreflexive relation satisfies `¬ r a a`. -/
irrefl : ∀ a, ¬r a a | Irrefl (r : α → α → Prop) : Prop where
/-- An irreflexive relation satisfies `¬ r a a`. -/
irrefl : ∀ a, ¬r a a | class | Std.Irrefl | Init | src/Init/Core.lean | [] | [] | `Irrefl r` means the binary relation `r` is irreflexive, that is, `r x x` never holds. | 2,588 | 2,590 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
Trichotomous (r : α → α → Prop) : Prop where
/-- An trichotomous relation `r` satisfies `¬ r a b → ¬ r b a → a = b`. -/
trichotomous (a b : α) : ¬ r a b → ¬ r b a → a = b | Trichotomous (r : α → α → Prop) : Prop where
/-- An trichotomous relation `r` satisfies `¬ r a b → ¬ r b a → a = b`. -/
trichotomous (a b : α) : ¬ r a b → ¬ r b a → a = b | class | Std.Trichotomous | Init | src/Init/Core.lean | [] | [] | `Trichotomous r` says that `r` is trichotomous, that is, `¬ r a b → ¬ r b a → a = b`. | 2,593 | 2,595 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
flip_flip {α : Sort u} {β : Sort v} {φ : Sort w} {f : α → β → φ} :
flip (flip f) = f := by
apply funext
intro a
apply funext
intro b
rw [flip, flip] | flip_flip {α : Sort u} {β : Sort v} {φ : Sort w} {f : α → β → φ} :
flip (flip f) = f | by
apply funext
intro a
apply funext
intro b
rw [flip, flip] | theorem | flip_flip | Init | src/Init/Core.lean | [] | [
"flip",
"funext"
] | null | 2,599 | 2,605 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
TypeNameData (α : Type u) : NonemptyType.{0} :=
⟨Name, inferInstance⟩ | TypeNameData (α : Type u) : NonemptyType.{0} | ⟨Name, inferInstance⟩ | opaque | TypeNameData | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [] | null | 19 | 20 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
TypeName (α : Type u) where private mk' ::
private data : (TypeNameData α).type | TypeName (α : Type u) where private mk' ::
private data : (TypeNameData α).type | class | TypeName | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [
"TypeNameData"
] | Dynamic type name information.
Types with an instance of `TypeName` can be stored in an `Dynamic`.
The type class contains the declaration name of the type,
which must not have any universe parameters
and be of type `Sort ..` (i.e., monomorphic).
The preferred way to declare instances of this type is using the derive
... | 38 | 40 | false | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
: Nonempty (TypeName α) := by exact (TypeNameData α).property.elim (⟨⟨·⟩⟩) | : Nonempty (TypeName α) | by exact (TypeNameData α).property.elim (⟨⟨·⟩⟩) | instance | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [
"Nonempty",
"TypeName",
"TypeNameData"
] | null | 42 | 42 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 | |
TypeName.mk (α : Type u) (typeName : Name) : TypeName α :=
⟨unsafeCast typeName⟩ | TypeName.mk (α : Type u) (typeName : Name) : TypeName α | ⟨unsafeCast typeName⟩ | def | TypeName.mk | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [
"TypeName"
] | Creates a `TypeName` instance.
For safety, it is required that the constant `typeName` is definitionally equal
to `α`. | 50 | 52 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
TypeName.typeNameImpl (α) [TypeName α] : Name :=
unsafeCast (@TypeName.data α _) | TypeName.typeNameImpl (α) [TypeName α] : Name | unsafeCast (@TypeName.data α _) | def | TypeName.typeNameImpl | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [
"TypeName",
"unsafeCast"
] | null | 54 | 55 | true | https://github.com/leanprover/lean4 | d265d1ca745e7741a7e7f7366c22ce9c9dda57b6 |
TypeName.typeName (α) [TypeName α] : Name | TypeName.typeName (α) [TypeName α] : Name | opaque | TypeName.typeName | Init | src/Init/Dynamic.lean | [
"Init.Core"
] | [
"TypeName"
] | Returns a declaration name of the type. | 60 | 61 | false | 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.