Datasets:

phanerozoic
/

Arend

statement stringlengths 3 4.77k	proof stringlengths 0 85.5k	type stringclasses 11 values	symbolic_name stringlengths 1 48	library stringclasses 53 values	filename stringclasses 279 values	imports listlengths 0 45	deps listlengths 0 64	source_url stringclasses 1 value	commit stringclasses 1 value
Precat (Ob : \hType obj)	{ \| Hom : Ob -> Ob -> \Set hom \| id (X : Ob) : Hom X X \| \fixl 8 o \alias \infixl 8 ∘ {X Y Z : Ob} : Hom Y Z -> Hom X Y -> Hom X Z \| id-left {X Y : Ob} {f : Hom X Y} : id Y ∘ f = f \| id-right {X Y : Ob} {f : Hom X Y} : f ∘ id X = f \| o-assoc {X Y Z W : Ob} {h : Hom Z W} {g : Hom Y Z} {f : Hom X Y} : (h ∘ g)...	\class	Precat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Iso", "Set", "id", "idIso", "inv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
SmallPrecat	=> Precat \lp \open Precat (>>)	\meta	SmallPrecat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Precat" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Map	{C : Precat} {dom cod : C} (\coerce f : Hom dom cod)	\record	Map	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Precat" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Mono	\extends Map \| isMono {x : C} {g h : Hom x dom} : f ∘ g = f ∘ h -> g = h \where { \func comp {C : Precat} {x y z : C} (g : Mono {C} {y} {z}) (f : Mono {C} {x} {y}) : Mono {C} {x} {z} (g.f ∘ f) \cowith \| isMono p => f.isMono (g.isMono (inv o-assoc > p > o-assoc)) }	\record	Mono	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "Map", "Precat", "inv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isEpi {C : Precat} {x y : C} (f : Hom x y)	=> \Pi {z : C} {g h : Hom y z} -> g ∘ f = h ∘ f -> g = h	\func	isEpi	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Precat" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
SplitMono	\extends Mono { \| hinv : Hom cod dom \| hinv_f : hinv ∘ f = id dom \| isMono {_} {g} {h} gf=hf => g ==< inv id-left >== g >> id dom ==< pmap (g >>) (inv hinv_f) >== g >> (f >> hinv) ==< o-assoc >== (g >> f) >> hinv ==< pmap (o hinv) gf=hf >== (h >> f) >> hinv ==< inv o-assoc >=...	\record	SplitMono	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "==<", ">==", "Mono", "id", "inv", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Iso	\extends SplitMono { \| f_hinv : f ∘ hinv = id cod \lemma adjointInv {z : C} {g : Hom z dom} {h : Hom z cod} (p : g = hinv ∘ h) : f ∘ g = h => pmap (f ∘) p > inv o-assoc > pmap (`∘ h) f_hinv *> id-left \lemma adjoint' {z : C} {g : Hom cod z} {h : Hom dom z} (p : g ∘ f = h) : g = h ∘ hinv => inv id-right...	\record	Iso	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "-o_Equiv", "Equiv", "Mono", "Precat", "QEquiv", "SplitMono", "id", "inv", "isEpi", "levelProp", "o-_Equiv", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
idIso {C : Precat} {x : C} : Iso (id x)	\cowith \| hinv => id x \| f_hinv => id-left \| hinv_f => id-right	\func	idIso	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Iso", "Precat", "id" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Cat	\extends Precat { \| univalence {a b : Ob} : Equiv (idtoiso {_} {a} {b}) \func op : Cat \cowith \| Precat => Precat.op \| univalence => univalenceFromEquiv {Precat.op} (\lam {a} {b} => transEquiv univalence $ later \new QEquiv { \| f (e : Iso) => e.op.reverse \| ret (e : Iso) => e.op.reverse \|...	\class	Cat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "Equiv", "Functor", "Iso", "Jl", "Precat", "QEquiv", "Retraction", "id", "idpe", "inv", "pathEquiv", "pmap", "transEquiv", "transport", "univalence" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
SmallCat	=> Cat \lp	\meta	SmallCat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Cat" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
DiscretePrecat (X : \Type) : Precat X	\cowith \| Hom x y => Trunc0 (x = y) \| id x => in0 idp \| o {x y z : X} (t : Trunc0 (y = z)) (s : Trunc0 (x = y)) : Trunc0 (x = z) \elim t, s { \| in0 y=z, in0 x=y => in0 (x=y > y=z) } \| id-left {_} {_} {p} => cases p idp \| id-right {_} {_} {p} => cases p (pmap in0 (idp_> _)) \| o-assoc {_} {_} {_} {_} ...	\func	DiscretePrecat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ ">", ">-assoc", "Precat", "Trunc0", "id", "idp_*>", "inv", "map", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
SIP (C : Cat) (Str : C -> \hType (\suc \lp)) (isHom : \Pi {x y : C} -> Str x -> Str y -> Hom x y -> \hType (\suc \lp)) (st : \Pi {X : C} {S1 S2 : Str X} -> isHom S1 S2 (id X) -> isHom S2 S1 (id X) -> S1 = S2) {X Y : C} (e : Iso {C} {X} {Y}) (S1 : Str X) (S2 : Str Y) (p : isHom S1 S2 e) (q : isHom ...	=> \case \elim Y, \elim e, \elim S2, p, q, Cat.univalenceToTransport e \with { \| Y, e : Iso, S2, p, q, (idp,s) => (idp, st (transportInv (isHom S1 S2) s p) (transport (isHom S2 S1) (inv id-right > pmap (∘ e.hinv) s > e.hinv_f) q), s) }	\sfunc	SIP	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "Cat", "Iso", "id", "inv", "pmap", "transport", "transportInv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Graph (\coerce V : \Set) (E : V -> V -> \Set)	{ \data Paths (x y : V) \| empty (x = y) \| cons {z : V} (E x z) (Paths z y) \func concat {x y z : V} (p : Paths x y) (q : Paths y z) : Paths x z \elim p \| empty idp => q \| cons e p => cons e (concat p q) \lemma concat_idp {x y : V} {p : Paths x y} : concat p (empty idp) = p \elim p \| empty id...	\class	Graph	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Cat", "Set", "concat", "id", "inv", "pmap", "univalence" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
TrivialCat : Cat	=> Graph.FreeCat {\new Graph (\Sigma) (\lam _ _ => Empty)}	\func	TrivialCat	src	src/Category.ard	[ "Algebra.Meta", "Category.Functor", "Equiv", "Equiv.Path", "Function.Meta", "Logic", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Cat", "Empty", "Graph" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
runTimed m	=> run { \let t => time, \let x => nf m, println (time Nat.- t), x }	\meta	runTimed	src	src/Debug.ard	[ "Debug.Meta", "Meta" ]	[ "-" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Map	{A B : \Type} (\coerce f : A -> B)	\record	Map	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Section	\extends Map \| ret : B -> A \| ret_f : \Pi (x : A) -> ret (f x) = x \where { \func =Fiber {A B : \Type} (f : A -> B) : Section f = Fib (-o f) id => path (iso (\lam (s : Section f) => Fib.make s.ret (path (\lam i x => s.ret_f x @ i))) (\lam z => \new Section f z.1 (\lam x => path ((z.2 ...	\record	Section	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "-o", "-o_Equiv", "Contr", "Equiv", "Equiv=>contrFibers", "Fib", "Map", "Retraction", "id", "idpe", "isContr=>isProp", "isProp", "levelProp", "make" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Retraction	\extends Map \| sec : B -> A \| f_sec : \Pi (y : B) -> f (sec y) = y \where { \func =Fiber {A B : \Type} (f : A -> B) : Retraction f = Fib (f `o-) id => path (iso (\lam (s : Retraction f) => Fib.make s.sec (path (\lam i x => s.f_sec x @ i))) (\lam z => \new Retraction f z.1 (\lam x => p...	\record	Retraction	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Contr", "Equiv", "Equiv=>contrFibers", "Fib", "Map", "Section", "id", "idpe", "isContr=>isProp", "isProp", "levelProp", "make", "o-_Equiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Equiv	\extends Section, Retraction { \func f_ret (y : B) : f (ret y) = y => pmap (\lam y => f (ret y)) (inv (f_sec y)) > pmap f (ret_f (sec y)) > f_sec y \func isInj {a a' : A} (p : f a = f a') : a = a' => inv (ret_f a) > pmap ret p > ret_f a' \lemma isSurj : Function.isSurj f => \lam y => inP (ret y,...	\record	Equiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "*>", "ESEquiv", "Embedding", "Retraction", "Section", "Set", "inv", "isContr=>isProp", "isInj", "isSurj", "levelProp", "pathOver", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
QEquiv	\extends Equiv { \| sec => ret } \where { \use \coerce fromEquiv (e : Equiv) : QEquiv \cowith \| Section => e \| f_sec => e.f_ret \func fromEquiv' (e : Equiv) : QEquiv \cowith \| Map => e \| ret => e.sec \| ret_f a => inv (e.ret_f (e.sec (e a))) > pmap e.ret (e.f_sec (e a)) > e.ret_...	\record	QEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "*>", "Equiv", "Map", "Section", "inv", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
idEquiv {A : \Type} : QEquiv	\cowith \| A => A \| B => A \| f x => x \| ret x => x \| ret_f _ => idp \| f_sec _ => idp	\func	idEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "QEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
symQEquiv {A B : \Type} (e : QEquiv {A} {B}) : QEquiv	{B} {A} \cowith \| f => e.ret \| ret => e.f \| ret_f => e.f_sec \| f_sec => e.ret_f	\func	symQEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "QEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
transQEquiv {A B C : \Type} (e1 : QEquiv {A} {B}) (e2 : QEquiv {B} {C}) : QEquiv	{A} {C} \cowith \| f x => e2 (e1 x) \| ret y => e1.ret (e2.ret y) \| ret_f x => pmap e1.ret (e2.ret_f (e1 x)) > e1.ret_f x \| f_sec y => pmap e2 (e1.f_sec (e2.sec y)) > e2.f_sec y \module TwoOutOfThree \where { \func leftFactor {A B C : \Type} (e1 : Retraction {A} {B}) (g : B -> C) (e3 : QEquiv (g `o` e1)) : Q...	\func	transQEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "*>", "==<", ">->", ">==", "ESEquiv", "Equiv", "QEquiv", "Retraction", "Section", "inv", "pmap", "propExt", "transEquiv", "transportInv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
transEquiv {A B C : \Type} (e1 : Equiv {A} {B}) (e2 : Equiv {B} {C}) : Equiv	{A} {C} \cowith \| f x => e2 (e1 x) \| ret y => e1.ret (e2.ret y) \| ret_f x => pmap e1.ret (e2.ret_f (e1 x)) > e1.ret_f x \| sec y => e1.sec (e2.sec y) \| f_sec y => pmap e2 (e1.f_sec (e2.sec y)) > e2.f_sec y	\func	transEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "*>", "Equiv", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
-o_Equiv {C : \Type} (e : Equiv) : Equiv	{e.B -> C} {e.A -> C} (-o e) \cowith \| ret => -o e.sec \| ret_f g => path (\lam i x => g (e.f_sec x @ i)) \| sec => -o e.ret \| f_sec g => path (\lam i x => g (e.ret_f x @ i))	\func	-o_Equiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "-o", "Equiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
o-_Equiv {C : \Type} (e : Equiv) : Equiv	{C -> e.A} (e `o-) \cowith \| ret => e.ret `o- \| ret_f g => path (\lam i x => e.ret_f (g x) @ i) \| sec => e.sec `o- \| f_sec g => path (\lam i x => e.f_sec (g x) @ i)	\func	o-_Equiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Equiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
piEquiv {A : \Type} (B : A -> \Type) (f f' : \Pi (a : A) -> B a) : QEquiv	\cowith \| A => f = f' \| B => \Pi (a : A) -> f a = f' a \| f p a => path ((p @ __) a) \| ret g => path (\lam i a => g a @ i) \| ret_f _ => idp \| f_sec _ => idp	\func	piEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "QEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
sigmaEquiv {A : \Type} (B : A -> \Type) (p p' : \Sigma (a : A) (B a)) : QEquiv	\cowith \| A => p = p' \| B => \Sigma (s : p.1 = p'.1) (transport B s p.2 = p'.2) \| f q => (pmap __.1 q, pmapd __.2 q) \| ret q => ext q \| ret_f q => Jl (\lam p'' q' => ext (pmap __.1 q', pmapd __.2 q') = q') idp q \| f_sec q => ext (idp, \case p'.1 \as p'1 , q.1 \as q1 : p.1 = p'1, ...	\func	sigmaEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Jl", "QEquiv", "pmap", "pmapd", "transport" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
piSigmaEquiv {A A' : \Type} (h : A -> A') (B : A' -> \Type) : QEquiv	{\Pi (a : A) -> B (h a)} {\Sigma (g : A -> \Sigma (a' : A') (B a')) ((\lam a => (g a).1) = h)} \cowith \| f g => (\lam a => (h a, g a), idp) \| ret p => \lam a => transport B (path ((p.2 @ __) a)) (p.1 a).2 \| ret_f g => idp \| f_sec p => Jl (\lam (h' : A -> A') q => (\lam a => (h' a, transport B (path...	\func	piSigmaEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Jl", "QEquiv", "transport" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
piSigmaIdEquiv {A : \Type} (B : A -> \Type) : QEquiv	{\Pi (a : A) -> B a} {\Sigma (g : A -> \Sigma (a : A) (B a)) ((\lam a => (g a).1) = id)} => piSigmaEquiv id B	\func	piSigmaIdEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "QEquiv", "id", "piSigmaEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
emptyEquiv {A B : \Type} (Ae : A -> Empty) (Be : B -> Empty) : QEquiv	{A} {B} \cowith \| f a => absurd (Ae a) \| ret b => absurd (Be b) \| ret_f a => absurd (Ae a) \| f_sec b => absurd (Be b)	\func	emptyEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Empty", "QEquiv", "absurd" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Embedding	\extends Map { \| isEmb : \Pi (a a' : A) -> Retraction (pmap f {a} {a'}) \func pmap-isEquiv {a a' : A} : QEquiv (pmap f {a} {a'}) => pathEquiv (f __ = f __) (\lam {a} {a'} => isEmb a a') } \where { \use \level levelProp {A B : \Type} {f : A -> B} (e e' : Embedding f) : e = e' => path (\lam i => \new Embedding ...	\record	Embedding	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ ">", ">-assoc", "==<", ">==", "Equiv", "Fib", "Jl", "Map", "QEquiv", "Retraction", "Set", "equiv", "idpe", "inv", "inv_*>", "isProp", "levelProp", "pathEquiv", "pmap", "prop-pi", "transQEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
transEmbedding {A B C : \Type} (e1 : Embedding {A} {B}) (e2 : Embedding {B} {C}) : Embedding	{A} {C} \cowith \| f a => e2 (e1 a) \| isEmb a a' => \new Retraction { \| sec p => sec {e1.isEmb a a'} (sec {e2.isEmb (e1 a) (e1 a')} p) \| f_sec p => pmap (pmap e2) (f_sec {e1.isEmb a a'} (sec {e2.isEmb (e1 a) (e1 a')} p)) *> f_sec {e2.isEmb (e1 a) (e1 a')} p }	\func	transEmbedding	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "*>", "Embedding", "Retraction", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
>-> (A B : \Type)	=> Embedding {A} {B}	\func	>->	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Embedding" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Surjection	\extends Map \| isSurjMap (y : B) : ∃ (x : A) (f x = y)	\record	Surjection	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Map" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
->> (A B : \Type)	=> Surjection {A} {B}	\func	->>	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Surjection" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
ESEquiv	\extends Embedding, Surjection, Equiv \| ret y => (aux \this isSurjMap y).1 \| sec y => (aux \this isSurjMap y).1 \| ret_f x => sec {isEmb _ _} (aux \this isSurjMap (f x)).2 \| f_sec y => (aux \this isSurjMap y).2 \where { \use \level levelProp {A B : \Type} {f : A -> B} (e e' : ESEquiv f) : e = e' => p...	\record	ESEquiv	src	src/Equiv.ard	[ "Equiv.Fiber", "Equiv.Path", "Function", "HLevel", "Homotopy.Fibration", "Logic", "Logic.Meta", "Paths", "Paths.Meta" ]	[ "Embedding", "Equiv", "Surjection", "TruncP", "aux", "levelProp", "pmapEquiv", "prop-isProp", "remove" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
id {A : \Type}	=> \lam (x : A) => x	\func	id	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
-o {A B C : \Type} (f : A -> B)	=> \lam (g : B -> C) x => g (f x)	\func	-o	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
o- {A B C : \Type} (g : B -> C)	=> \lam (f : A -> B) x => g (f x)	\func	o-	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
o {A B C : \Type} (g : B -> C) (f : A -> B)	=> \lam x => g (f x)	\func	o	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
iterl {A : \Type} (f : A -> A) (n : Nat) (a : A) : A	\elim n \| 0 => a \| suc n => iterl f n (f a)	\func	iterl	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
iterr {A : \Type} (f : A -> A) (n : Nat) (a : A) : A	\elim n \| 0 => a \| suc n => f (iterr f n a)	\func	iterr	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
iterr-ind {A : \Type} {P : A -> \Type} {f : A -> A} {a0 : A} (p0 : P a0) (s : \Pi {a : A} -> P a -> P (f a)) (n : Nat) : P (iterr f n a0)	\elim n \| 0 => p0 \| suc n => s (iterr-ind p0 s n)	\func	iterr-ind	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[ "iterr" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
iterr-index-ind {A : \Type} {P : Nat -> A -> \Type} {f : A -> A} {a0 : A} (p0 : P 0 a0) (s : \Pi {n : Nat} {a : A} -> P n a -> P (suc n) (f a)) (n : Nat) : P n (iterr f n a0)	\elim n \| 0 => p0 \| suc n => s (iterr-index-ind p0 s n)	\func	iterr-index-ind	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[ "iterr" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isInj {A B : \Set} (f : A -> B)	=> \Pi {a a' : A} -> f a = f a' -> a = a'	\func	isInj	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[ "Set" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
iterr_inj {A : \Set} (f : A -> A) (inj : isInj f) (a : A) (n m : Nat) (p : n < m) (q : iterr f n a = iterr f m a) : a = iterr f (suc (pred (m -' n))) a	\elim n, m, p \| 0, suc m, NatSemiring.zero<suc => q \| suc n, suc m, NatSemiring.suc<suc p => iterr_inj f inj a n m p (inj q)	\lemma	iterr_inj	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[ "-'", "NatSemiring", "Set", "isInj", "iterr", "pred" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isSurj {A B : \Type} (f : A -> B)	=> \Pi (y : B) -> ∃ (x : A) (f x = y) \where { \lemma comp {A B C : \Type} {f : A -> B} (fs : isSurj f) {g : B -> C} (gs : isSurj g) : isSurj (g o f) => \lam z => \have \| (inP (y,gy=z)) => gs z \| (inP (x,fx=y)) => fs y \in inP (x, pmap g fx=y *> gy=z) }	\func	isSurj	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[ "*>", "pmap" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
assuming {A B : \Type} (f : (A -> B) -> B) (g : A -> B)	=> f g	\func	assuming	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Image {A B : \Type} (f : A -> B)	=> \Sigma (b : B) (∃ (a : A) (f a = b))	\type	Image	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
flip f a b	=> f b a	\meta	flip	src	src/Function.ard	[ "Arith.Nat", "Logic", "Logic.Meta", "Order.StrictOrder", "Paths" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isProp (A : \Type)	=> \Pi (a a' : A) -> a = a' \where \use \level levelProp (A : \Type) (e e' : isProp A) : e = e' => path (\lam i a a' => isProp=>isSet A e a a' (e a a') (e' a a') @ i)	\func	isProp	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isProp=>isSet", "levelProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
ofHLevel_-1+ (A : \Type) (n : Nat) : \Type	\elim n \| 0 => isProp A \| suc n => \Pi (a a' : A) -> (a = a') ofHLevel_-1+ n \where \use \level levelProp (A : \Type) (n : Nat) (e e' : A ofHLevel_-1+ n) : e = e' \elim n \| 0 => isProp.levelProp A e e' \| suc n => path (\lam i a a' => levelProp (a = a') n (e a a') (e' a a') @ i)	\func	ofHLevel_-1+	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isProp", "levelProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isProp=>isSet (A : \Type) (p : isProp A) (a a' : A) : isProp (a = a')	=> isContr=>isProp (isProp=>HLevel_-2+1 A p a a')	\func	isProp=>isSet	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isContr=>isProp", "isProp", "isProp=>HLevel_-2+1" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isSet (A : \Type)	=> A ofHLevel_-1+ 1	\func	isSet	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isGpd (A : \Type)	=> A ofHLevel_-1+ 2	\func	isGpd	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isSet=>isGpd (A : \Type) (p : isSet A) : isGpd A	=> \lam a a' => isProp=>isSet (a = a') (p a a')	\lemma	isSet=>isGpd	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isGpd", "isProp=>isSet", "isSet" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
hLevel-inh {A : \Type} (n : Nat) (f : A -> A ofHLevel_-1+ n) : A ofHLevel_-1+ n	\elim n \| 0 => \lam a => f a a \| suc n => \lam a => f a a	\func	hLevel-inh	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Contr (A : \Type) (center : A) (contraction : \Pi (a' : A) -> center = a')	\where { \func make {A : \Type} (a : A) (p : \Pi (a' : A) -> a = a') => \new Contr A a p \use \level levelProp (A : \Type) (c1 c2 : Contr A) : c1 = c2 => exts Contr { \| center => c1.contraction c2.center \| contraction a' => isProp=>isSet A (isContr=>isProp c1) c2.center a' _ _ } }	\class	Contr	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isContr=>isProp", "isProp=>isSet", "levelProp", "make" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
contr-equiv (A B : Contr) {f : A -> B} : Equiv f	=> \new QEquiv { \| ret _ => A.center \| ret_f x => A.contraction x \| f_sec y => isContr=>isProp B _ _ }	\lemma	contr-equiv	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "Equiv", "QEquiv", "isContr=>isProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isContr=>isProp {A : \Type} (c : Contr A) : isProp A	=> \lam a a' => inv (c.contraction a) *> c.contraction a'	\func	isContr=>isProp	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "*>", "Contr", "inv", "isProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isContr'=>isProp {A : \Type} (c : A -> Contr A) : isProp A	=> \lam a => isContr=>isProp (c a) a	\lemma	isContr'=>isProp	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "isContr=>isProp", "isProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isProp=>isContr {A : \Type} (p : isProp A) (a : A) : Contr A	=> Contr.make a (p a)	\lemma	isProp=>isContr	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "isProp", "make" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isProp'=>isContr {A : \Type} (p : isProp A) (a : TruncP A) : Contr A	\elim a \| inP a => isProp=>isContr p a	\lemma	isProp'=>isContr	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "TruncP", "isProp", "isProp=>isContr" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
I-isContr : Contr I	\cowith \| center => left \| contraction i => path (I.squeeze i)	\func	I-isContr	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
ofHLevel_-2+ (A : \Type) (n : Nat) : \Prop	\elim n \| 0 => Contr A \| suc n => \Pi (a a' : A) -> (a = a') ofHLevel_-2+ n	\func	ofHLevel_-2+	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-2+1=>HLevel_-1 (A : \Type) (n : Nat) (p : A ofHLevel_-2+ suc n) : A ofHLevel_-1+ n	\elim n \| 0 => \lam a a' => Contr.center {p a a'} \| suc n => \lam a a' => HLevel_-2+1=>HLevel_-1 (a = a') n (p a a')	\func	HLevel_-2+1=>HLevel_-1	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "ofHLevel_-1+", "ofHLevel_-2+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
isProp=>HLevel_-2+1 (A : \Type) (p : isProp A) (a a' : A) : Contr (a = a')	=> \new Contr (a = a') { \| center => inv (p a a) > p a a' \| contraction => Jl (\lam x q => inv (p a a) > p a x = q) (inv_*> (p a a)) }	\func	isProp=>HLevel_-2+1	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ ">", "Contr", "Jl", "inv", "inv_>", "isProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-1=>HLevel_-2+1 (A : \Type) (n : Nat) (p : A ofHLevel_-1+ n) : A ofHLevel_-2+ suc n	\elim n \| 0 => isProp=>HLevel_-2+1 A p \| suc n => \lam a a' => HLevel_-1=>HLevel_-2+1 (a = a') n (p a a')	\lemma	HLevel_-1=>HLevel_-2+1	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isProp=>HLevel_-2+1", "ofHLevel_-1+", "ofHLevel_-2+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-1_suc {A : \Type} {n : Nat} (p : A ofHLevel_-1+ n) : A ofHLevel_-1+ suc n	\elim n \| 0 => isProp=>isSet A p \| suc n => \lam a a' => HLevel_-1_suc (p a a')	\func	HLevel_-1_suc	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "isProp=>isSet", "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-1_+ {A : \Type} {k : Nat} (n : Nat) (p : A ofHLevel_-1+ k) : A ofHLevel_-1+ k + n	\elim n \| 0 => p \| suc n => HLevel_-1_suc (HLevel_-1_+ n p)	\func	HLevel_-1_+	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "HLevel_-1_suc", "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-1_<= {A : \Type} (k : Nat) (n : Nat) (q : k <= n) (p : A ofHLevel_-1+ k) : A ofHLevel_-1+ n	=> rewriteI (<=_exists q) (HLevel_-1_+ (n -' k) p)	\func	HLevel_-1_<=	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "-'", "<=_exists", "HLevel_-1_+", "ofHLevel_-1+" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel-retracts (s : Section) {n : Nat} (p : s.B ofHLevel_-1+ n) : s.A ofHLevel_-1+ n	\elim n \| 0 => \lam a a' => inv (s.ret_f a) > pmap s.ret (p (s a) (s a')) > s.ret_f a' \| suc n => \lam a a' => HLevel-retracts (pmapSection s) (p (s a) (s a'))	\func	HLevel-retracts	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "*>", "Section", "inv", "ofHLevel_-1+", "pmap", "pmapSection" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevels-pi {A : \Type} (B : A -> \Type) {n : Nat} (p : \Pi (a : A) -> B a ofHLevel_-1+ n) : (\Pi (a : A) -> B a) ofHLevel_-1+ n	\elim n \| 0 => \lam f f' => path (\lam i a => p a (f a) (f' a) @ i) \| suc n => \lam f f' => HLevel-retracts (piEquiv B f f') (HLevels-pi (\lam a => f a = f' a) (\lam a => p a (f a) (f' a)))	\func	HLevels-pi	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "HLevel-retracts", "ofHLevel_-1+", "piEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevels-sigma {A : \Type} (B : A -> \Type) {n : Nat} (pA : A ofHLevel_-1+ n) (pB : \Pi (a : A) -> B a ofHLevel_-1+ n) : (\Sigma (a : A) (B a)) ofHLevel_-1+ n	\elim n \| 0 => \lam p p' => ext (pA p.1 p'.1, pB p'.1 _ _) \| suc n => \lam p p' => HLevel-retracts (sigmaEquiv B p p') (HLevels-sigma (transport B __ p.2 = p'.2) (pA p.1 p'.1) (\lam s => pB _ _ _))	\func	HLevels-sigma	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "HLevel-retracts", "ofHLevel_-1+", "sigmaEquiv", "transport" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevels-embeddings (e : Embedding) {n : Nat} (p : e.B ofHLevel_-1+ n) : e.A ofHLevel_-1+ n	\elim n \| 0 => \lam a a' => sec {e.isEmb a a'} (p (e a) (e a')) \| suc n => \lam a a' => HLevels-embeddings (pmapEmbedding e) (p (e a) (e a'))	\func	HLevels-embeddings	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Embedding", "ofHLevel_-1+", "pmapEmbedding" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevel_-2-retracts (s : Section) {n : Nat} (p : s.B ofHLevel_-2+ n) : s.A ofHLevel_-2+ n	\elim n \| 0 => \have a0 => s.ret (Contr.center {p}) \in Contr.make a0 (\lam a => inv (s.ret_f a0) > pmap s.ret (isContr=>isProp p (s a0) (s a)) > s.ret_f a) \| suc n => \lam a a' => HLevel_-2-retracts (pmapSection s) (p (s a) (s a'))	\lemma	HLevel_-2-retracts	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "*>", "Contr", "Section", "inv", "isContr=>isProp", "make", "ofHLevel_-2+", "pmap", "pmapSection" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevels_-2-pi {A : \Type} (B : A -> \Type) {n : Nat} (p : \Pi (a : A) -> B a ofHLevel_-2+ n) : (\Pi (a : A) -> B a) ofHLevel_-2+ n	\elim n \| 0 => Contr.make (\lam a => Contr.center {p a}) (\lam f => path (\lam i a => Contr.contraction {p a} (f a) @ i)) \| suc n => \lam f f' => HLevel_-2-retracts (piEquiv B f f') (HLevels_-2-pi (\lam a => f a = f' a) (\lam a => p a (f a) (f' a)))	\lemma	HLevels_-2-pi	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "HLevel_-2-retracts", "make", "ofHLevel_-2+", "piEquiv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
HLevels_-2-sigma {A : \Type} (B : A -> \Type) {n : Nat} (pA : A ofHLevel_-2+ n) (pB : \Pi (a : A) -> B a ofHLevel_-2+ n) : (\Sigma (a : A) (B a)) ofHLevel_-2+ n	\elim n \| 0 => \let \| a0 => Contr.center {pA} \| p0 => ((a0, Contr.center {pB a0}) : \Sigma (a : A) (B a)) \in Contr.make p0 (\lam p => ext (Contr.contraction {pA} p.1, isContr=>isProp (pB p.1) _ _)) \| suc n => \lam p p' => HLevel_-2-retracts (sigmaEquiv B p p') (HLevels_-2-sigma (transport B ...	\lemma	HLevels_-2-sigma	src	src/HLevel.ard	[ "Arith.Nat", "Equiv", "Equiv.Path", "Logic", "Order.PartialOrder", "Paths", "Paths.Meta" ]	[ "Contr", "HLevel_-2-retracts", "isContr=>isProp", "make", "ofHLevel_-2+", "sigmaEquiv", "transport" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Empty		\data	Empty	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
absurd	{A : \Type} (x : Empty) : A	\func	absurd	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Empty" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
Not (A : \Type)	=> A -> Empty	\func	Not	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Empty" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
/= {A : \Type} (a a' : A)	=> Not (a = a')	\func	/=	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Not" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
/=-sym {A : \Type} {a a' : A} (p : a /= a') : a' /= a	=> \lam r => p (inv r)	\lemma	/=-sym	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "/=", "inv" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
TruncP (A : \Type)	\| inP A \| truncP (a a' : TruncP A) : a = a' \where { \use \level levelProp {A : \Type} (a a' : TruncP A) : a = a' => path (truncP a a') \lemma remove {A : \Type} (p : isProp A) (t : TruncP A) : A \elim t \| inP a => a \lemma remove' {A : \Prop} (t : TruncP A) : A \elim t \| inP a => a \...	\data	TruncP	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "*>", "Set", "inv", "isProp", "isProp=>isSet", "levelProp", "map", "remove" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
prop-pi {A : \Prop} {a a' : A} : a = a'	=> \case truncP (inP a) (inP a') __ \with { \| inP x => x }	\lemma	prop-pi	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
prop-isProp {A : \Prop} : isProp A	=> \lam _ _ => prop-pi	\lemma	prop-isProp	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "isProp", "prop-pi" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
set-pi {A : \Set} {a b : A} {p q : a = b} : p = q	=> prop-pi	\lemma	set-pi	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Set", "prop-pi" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
prop-dpi (A : I -> \Prop) (a : A left) (a' : A right) : Path A a a'	=> pathOver (prop-isProp (coe A a right) a')	\lemma	prop-dpi	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "pathOver", "prop-isProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
ToProp (A : \Type) (p : isProp A)	\| toProp A \where { \lemma fromProp {A : \Type} {p : isProp A} (t : ToProp A p) : A \elim t \| toProp a => a \use \level levelProp : \Prop } \truncated	\data	ToProp	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "isProp", "levelProp" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
\|\| (A B : \Type) : \Prop	\| byLeft A \| byRight B \where { \lemma rec {A B C : \Type} (p : isProp C) (f : A -> C) (g : B -> C) (t : A \|\| B) : C \elim t \| byLeft a => f a \| byRight b => g b \lemma rec' {A B : \Type} {C : \Prop} (f : A -> C) (g : B -> C) (t : A \|\| B) : C \elim t \| byLeft a => f a \| byRight b =>...	\data	\|\|	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "Or", "TruncP", "isProp", "map" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
<-> (P Q : \Prop)	=> \Sigma (P -> Q) (Q -> P)	\func	<->	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
<->_= {P Q : \Prop} : (P <-> Q) <-> (P = Q)	=> (\lam p => ext p, \lam p => rewrite p (\lam x => x, \lam x => x))	\lemma	<->_=	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "<->" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
<->refl {P : \Prop} : P <-> P	=> (\lam p => p, \lam p => p)	\lemma	<->refl	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "<->" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
<->trans {P Q S : \Prop} (f : P <-> Q) (g : Q <-> S) : P <-> S	=> (\lam p => g.1 (f.1 p), \lam s => f.2 (g.2 s))	\lemma	<->trans	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "<->" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
<->sym {P Q : \Prop} (f : P <-> Q) : Q <-> P	=> (f.2,f.1)	\lemma	<->sym	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "<->" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
OneOf (l : Array \Type)	=> ∃ (P : l) P	\func	OneOf	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
ElemOf (l : Array \Type)	=> Given (P : l) P	\func	ElemOf	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
arraySubset {X : \Type} (l : Array X) (x : X)	=> ∃ (y : l) (y = x)	\type	arraySubset	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4
propExt {A B : \Prop} (f : A -> B) (g : B -> A) : A = B	=> path (iso f g (\lam _ => prop-pi) (\lam _ => prop-pi)) \where { \lemma dir {A B : \Prop} (p : A = B) (a : A) : B => transport (\lam X => X) p a \lemma conv {A B : \Prop} (p : A = B) (b : B) : A => dir (inv p) b }	\lemma	propExt	src	src/Logic.ard	[ "Arith.Nat", "Data.Array", "Data.Bool", "Data.Fin", "Data.List", "Data.Or", "Function.Meta", "HLevel", "Logic.Meta", "Meta", "Paths", "Paths.Meta", "Set" ]	[ "conv", "inv", "prop-pi", "transport" ]	https://github.com/JetBrains/arend-lib	373ed3c493f40a6b7b04a6b81c4e809338e568c4

End of preview. Expand in Data Studio

Arend

Declarations from Arend.

Source

Repository: https://github.com/JetBrains/arend-lib
Commit: 373ed3c493f40a6b7b04a6b81c4e809338e568c4
Files: 280
License: other

Schema

Column	Type	Description
statement	string	Declaration signature/claim with the leading keyword removed (verbatim slice); the full declaration minus its proof
proof	string	Verbatim proof/body, empty if the declaration has none
type	string	Declaration keyword
symbolic_name	string	Declaration identifier
library	string	Sub-library
filename	string	Repository-relative source path
imports	list[string]	File-level `Require`/`Import` modules
deps	list[string]	Intra-corpus identifiers referenced
docstring	string	Preceding documentation comment, empty if absent
source_url	string	Upstream repository
commit	string	Upstream commit extracted

Statistics

Entries: 2,690
With proof: 2,682 (99.7%)
With docstring: 0 (0.0%)
Libraries: 53

By type

Type	Count
\func	968
\lemma	920
\class	334
\instance	249
\record	93
\data	59
\type	37
\sfunc	12
\cons	9
\meta	7
\axiom	2

Example

Mono
\extends Map
  | isMono {x : C} {g h : Hom x dom} : f ∘ g = f ∘ h -> g = h
  \where {
    \func comp {C : Precat} {x y z : C} (g : Mono {C} {y} {z}) (f : Mono {C} {x} {y}) : Mono {C} {x} {z} (g.f ∘ f) \cowith
      | isMono p => f.isMono (g.isMono (inv o-assoc *> p *> o-assoc))
  }

type: \record | symbolic_name: Mono | src/Category.ard

Use

Each declaration is split into a statement (signature/claim) and a proof (body) that are disjoint and together form the complete declaration, for proof modeling, autoformalization, retrieval, and dependency analysis via deps.

Citation

@misc{arend_dataset,
  title  = {Arend},
  author = {Norton, Charles},
  year   = {2026},
  note   = {Extracted from https://github.com/JetBrains/arend-lib, commit 373ed3c493f4},
  url    = {https://huggingface.co/datasets/phanerozoic/Arend}
}

Downloads last month: 60

Collection including phanerozoic/Arend

Proof Assistant Projects

Collection

Digesting proof assistant libraries for AI ingestion. • 103 items • Updated 12 days ago • 3