Nuprl - Some Definitions

Thms myhill nerode Sections AutomataTheory Doc

action_set	`Def ActionSet(T) == car:TypeTcarcar` `Thm* T:Type{i}. ActionSet(T) Type{i'}`
maction	`Def (S:Ls) == if null(L) s else S.act(hd(L),(S:tl(L)s)) fi (recursive)` `Thm* Alph:Type, S:ActionSet(Alph), L:Alph*, s:S.car. (S:Ls) S.car`
aset_act	`Def a.act == 2of(a)` `Thm* T:Type, a:ActionSet(T). a.act Ta.cara.car`
aset_car	`Def a.car == 1of(a)` `Thm* T:Type, a:ActionSet(T). a.car Type`
finite	`Def Fin(s) == n:, f:(ns). Bij(n; s; f)` `Thm* T:Type. Fin(T) Prop`
iff	`Def P Q == (P Q) & (P Q)` `Thm* A,B:Prop. (A B) Prop`
int_seg	`Def {i..j} == {k:\| i k < j }` `Thm* m,n:. {m..n} Type`
length	`Def \|\|as\|\| == Case of as; nil 0 ; a.as' \|\|as'\|\|+1 (recursive) Thm* A:Type, l:A. \|\|l\|\|` `Thm \|\|nil\|\|`
mem_f	`Def mem_f(T;a;bs) == Case of bs; nil False ; b.bs' b = a T mem_f(T;a;bs') (recursive)` `Thm* T:Type, a:T, bs:T*. mem_f(T;a;bs) Prop`
nat	`Def == {i:\| 0i }` `Thm* Type`
lelt	`Def i j < k == ij & j < k`
le	`Def AB == B < A` `Thm* i,j:. ij Prop`
not	`Def A == A False` `Thm* A:Prop. (A) Prop`
select	`Def l[i] == hd(nth_tl(i;l))` `Thm* A:Type, l:A*, n:. 0n n < \|\|l\|\| l[n] A`
pi2	`Def 2of(t) == t.2` `Thm* A:Type, B:(AType), p:a:AB(a). 2of(p) B(1of(p))`
pi1	`Def 1of(t) == t.1` `Thm* A:Type, B:(AType), p:a:AB(a). 1of(p) A`
biject	`Def Bij(A; B; f) == Inj(A; B; f) & Surj(A; B; f)` `Thm* A,B:Type, f:(AB). Bij(A; B; f) Prop`
rev_implies	`Def P Q == Q P` `Thm* A,B:Prop. (A B) Prop`
nth_tl	`Def nth_tl(n;as) == if n0 as else nth_tl(n-1;tl(as)) fi (recursive)` `Thm* A:Type, as:A, i:. nth_tl(i;as) A`
tl	`Def tl(l) == Case of l; nil nil ; h.t t` `Thm* A:Type, l:A. tl(l) A`
hd	`Def hd(l) == Case of l; nil "?" ; h.t h` `Thm* A:Type, l:A*. \|\|l\|\|1 hd(l) A`
null	`Def null(as) == Case of as; nil true ; a.as' false Thm* T:Type, as:T. null(as)` `Thm null(nil)`
surject	`Def Surj(A; B; f) == b:B. a:A. f(a) = b` `Thm* A,B:Type, f:(AB). Surj(A; B; f) Prop`
inject	`Def Inj(A; B; f) == a1,a2:A. f(a1) = f(a2) B a1 = a2` `Thm* A,B:Type, f:(AB). Inj(A; B; f) Prop`
le_int	`Def ij == j < i` `Thm* i,j:. ij`
lt_int	`Def i < j == if i < j true ; false fi` `Thm* i,j:. i < j`
bnot	`Def b == if b false else true fi` `Thm* b:. b`

About: