Hugging Face's logo

Datasets:
erbacher
/
LeanRank-corpus

Modalities:
Text
Formats:
parquet
Size:
100K - 1M
Libraries:
Datasets
pandas
Dataset card Data Studio Files
xet
Community
1
Dataset Viewer
Auto-converted to Parquet Duplicate
path
stringlengths
20
108
imports
listlengths
0
20
full_name
stringlengths
1
124
code
stringlengths
15
16.6k
start
listlengths
2
2
end
listlengths
2
2
kind
stringclasses
3 values
pid
int64
0
249k
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
id
@[inline] def id {α : Sort u} (a : α) : α := a
[ 23, 1 ]
[ 35, 47 ]
commanddeclaration
0
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Function.comp
@[inline] def Function.comp {α : Sort u} {β : Sort v} {δ : Sort w} (f : β → δ) (g : α → β) : α → δ := fun x => f (g x)
[ 37, 1 ]
[ 46, 19 ]
commanddeclaration
1
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Function.const
@[inline] def Function.const {α : Sort u} (β : Sort v) (a : α) : β → α := fun _ => a
[ 48, 1 ]
[ 60, 13 ]
commanddeclaration
2
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
letFun
@[irreducible] def letFun {α : Sort u} {β : α → Sort v} (v : α) (f : (x : α) → β x) : β v := f v
[ 62, 1 ]
[ 73, 97 ]
commanddeclaration
3
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
inferInstance
abbrev inferInstance {α : Sort u} [i : α] : α := i
[ 76, 1 ]
[ 92, 51 ]
commanddeclaration
4
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
inferInstanceAs
abbrev inferInstanceAs (α : Sort u) [i : α] : α := i
[ 95, 1 ]
[ 106, 53 ]
commanddeclaration
5
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PUnit
inductive PUnit : Sort u where | unit : PUnit
[ 109, 1 ]
[ 117, 17 ]
commanddeclaration
6
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Unit
abbrev Unit : Type := PUnit
[ 119, 1 ]
[ 129, 28 ]
commanddeclaration
7
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Unit.unit
@[match_pattern] abbrev Unit.unit : Unit := PUnit.unit
[ 131, 1 ]
[ 136, 55 ]
commanddeclaration
8
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
lcErased
unsafe axiom lcErased : Type
[ 138, 1 ]
[ 139, 29 ]
commanddeclaration
9
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
lcAny
unsafe axiom lcAny : Type
[ 141, 1 ]
[ 142, 26 ]
commanddeclaration
10
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
lcProof
unsafe axiom lcProof {α : Prop} : α
[ 144, 1 ]
[ 153, 36 ]
commanddeclaration
11
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
lcCast
unsafe axiom lcCast {α : Sort u} {β : Sort v} (a : α) : β
[ 155, 1 ]
[ 158, 58 ]
commanddeclaration
12
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
lcUnreachable
unsafe axiom lcUnreachable {α : Sort u} : α
[ 161, 1 ]
[ 173, 44 ]
commanddeclaration
13
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
True
inductive True : Prop where | intro : True
[ 175, 1 ]
[ 183, 17 ]
commanddeclaration
14
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
False
inductive False : Prop
[ 185, 1 ]
[ 193, 23 ]
commanddeclaration
15
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Empty
inductive Empty : Type
[ 195, 1 ]
[ 200, 23 ]
commanddeclaration
16
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PEmpty
inductive PEmpty : Sort u where
[ 203, 1 ]
[ 210, 32 ]
commanddeclaration
17
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Not
def Not (a : Prop) : Prop := a → False
[ 212, 1 ]
[ 219, 39 ]
commanddeclaration
18
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
False.elim
@[macro_inline] def False.elim {C : Sort u} (h : False) : C := h.rec
[ 221, 1 ]
[ 232, 8 ]
commanddeclaration
19
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
absurd
@[macro_inline] def absurd {a : Prop} {b : Sort v} (h₁ : a) (h₂ : Not a) : b := (h₂ h₁).rec
[ 234, 1 ]
[ 242, 14 ]
commanddeclaration
20
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Eq
inductive Eq : α → α → Prop where | refl (a : α) : Eq a a
[ 244, 1 ]
[ 274, 26 ]
commanddeclaration
21
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Eq.ndrec
@[simp] abbrev Eq.ndrec.{u1, u2} {α : Sort u2} {a : α} {motive : α → Sort u1} (m : motive a) {b : α} (h : Eq a b) : motive b := h.rec m
[ 276, 1 ]
[ 278, 10 ]
commanddeclaration
22
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
rfl
@[match_pattern] def rfl {α : Sort u} {a : α} : Eq a a := Eq.refl a
[ 280, 1 ]
[ 289, 68 ]
commanddeclaration
23
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
id_eq
@[simp] theorem id_eq (a : α) : Eq (id a) a
[ 291, 1 ]
[ 292, 51 ]
commanddeclaration
24
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Eq.subst
theorem Eq.subst {α : Sort u} {motive : α → Prop} {a b : α} (h₁ : Eq a b) (h₂ : motive a) : motive b
[ 294, 1 ]
[ 308, 17 ]
commanddeclaration
25
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Eq.symm
@[symm] theorem Eq.symm {α : Sort u} {a b : α} (h : Eq a b) : Eq b a
[ 310, 1 ]
[ 319, 10 ]
commanddeclaration
26
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Eq.trans
theorem Eq.trans {α : Sort u} {a b c : α} (h₁ : Eq a b) (h₂ : Eq b c) : Eq a c
[ 321, 1 ]
[ 331, 10 ]
commanddeclaration
27
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
cast
@[macro_inline] def cast {α β : Sort u} (h : Eq α β) (a : α) : β := h.rec a
[ 333, 1 ]
[ 345, 10 ]
commanddeclaration
28
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
congrArg
theorem congrArg {α : Sort u} {β : Sort v} {a₁ a₂ : α} (f : α → β) (h : Eq a₁ a₂) : Eq (f a₁) (f a₂)
[ 347, 1 ]
[ 358, 10 ]
commanddeclaration
29
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
congr
theorem congr {α : Sort u} {β : Sort v} {f₁ f₂ : α → β} {a₁ a₂ : α} (h₁ : Eq f₁ f₂) (h₂ : Eq a₁ a₂) : Eq (f₁ a₁) (f₂ a₂)
[ 360, 1 ]
[ 368, 16 ]
commanddeclaration
30
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
congrFun
theorem congrFun {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x} (h : Eq f g) (a : α) : Eq (f a) (g a)
[ 370, 1 ]
[ 372, 10 ]
commanddeclaration
31
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Quot.lcInv
unsafe axiom Quot.lcInv {α : Sort u} {r : α → α → Prop} (q : Quot r) : α
[ 463, 1 ]
[ 466, 73 ]
commanddeclaration
32
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
HEq
inductive HEq : {α : Sort u} → α → {β : Sort u} → β → Prop where | refl (a : α) : HEq a a
[ 468, 1 ]
[ 482, 27 ]
commanddeclaration
33
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
HEq.rfl
@[match_pattern] protected def HEq.rfl {α : Sort u} {a : α} : HEq a a := HEq.refl a
[ 484, 1 ]
[ 486, 13 ]
commanddeclaration
34
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
eq_of_heq
theorem eq_of_heq {α : Sort u} {a a' : α} (h : HEq a a') : Eq a a'
[ 488, 1 ]
[ 493, 22 ]
commanddeclaration
35
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Prod
structure Prod (α : Type u) (β : Type v) where mk :: fst : α snd : β
[ 495, 1 ]
[ 510, 10 ]
commanddeclaration
36
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PProd
structure PProd (α : Sort u) (β : Sort v) where fst : α snd : β
[ 514, 1 ]
[ 524, 10 ]
commanddeclaration
37
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
MProd
structure MProd (α β : Type u) where fst : α snd : β
[ 526, 1 ]
[ 535, 10 ]
commanddeclaration
38
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
And
@[pp_using_anonymous_constructor] structure And (a b : Prop) : Prop where intro :: left : a right : b
[ 537, 1 ]
[ 551, 12 ]
commanddeclaration
39
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or
inductive Or (a b : Prop) : Prop where | inl (h : a) : Or a b | inr (h : b) : Or a b
[ 553, 1 ]
[ 563, 25 ]
commanddeclaration
40
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.intro_left
theorem Or.intro_left (b : Prop) (h : a) : Or a b
[ 565, 1 ]
[ 567, 11 ]
commanddeclaration
41
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.intro_right
theorem Or.intro_right (a : Prop) (h : b) : Or a b
[ 569, 1 ]
[ 571, 11 ]
commanddeclaration
42
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.elim
theorem Or.elim {c : Prop} (h : Or a b) (left : a → c) (right : b → c) : c
[ 573, 1 ]
[ 580, 24 ]
commanddeclaration
43
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.resolve_left
theorem Or.resolve_left (h: Or a b) (na : Not a) : b
[ 582, 1 ]
[ 582, 81 ]
commanddeclaration
44
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.resolve_right
theorem Or.resolve_right (h: Or a b) (nb : Not b) : a
[ 583, 1 ]
[ 583, 81 ]
commanddeclaration
45
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.neg_resolve_left
theorem Or.neg_resolve_left (h : Or (Not a) b) (ha : a) : b
[ 584, 1 ]
[ 584, 86 ]
commanddeclaration
46
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Or.neg_resolve_right
theorem Or.neg_resolve_right (h : Or a (Not b)) (nb : b) : a
[ 585, 1 ]
[ 585, 86 ]
commanddeclaration
47
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool
inductive Bool : Type where | false : Bool | true : Bool
[ 587, 1 ]
[ 599, 16 ]
commanddeclaration
48
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Subtype
@[pp_using_anonymous_constructor] structure Subtype {α : Sort u} (p : α → Prop) where val : α property : p val
[ 603, 1 ]
[ 628, 19 ]
commanddeclaration
49
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
optParam
@[reducible] def optParam (α : Sort u) (default : α) : Sort u := α
[ 631, 1 ]
[ 638, 67 ]
commanddeclaration
50
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
outParam
@[reducible] def outParam (α : Sort u) : Sort u := α
[ 640, 1 ]
[ 656, 53 ]
commanddeclaration
51
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
semiOutParam
@[reducible] def semiOutParam (α : Sort u) : Sort u := α
[ 658, 1 ]
[ 679, 57 ]
commanddeclaration
52
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
namedPattern
@[reducible] def namedPattern {α : Sort u} (x a : α) (h : Eq x a) : α := a
[ 682, 1 ]
[ 683, 75 ]
commanddeclaration
53
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
sorryAx
@[extern "lean_sorry", never_extract] axiom sorryAx (α : Sort u) (synthetic : Bool) : α
[ 685, 1 ]
[ 701, 50 ]
commanddeclaration
54
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
eq_false_of_ne_true
theorem eq_false_of_ne_true : {b : Bool} → Not (Eq b true) → Eq b false
[ 703, 1 ]
[ 705, 20 ]
commanddeclaration
55
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
eq_true_of_ne_false
theorem eq_true_of_ne_false : {b : Bool} → Not (Eq b false) → Eq b true
[ 707, 1 ]
[ 709, 35 ]
commanddeclaration
56
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ne_false_of_eq_true
theorem ne_false_of_eq_true : {b : Bool} → Eq b true → Not (Eq b false)
[ 711, 1 ]
[ 713, 35 ]
commanddeclaration
57
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ne_true_of_eq_false
theorem ne_true_of_eq_false : {b : Bool} → Eq b false → Not (Eq b true)
[ 715, 1 ]
[ 717, 44 ]
commanddeclaration
58
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Inhabited
class Inhabited (α : Sort u) where default : α
[ 719, 1 ]
[ 734, 14 ]
commanddeclaration
59
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Nonempty
class inductive Nonempty (α : Sort u) : Prop where | intro (val : α) : Nonempty α
[ 738, 1 ]
[ 748, 33 ]
commanddeclaration
60
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Classical.choice
axiom Classical.choice {α : Sort u} : Nonempty α → α
[ 750, 1 ]
[ 772, 53 ]
commanddeclaration
61
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Nonempty.elim
protected theorem Nonempty.elim {α : Sort u} {p : Prop} (h₁ : Nonempty α) (h₂ : α → p) : p
[ 774, 1 ]
[ 782, 20 ]
commanddeclaration
62
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Classical.ofNonempty
noncomputable def Classical.ofNonempty {α : Sort u} [Nonempty α] : α := Classical.choice inferInstance
[ 787, 1 ]
[ 792, 33 ]
commanddeclaration
63
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Pi.instNonempty
instance Pi.instNonempty {α : Sort u} {β : α → Sort v} [(a : α) → Nonempty (β a)] : Nonempty ((a : α) → β a) := Nonempty.intro fun _ => Classical.ofNonempty
[ 797, 1 ]
[ 799, 47 ]
commanddeclaration
64
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Pi.instInhabited
instance Pi.instInhabited {α : Sort u} {β : α → Sort v} [(a : α) → Inhabited (β a)] : Inhabited ((a : α) → β a) where default := fun _ => default
[ 807, 1 ]
[ 809, 30 ]
commanddeclaration
65
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PLift
structure PLift (α : Sort u) : Type u where up :: down : α
[ 813, 1 ]
[ 832, 11 ]
commanddeclaration
66
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PLift.up_down
theorem PLift.up_down {α : Sort u} (b : PLift α) : Eq (up (down b)) b
[ 834, 1 ]
[ 835, 77 ]
commanddeclaration
67
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
PLift.down_up
theorem PLift.down_up {α : Sort u} (a : α) : Eq (down (up a)) a
[ 837, 1 ]
[ 838, 71 ]
commanddeclaration
68
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
NonemptyType
def NonemptyType := Subtype fun α : Type u => Nonempty α
[ 840, 1 ]
[ 846, 57 ]
commanddeclaration
69
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
NonemptyType.type
abbrev NonemptyType.type (type : NonemptyType.{u}) : Type u := type.val
[ 848, 1 ]
[ 850, 11 ]
commanddeclaration
70
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ULift
structure ULift.{r, s} (α : Type s) : Type (max s r) where up :: down : α
[ 856, 1 ]
[ 881, 11 ]
commanddeclaration
71
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ULift.up_down
theorem ULift.up_down {α : Type u} (b : ULift.{v} α) : Eq (up (down b)) b
[ 883, 1 ]
[ 884, 81 ]
commanddeclaration
72
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ULift.down_up
theorem ULift.down_up {α : Type u} (a : α) : Eq (down (up.{v} a)) a
[ 886, 1 ]
[ 887, 75 ]
commanddeclaration
73
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Decidable
class inductive Decidable (p : Prop) where | isFalse (h : Not p) : Decidable p | isTrue (h : p) : Decidable p
[ 889, 1 ]
[ 907, 33 ]
commanddeclaration
74
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Decidable.decide
@[inline_if_reduce, nospecialize] def Decidable.decide (p : Prop) [h : Decidable p] : Bool := h.casesOn (fun _ => false) (fun _ => true)
[ 909, 1 ]
[ 916, 45 ]
commanddeclaration
75
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
DecidablePred
abbrev DecidablePred {α : Sort u} (r : α → Prop) := (a : α) → Decidable (r a)
[ 920, 1 ]
[ 926, 28 ]
commanddeclaration
76
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
DecidableRel
abbrev DecidableRel {α : Sort u} {β : Sort v} (r : α → β → Prop) := (a : α) → (b : β) → Decidable (r a b)
[ 928, 1 ]
[ 934, 40 ]
commanddeclaration
77
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
DecidableEq
abbrev DecidableEq (α : Sort u) := (a b : α) → Decidable (Eq a b)
[ 936, 1 ]
[ 943, 33 ]
commanddeclaration
78
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
decEq
def decEq {α : Sort u} [inst : DecidableEq α] (a b : α) : Decidable (Eq a b) := inst a b
[ 945, 1 ]
[ 949, 11 ]
commanddeclaration
79
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
decide_eq_true
theorem decide_eq_true : [inst : Decidable p] → p → Eq (decide p) true
[ 952, 1 ]
[ 954, 35 ]
commanddeclaration
80
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
decide_eq_false
theorem decide_eq_false : [Decidable p] → Not p → Eq (decide p) false
[ 956, 1 ]
[ 958, 26 ]
commanddeclaration
81
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
of_decide_eq_true
theorem of_decide_eq_true [inst : Decidable p] : Eq (decide p) true → p
[ 960, 1 ]
[ 963, 70 ]
commanddeclaration
82
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
of_decide_eq_false
theorem of_decide_eq_false [inst : Decidable p] : Eq (decide p) false → Not p
[ 965, 1 ]
[ 968, 21 ]
commanddeclaration
83
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
of_decide_eq_self_eq_true
theorem of_decide_eq_self_eq_true [inst : DecidableEq α] (a : α) : Eq (decide (Eq a a)) true
[ 970, 1 ]
[ 973, 32 ]
commanddeclaration
84
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool.decEq
@[inline] def 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
[ 975, 1 ]
[ 986, 32 ]
commanddeclaration
85
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
BEq
class BEq (α : Type u) where beq : α → α → Bool
[ 991, 1 ]
[ 1004, 21 ]
commanddeclaration
86
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
dite
@[macro_inline] def dite {α : Sort u} (c : Prop) [h : Decidable c] (t : c → α) (e : Not c → α) : α := h.casesOn e t
[ 1012, 1 ]
[ 1027, 16 ]
commanddeclaration
87
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
ite
@[macro_inline] def ite {α : Sort u} (c : Prop) [h : Decidable c] (t e : α) : α := h.casesOn (fun _ => e) (fun _ => t)
[ 1031, 1 ]
[ 1052, 38 ]
commanddeclaration
88
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
cond
@[macro_inline] def cond {α : Sort u} (c : Bool) (x y : α) : α := match c with | true => x | false => y
[ 1081, 1 ]
[ 1094, 15 ]
commanddeclaration
89
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool.dcond
@[macro_inline] protected def Bool.dcond {α : Sort u} (c : Bool) (x : Eq c true → α) (y : Eq c false → α) : α := match c with | true => x rfl | false => y rfl
[ 1097, 1 ]
[ 1115, 19 ]
commanddeclaration
90
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool.or
@[macro_inline] def Bool.or (x y : Bool) : Bool := match x with | true => true | false => y
[ 1117, 1 ]
[ 1129, 15 ]
commanddeclaration
91
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool.and
@[macro_inline] def Bool.and (x y : Bool) : Bool := match x with | false => false | true => y
[ 1131, 1 ]
[ 1143, 15 ]
commanddeclaration
92
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Bool.not
@[inline] def Bool.not : Bool → Bool | true => false | false => true
[ 1145, 1 ]
[ 1153, 18 ]
commanddeclaration
93
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
Nat
inductive Nat where | zero : Nat | succ (n : Nat) : Nat
[ 1157, 1 ]
[ 1178, 25 ]
commanddeclaration
94
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
OfNat
class OfNat (α : Type u) (_ : Nat) where ofNat : α
[ 1183, 1 ]
[ 1200, 12 ]
commanddeclaration
95
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
instOfNatNat
@[default_instance 100] instance instOfNatNat (n : Nat) : OfNat Nat n where ofNat := n
[ 1202, 1 ]
[ 1204, 13 ]
commanddeclaration
96
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
LE
class LE (α : Type u) where le : α → α → Prop
[ 1206, 1 ]
[ 1209, 20 ]
commanddeclaration
97
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
LT
class LT (α : Type u) where lt : α → α → Prop
[ 1211, 1 ]
[ 1214, 20 ]
commanddeclaration
98
.lake/packages/lean4/src/lean/Init/Prelude.lean
[]
GE.ge
@[reducible] def GE.ge {α : Type u} [LE α] (a b : α) : Prop := LE.le b a
[ 1216, 1 ]
[ 1217, 73 ]
commanddeclaration
99
End of preview. Expand in Data Studio
README.md exists but content is empty.
Downloads last month
14
Size of downloaded dataset files:
25.7 MB
Size of the auto-converted Parquet files:
25.7 MB
Number of rows:
248,893