[Imprint][Data Privacy Statement][E-Mail]

Back to the index. View project statistic. View project symbols. View KIV symbols to check that all symbols are available.

All project symbols

symbol	specification	entry
#	map	function, Map[A, B] → Nat
#	array	function, Array[A] → Nat
#	stream	function, Stream[A] → Natinf
#	list-data	function, List[A] → Nat
#	set-basic	function, Set[A] → Nat
#	bag-union	function, Bag[A] → Nat
#	stream-old	function, Stream[A] → Natinf
#	fsarray	function, FSArray[A] → Nat
#	string	function, String → Nat
#c	matrix	function, Matrix[A] → Nat
#oc	list-perm	function, A × List[A] → Nat
#oc	list-as-arrayinstance	function, A × Array[A] → Nat
#r	matrix	function, Matrix[A] → Nat
#x	cube	function, Cube[A] → Nat
#y	cube	function, Cube[A] → Nat
#z	cube	function, Cube[A] → Nat
'	list	function, A → List[A]
*	nat-mult	function, Nat × Nat → Nat
*	matrixops	partial function, Array[Ring] × Array[Ring] → Ring
*	matrixops	partial function, Array[Ring] × Matrix[Ring] → Array[Ring]
*	matrixops	partial function, Matrix[Ring] × Array[Ring] → Array[Ring]
*	matrixops	partial function, Matrix[Ring] × Matrix[Ring] → Matrix[Ring]
*	ring	function, Ring × Ring → Ring
+	array-listops	function, A × Array[A] → Array[A]
+	matrixops	partial function, Array[Ring] × Array[Ring] → Array[Ring]
+	matrixops	partial function, Matrix[Ring] × Matrix[Ring] → Matrix[Ring]
+	nat-inf	function, Natinf × Natinf → Natinf
+	ring	function, Ring × Ring → Ring
+	list	function, List[A] × A → List[A]
+	list	function, List[A] × List[A] → List[A]
+	stream	function, List[A] × Nat → A → Nat → A
+	stream	function, Stream[A] × Stream[A] → Stream[A]
+	stream	function, A × Stream[A] → Stream[A]
+	list-data	function, A × List[A] → List[A]
+	list-as-arrayinstance	function, Array[A] × A → Array[A]
+	list-as-arrayinstance	function, Array[A] × Array[A] → Array[A]
+	stream-old	function, Stream[A] × Stream[A] → Stream[A]
+	stream-old	function, A × Stream[A] → Stream[A]
+	nat-basic	function, Nat × Nat → Nat
+	string	function, String × Char → String
+	string	function, String × String → String
+	string	function, Char × String → String
++	list-dup	function, List[A] × A → List[A]
++	set-basic	function, Set[A] × A → Set[A]
++	bag-basic	function, Bag[A] × A → Bag[A]
++	infset-basic	function, Iset[A] × A → Iset[A]
++	list-as-arrayinstance	function, Array[A] × A → Array[A]
+1	nat-basic	function, Nat → Nat
+2	list	function, A × A → List[A]
+2a	list-as-arrayinstance	function, A × A → Array[A]
-	nat	partial function, Nat × Nat → Nat
--	map	function, Map[A, B] × A → Map[A, B]
--	set-union	function, Set[A] × A → Set[A]
--	bag-union	function, Bag[A] × A → Bag[A]
--	infset-union	function, Iset[A] × A → Iset[A]
-1	nat-basic	partial function, Nat → Nat
-1l	list-del	function, List[A] × A → List[A]
-1l	list-as-arrayinstance	function, Array[A] × A → Array[A]
-l	list-del	function, List[A] × A → List[A]
-l	list-as-arrayinstance	function, Array[A] × A → Array[A]
-p	list-del	function, List[A] × Nat → List[A]
-p	list-as-arrayinstance	function, Array[A] × Nat → Array[A]
. ( . )	list-getput	partial function, List[A] × Nat → A
. ( . )	map	partial function, Map[A, B] × A → B
. ( . )	array	partial function, Array[A] × Nat → A
. ( . )	assoclist	partial function, List[(A, B)] × A → B
. ( . )	stream	partial function, Stream[A] × Nat → A
. ( . )	matrix	partial function, Matrix[A] × Nat × Nat → A
. ( . )	cube	partial function, Cube[A] × Nat × Nat × Nat → A
. ( . )	stream-old	partial function, Stream[A] × Nat → A
. ( . )	fsarray	partial function, FSArray[A] × Nat → A
. ( . := . )	list-getput	partial function, List[A] × Nat × A → List[A]
. ( . := . )	map	function, Map[A, B] × A × B → Map[A, B]
. ( . := . )	array	partial function, Array[A] × Nat × A → Array[A]
. ( . := . )	assoclist	function, List[(A, B)] × A × B → List[(A, B)]
. ( . := . )	stream	partial function, Stream[A] × Nat × A → Stream[A]
. ( . := . )	matrix	partial function, Matrix[A] × Nat × Nat × A → Matrix[A]
. ( . := . )	cube	partial function, Cube[A] × Nat × Nat × Nat × A → Cube[A]
. ( . := . )	stream-old	partial function, Stream[A] × Nat × A → Stream[A]
. ( . := . )	fsarray	partial function, FSArray[A] × Nat × A → FSArray[A]
<	array-listops	predicate, Array[A] × Array[A]
<	oset	predicate, Set[Tord] × Tord
<	oset	predicate, Tord × Set[Tord]
<	nat-inf	predicate, Natinf × Natinf
<	weakord	predicate, Weakord × Weakord
<	list-data	predicate, List[A] × List[A]
<	tord	predicate, Tord × Tord
<	nat-basic	predicate, Nat × Nat
>	nat	predicate, Nat × Nat
Array	array	sort,
Bag	bag-basic	sort,
Cell	lincell	sort,
Char	char	sort,
Cube	cube	sort,
Either	either	sort,
FSArray	fsarray	sort,
I	ring	constant, Ring
IS	monotone-set-fixpoint	function, (A → Bool) → Bool → A → Bool
Iset	infset-basic	sort,
Left	either	function, A → Either[A, B]
List	list-data	sort,
Map	map	sort,
Matrix	matrix	sort,
Nat	nat-basic	sort,
Natinf	nat-inf	sort,
None	option	constant, Option[A]
O	ring	constant, Ring
O-	matrixops	function, Array[Ring] → Array[Ring]
O-	matrixops	function, Matrix[Ring] → Matrix[Ring]
O-	ring	function, Ring → Ring
Option	option	sort,
Ref	Ref	sort,
Right	either	function, B → Either[A, B]
Ring	ring	sort,
Set	set-basic	sort,
Some	option	function, A → Option[A]
Stream	stream-basic	sort,
String	string	sort,
Tord	tord	sort,
UN	monotone-set-fixpoint	function, (A → Bool) → Bool → A → Bool
Weakord	weakord	sort,
[]	array-listops	constant, Array[A]
[]	stream	constant, Stream[A]
[]	list-data	constant, List[A]
[]	stream-old	constant, Stream[A]
[]	string	constant, String
\	set-union	function, Set[A] × Set[A] → Set[A]
\	list-as-arrayinstance	function, Array[A] × Array[A] → Array[A]
\	bag-union	function, Bag[A] × Bag[A] → Bag[A]
\	infset-union	function, Iset[A] × Iset[A] → Iset[A]
\	map+set	function, Map[A, B] × Set[A] → Map[A, B]
\	list-set	function, List[A] × List[A] → List[A]
]c	rowcol-upd	partial function, Matrix[A] × Nat × Array[A] → Matrix[A]
]c	matrix+array	partial function, Matrix[A] × Nat → Array[A]
]r	assoclist	partial function, List[(A, B)] × B → A
]r	rowcol-upd	partial function, Matrix[A] × Nat × Array[A] → Matrix[A]
]r	matrix+array	partial function, Matrix[A] × Nat → Array[A]
]xy	cube+array	partial function, Cube[A] × Nat × Nat → Array[A]
]xz	cube+array	partial function, Cube[A] × Nat × Nat → Array[A]
]yz	cube+array	partial function, Cube[A] × Nat × Nat → Array[A]
^	approx-fixpoint	function, (A → Bool) → A → Bool × Nat → (A → Bool) → A → Bool
^*	relops	function, A × A → Bool → A × A → Bool
^-1	relops	function, A × B → Bool → B × A → Bool
a	list-getput	variable, A
a	map	variable, A
a	array-listops	variable, A
a	putoutside-id	variable, A
a	array	variable, A
a	list-del	variable, A
a	woarray	variable, A
a	olist	variable, Tord
a	oset	variable, Tord
a	wellfounded	variable, A
a	map-ops	variable, A
a	streamseq-mon-lim-old	variable, A
a	wolist	variable, Weakord
a	list-perm	variable, A
a	matrixops	variable, Ring
a	filter-count	variable, A
a	array-as-listinstance	variable, A
a	forall-indexWhere	variable, A
a	list-dup	variable, A
a	ring	variable, Ring
a	omap	variable, Tord
a	array-copy	variable, A
a	list	variable, A
a	assoclist	variable, A
a	infinite-append	variable, A
a	olist-min-max	variable, Tord
a	tord-min-max	variable, Tord
a	relops	variable, A
a	stream	variable, A
a	funops	variable, A
a	weakord	variable, Weakord
a	matrix	variable, A
a	mon-lim-filter-count-old	variable, A
a	list-data	variable, A
a	oarray-sort	variable, A
a	inf-app-list	variable, A
a	list-last	variable, A
a	set-basic	variable, A
a	rowcol-upd	variable, Array[A]
a	bag-basic	variable, A
a	mon-lim-filter-count	variable, A
a	cube	variable, A
a	infset-basic	variable, A
a	set-union	variable, A
a	olist-sort	variable, Tord
a	list-as-arrayinstance	variable, A
a	bag-union	variable, A
a	stream-old	variable, A
a	infset-union	variable, A
a	map+set	variable, A
a	contfun-lim	variable, A
a	infinite-append-old	variable, A
a	tord	variable, Tord
a	list-set	variable, A
a	streamseq-mon-lim	variable, A
a	either	variable, A
a	inf-app-list-old	variable, A
a	fsarray	variable, A
a	fsarray-copy	variable, A
a	array-fsarray	variable, A
af	wellfounded	variable, A → A
af	contfun-lim	variable, Nat → A
al	contfun-lim	variable, List[A]
alf	contfun-lim	variable, Nat → List[A]
all<	olist-min-max	predicate, List[Tord] × Nat × Nat × Tord
all<	olist-min-max	predicate, List[Tord] × Tord
all<	oarray-sort	predicate, Array[Tord] × Nat × Nat × Tord
all<	oarray-sort	predicate, Array[Tord] × Tord
all>	olist-min-max	predicate, List[Tord] × Nat × Nat × Tord
all>	olist-min-max	predicate, List[Tord] × Tord
all>	oarray-sort	predicate, Array[Tord] × Nat × Nat × Tord
all>	oarray-sort	predicate, Array[Tord] × Tord
all≤	olist-min-max	predicate, List[Tord] × Nat × Nat × Tord
all≤	olist-min-max	predicate, List[Tord] × Tord
all≤	oarray-sort	predicate, Array[Tord] × Nat × Nat × Tord
all≤	oarray-sort	predicate, Array[Tord] × Tord
all≥	olist-min-max	predicate, List[Tord] × Nat × Nat × Tord
all≥	olist-min-max	predicate, List[Tord] × Tord
all≥	oarray-sort	predicate, Array[Tord] × Nat × Nat × Tord
all≥	oarray-sort	predicate, Array[Tord] × Tord
alp	contfun-lim	variable, List[A] → Bool
ar	array-listops	variable, Array[A]
ar	array	variable, Array[A]
ar	woarray	variable, Array[A]
ar	array-copy	variable, Array[A]
ar	oarray-sort	variable, Array[A]
ar	list-as-arrayinstance	variable, Array[A]
ar	get-outside	variable, Array[A]
ar	fsarray	variable, FSArray[A]
ar	fsarray-copy	variable, FSArray[A]
ar	array-fsarray	variable, Array[A]
ax	assoclist	variable, List[(A, B)]
b	list-getput	variable, A
b	map	variable, A
b	option	variable, B
b	array	variable, A
b	list-del	variable, A
b	olist	variable, Tord
b	oset	variable, Tord
b	wellfounded	variable, B
b	map-ops	variable, B
b	streamseq-mon-lim-old	variable, A
b	wolist	variable, Weakord
b	list-perm	variable, A
b	filter-count	variable, B
b	array-as-listinstance	variable, A
b	list-dup	variable, A
b	ring	variable, Ring
b	list	variable, B
b	assoclist	variable, A
b	olist-min-max	variable, Tord
b	tord-min-max	variable, Tord
b	relops	variable, B
b	funops	variable, B
b	weakord	variable, Weakord
b	matrix	variable, A
b	mon-lim-filter-count-old	variable, A
b	inf-app-list	variable, A
b	list-last	variable, A
b	set-basic	variable, A
b	bag-basic	variable, A
b	mon-lim-filter-count	variable, A
b	cube	variable, A
b	infset-basic	variable, A
b	set-union	variable, B
b	olist-sort	variable, Tord
b	bag-union	variable, A
b	infset-union	variable, A
b	contfun-lim	variable, B
b	tord	variable, Tord
b	list-set	variable, A
b	streamseq-mon-lim	variable, A
b	either	variable, B
b	inf-app-list-old	variable, A
b	fsarray	variable, A
bag	bag-basic	variable, Bag[A]
bag	bag-union	variable, Bag[A]
bc	wellfounded	variable, (B, C)
bf	contfun-lim	variable, Nat → B
bl	contfun-lim	variable, List[B]
butlast	list-last	partial function, List[A] → List[A]
butlast	list-as-arrayinstance	partial function, Array[A] → Array[A]
butmax	oset	partial function, Set[Tord] → Set[Tord]
butmin	oset	partial function, Set[Tord] → Set[Tord]
butmin	omap	partial function, Map[Tord, B] → Map[Tord, B]
bx	list-dup	variable, List[B]
bx	list	variable, List[B]
c	list-getput	variable, A
c	map	variable, A
c	array	variable, A
c	olist	variable, Tord
c	wellfounded	variable, C
c	map-ops	variable, C
c	wolist	variable, Weakord
c	list-perm	variable, A
c	matrixops	variable, Nat
c	array-as-listinstance	variable, A
c	list-dup	variable, A
c	ring	variable, Ring
c	relops	variable, C
c	funops	variable, C
c	weakord	variable, Weakord
c	matrix	variable, Nat
c	list-last	variable, A
c	rowcol-upd	variable, Nat
c	olist-sort	variable, Tord
c	infset-union	variable, A
c	matrix+array	variable, Nat
c	tord	variable, Tord
c	list-set	variable, A
c	either	variable, C
c	fsarray	variable, A
c	string	variable, Char
ce	path-reachable	variable, Cell
ce	lincell	variable, Cell
chain	approx-fixpoint	predicate, Nat → A → Bool
char	char	variable, Char
chn	wellfounded	variable, Nat → A
chn	approx-fixpoint	variable, Nat → A → Bool
chngen	wellfounded	variable, Nat → Nat → A
cmp	array-copy	partial predicate, Array[A] × A × Nat × Nat
cmp	array-copy	partial predicate, Array[A] × Nat × Array[A] × Nat × Nat
cmp	array-copy	predicate, Array[A] × A
cmp	fsarray-copy	partial predicate, FSArray[A] × A × Nat × Nat
cmp	fsarray-copy	partial predicate, FSArray[A] × Nat × FSArray[A] × Nat × Nat
cmp	fsarray-copy	predicate, FSArray[A] × A
cmp	array-fsarray	partial predicate, FSArray[A] × Nat × Array[A] × Nat × Nat
cnt	mon-lim-filter-count-old	function, A × Stream[A] → Natinf
cnt	mon-lim-filter-count	function, A × Stream[A] → Natinf
cod	relops	function, A × B → Bool → B → Bool
cod	funops	function, A → B → B → Bool
compl	monotone-set-fixpoint	function, (A → Bool) → A → Bool → (A → Bool) → A → Bool
cont	approx-fixpoint	predicate, (A → Bool) → A → Bool
cont	contfun-lim	predicate, Stream[S] × Stream[A] → Stream[B]
cont	contfun-lim	predicate, Stream[A] → Stream[B]
copy	array-copy	partial function, Array[A] × Nat × Array[A] × Nat × Nat → Array[A]
copy	fsarray-copy	partial function, FSArray[A] × Nat × FSArray[A] × Nat × Nat → FSArray[A]
copy	array-fsarray	partial function, FSArray[A] × Nat × Array[A] × Nat × Nat → Array[A]
copy	array-fsarray	partial function, Array[A] × Nat × FSArray[A] × Nat × Nat → FSArray[A]
copyAndFill#	array-copy	procedure, Nat × Nat × Nat × A : Array[A] × Array[A]
count	filter-count	partial function, List[A] × Nat × Nat × A → Bool → Nat
count	filter-count	function, List[A] × A → Bool → Nat
count	bag-basic	function, Bag[A] × A → Nat
count	list-as-arrayinstance	partial function, Array[A] × Nat × Nat × A → Bool → Nat
count	list-as-arrayinstance	function, Array[A] × A → Bool → Nat
cu	cube	variable, Cube[A]
cu	cube+array	variable, Cube[A]
d	map	variable, B
d	omap	variable, B
d	assoclist	variable, B
d	map+set	variable, B
d	either	variable, D
disj	list-dup	predicate, List[A] × List[A]
disj	list-as-arrayinstance	predicate, Array[A] × Array[A]
disjoint	set-union	predicate, Set[A] × Set[A]
distinct	list-dup	function, List[A] → List[A]
distinct	list-as-arrayinstance	function, Array[A] → Array[A]
dom	relops	function, A × B → Bool → A → Bool
dom	map+set	function, Map[A, B] → Set[A]
drop	list-del	partial function, List[A] × Nat → List[A]
drop	stream	partial function, Stream[A] × Nat → Stream[A]
drop	stream	function, Nat → A × Nat → Nat → A
drop	list-as-arrayinstance	partial function, Array[A] × Nat → Array[A]
drop	stream-old	partial function, Stream[A] × Nat → Stream[A]
drop	stream-old	function, Nat → A × Nat → Nat → A
dropRight	list-last	partial function, List[A] × Nat → List[A]
dropRight	list-as-arrayinstance	partial function, Array[A] × Nat → Array[A]
dups	list-dup	predicate, List[A]
dups	list-as-arrayinstance	predicate, Array[A]
exists	map-ops	predicate, Map[A, B] × A → Bool
exists	map-ops	predicate, Map[A, B] × A × B → Bool
exists	forall-indexWhere	predicate, List[A] × A → Bool
exists	set-union	predicate, Set[A] × A → Bool
exists	bag-union	predicate, Bag[A] × A → Bool
f	option	variable, A → B
f	list-del	variable, A → B
f	map-ops	variable, B → C
f	matrixops	variable, Nat → Ring
f	stream-basic	partial function, Stream[A] → Nat → A
f	stream-basic	variable, Nat → A
f	list-dup	variable, A → B
f	list	variable, A → B
f	infinite-append	variable, A → A
f	relops	variable, A → B
f	funops	variable, A → B
f	approx-fixpoint	variable, (A → Bool) → A → Bool
f	infset-basic	variable, A → Bool
f	set-union	variable, A → B
f	monotone-set-fixpoint	variable, (A → Bool) → A → Bool
f	contfun-lim	variable, Stream[A] → Stream[B]
fa	list-dup	variable, B
fac	either	variable, A → C
fbc	either	variable, B → C
fbd	either	variable, B → D
fill	array-copy	partial function, Array[A] × A × Nat × Nat → Array[A]
fill	array-copy	function, Array[A] × A → Array[A]
fill	fsarray-copy	partial function, FSArray[A] × A × Nat × Nat → FSArray[A]
fill	fsarray-copy	function, FSArray[A] × A → FSArray[A]
fillfirst	list-last	function, Nat × A × List[A] → List[A]
fillfirst	list-as-arrayinstance	function, Nat × A × Array[A] → Array[A]
filter	map-ops	function, Map[A, B] × A → Bool → Map[A, B]
filter	map-ops	function, Map[A, B] × A × B → Bool → Map[A, B]
filter	filter-count	function, List[A] × A → Bool → List[A]
filter	mon-lim-filter-count-old	function, Stream[A] × A → Bool → Stream[A]
filter	mon-lim-filter-count	function, Stream[A] × A → Bool → Stream[A]
filter	set-union	function, Set[A] × A → Bool → Set[A]
filter	list-as-arrayinstance	function, Array[A] × A → Bool → Array[A]
filter	bag-union	function, Bag[A] × A → Bool → Bag[A]
finp	stream-basic	predicate, Stream[A]
first	array-listops	partial function, Array[A] → A
fold	either	function, Either[A, B] × A → C × B → C → C
foldLeft	list	function, List[A] × B × B × A → B → B
foldLeft	list-as-arrayinstance	function, Array[A] × B × B × A → B → B
forall	map-ops	predicate, Map[A, B] × A → Bool
forall	map-ops	predicate, Map[A, B] × A × B → Bool
forall	forall-indexWhere	predicate, List[A] × A → Bool
forall	set-union	predicate, Set[A] × A → Bool
forall	bag-union	predicate, Bag[A] × A → Bool
frome	list-del	function, List[A] × A → List[A]
frome	list-as-arrayinstance	function, Array[A] × A → Array[A]
fsar	array-fsarray	variable, FSArray[A]
funp	relops	predicate, A × B → Bool
g	map-ops	variable, A × B → C
g	matrixops	variable, Nat × Nat → Ring
g	funops	variable, B → C
get	option	partial function, Option[A] → A
getL	either	partial function, Either[A, B] → A
getLOrElse	either	function, Either[A, B] × A → A
getOrElse	option	function, Option[A] × A → A
getR	either	partial function, Either[A, B] → B
getROrElse	either	function, Either[A, B] × B → B
h	funops	variable, A → C
h	path-reachable	variable, Map[Ref, Cell]
hd	stream	partial function, Stream[A] → A
hd	stream-old	partial function, Stream[A] → A
head	list-data	partial function, List[A] → A
head	list-data	variable, A
head	string	partial function, String → Char
i	rowcol-upd	variable, A
idrange	array-copy	partial predicate, Array[A] × Nat × Nat
idrange	fsarray-copy	partial predicate, FSArray[A] × Nat × Nat
id○	array-copy	predicate, Array[A] × Array[A] × Nat × Nat
id○	array-copy	predicate, Array[A] × Array[A] × Nat
id○	fsarray-copy	predicate, FSArray[A] × FSArray[A] × Nat × Nat
id○	fsarray-copy	predicate, FSArray[A] × FSArray[A] × Nat
ii	infinite-append	variable, Nat → Nat
ii	inf-app-list	variable, Nat → Nat
ii	infinite-append-old	variable, Nat → Nat
ii	streamseq-mon-lim	variable, Nat → Nat
ii	inf-app-list-old	variable, Nat → Nat
iigen	infinite-append	variable, Nat → Nat → Nat
iigen	infinite-append-old	variable, Nat → Nat → Nat
indexOf	list-del	function, List[A] × A → Nat
indexOf	list-as-arrayinstance	function, Array[A] × A → Nat
indexWhere	forall-indexWhere	function, List[A] × A → Bool → Nat
inj	relops	predicate, A × B → Bool
inj	funops	predicate, A → B
ins≤	woarray	function, Weakord × Array[Weakord] → Array[Weakord]
ins≤	olist	function, Tord × List[Tord] → List[Tord]
ins≤	wolist	function, Weakord × List[Weakord] → List[Weakord]
ins≤	oarray-sort	function, Tord × Array[Tord] → Array[Tord]
intersect	list-as-arrayinstance	function, Array[A] × Array[A] → Array[A]
intersect	list-set	function, List[A] × List[A] → List[A]
inv	stut-mon-old	partial function, Stream[Nat] → Stream[Nat]
inv	stut-mon	partial function, Stream[Nat] → Stream[Nat]
irel	relops	variable, B × A → Bool
isRight	either	predicate, Either[A, B]
iset	approx-fixpoint	variable, A → Bool
iset	monotone-set-fixpoint	variable, A → Bool
iset0	monotone-set-fixpoint	variable, A → Bool
iset1	monotone-set-fixpoint	variable, A → Bool
isetset	monotone-set-fixpoint	variable, (A → Bool) → Bool
j	rowcol-upd	variable, A
jj	infinite-append	variable, Nat → Nat
jj	infinite-append-old	variable, Nat → Nat
keys	omap	function, Map[Tord, B] → Set[Tord]
l	stream-basic	partial function, Stream[A] → List[A]
l	stream-basic	variable, List[A]
last	list-last	partial function, List[A] → A
last	list-as-arrayinstance	partial function, Array[A] → A
lastoc	mon-lim-filter-count-old	function, A × Stream[A] → Natinf
lastoc	mon-lim-filter-count	function, A × Stream[A] → Natinf
leninv	stut-mon-old	function, Stream[Nat] → Natinf
leninv	stut-mon	function, Stream[Nat] → Natinf
lf	infinite-append	variable, Nat → List[A]
lf	inf-app-list	variable, Nat → List[A]
lf	contfun-lim	variable, List[A] → List[B]
lf	infinite-append-old	variable, Nat → List[A]
lf	streamseq-mon-lim	variable, Nat → List[A]
lf	inf-app-list-old	variable, Nat → List[A]
lfgen	infinite-append	variable, Nat → Nat → List[A]
lfgen	infinite-append-old	variable, Nat → Nat → List[A]
lift	contfun-lim	partial function, List[S] × List[A] → List[B] → Stream[S] × Stream[A] → Stream[B]
lift	contfun-lim	partial function, List[A] → List[B] → Stream[A] → Stream[B]
lift	contfun-lim	function, List[S] × List[A] → Bool → Stream[S] × Stream[A] → Bool
lift	contfun-lim	function, List[A] → Bool → Stream[A] → Bool
lifted	contfun-lim	function, List[S] × List[A] → Bool → (List[S] × List[A] → List[B]) × (Stream[S] × Stream[A] → Stream[B]) → Bool
lifted	contfun-lim	function, List[A] → Bool → (List[A] → List[B]) × (Stream[A] → Stream[B]) → Bool
lim	streamseq-mon-lim-old	partial function, Stream[Stream[A]] → Stream[A]
lim	mon-lim-filter-count-old	partial function, Nat → Stream[A] → Stream[A]
lim	mon-lim-filter-count	partial function, Nat → Stream[A] → Stream[A]
lim	streamseq-mon-lim	partial function, Stream[Stream[A]] → Stream[A]
m	list-getput	variable, Nat
m	putoutside-id	variable, Nat
m	array	variable, Nat
m	list-del	variable, Nat
m	olist	variable, Nat
m	streamseq-mon-lim-old	variable, Nat
m	stut-mon-old	variable, Nat
m	nat-mult	variable, Nat
m	wolist	variable, Nat
m	list-perm	variable, Nat
m	matrixops	variable, Nat
m	filter-count	variable, Nat
m	array-as-listinstance	variable, Nat
m	nat-inf	variable, Nat
m	stream-basic	variable, Nat
m	array-copy	variable, Nat
m	infinite-append	variable, Nat
m	olist-min-max	variable, Nat
m	stream	variable, Nat
m	mon-lim-filter-count-old	variable, Nat
m	approx-fixpoint	variable, Nat
m	inf-app-list	variable, Nat
m	list-last	variable, Nat
m	rowcol-upd	variable, Nat
m	mon-lim-filter-count	variable, Nat
m	set-union	variable, Nat
m	stream-old	variable, Nat
m	path-reachable	variable, Nat
m	contfun-lim	variable, Nat
m	infinite-append-old	variable, Nat
m	natset	variable, Nat
m	list-set	variable, Nat
m	streamseq-mon-lim	variable, Nat
m	stut-mon	variable, Nat
m	inf-app-list-old	variable, Nat
m	fsarray	variable, Nat
m	fsarray-copy	variable, Nat
m	array-fsarray	variable, Nat
map	option	function, Option[A] × A → B → Option[B]
map	map-ops	function, Map[A, B] × A × B → C → Map[A, C]
map	map-ops	function, Map[A, B] × B → C → Map[A, C]
map	list	function, List[A] × A → B → List[B]
map	set-union	function, Set[A] × A → B → Set[B]
map	list-as-arrayinstance	function, Array[A] × A → B → Array[B]
map	bag-union	function, Bag[A] × A → B → Bag[B]
map	either	function, Either[A, B] × A → C × B → D → Either[C, D]
mapl	either	function, Either[A, B] × A → C → Either[C, B]
mapr	either	function, Either[A, B] × B → C → Either[A, C]
max	oset	partial function, Set[Tord] → Tord
max	olist-min-max	partial function, List[Tord] → Tord
max	tord-min-max	function, Tord × Tord → Tord
max	oarray-sort	partial function, Array[Tord] → Tord
max∞	stut-mon-old	function, Nat → Bool → Natinf
max∞	stut-mon	function, Nat → Bool → Natinf
merge	woarray	function, Array[Weakord] × Array[Weakord] → Array[Weakord]
merge	olist	function, List[Tord] × List[Tord] → List[Tord]
merge	wolist	function, List[Weakord] × List[Weakord] → List[Weakord]
merge	oarray-sort	function, Array[Tord] × Array[Tord] → Array[Tord]
min	oset	partial function, Set[Tord] → Tord
min	stut-mon-old	partial function, Stream[Nat] × Nat → Nat
min	nat-inf	function, Natinf × Natinf → Natinf
min	omap	partial function, Map[Tord, B] → Tord
min	olist-min-max	partial function, List[Tord] → Tord
min	tord-min-max	function, Tord × Tord → Tord
min	oarray-sort	partial function, Array[Tord] → Tord
min	stut-mon	partial function, Stream[Nat] × Nat → Nat
mkar'	list-as-arrayinstance	function, A → Array[A]
mkarray	array	function, Nat × A → Array[A]
mkarray	array	function, Nat → Array[A]
mkarray	fsarray	constant, FSArray[A]
mkcube	cube	function, Nat × Nat × Nat × A → Cube[A]
mkfsarray	fsarray	function, A → FSArray[A]
mkinitar	list-as-arrayinstance	function, A × Nat → Array[A]
mklist	list-last	function, A × Nat → List[A]
mkmatrix	matrix	function, Nat × Nat × A → Matrix[A]
mon	streamseq-mon-lim-old	predicate, Stream[Stream[A]]
mon	mon-lim-filter-count-old	predicate, Nat → Stream[A]
mon	mon-lim-filter-count	predicate, Nat → Stream[A]
mon	contfun-lim	predicate, List[S] × List[A] → List[B]
mon	contfun-lim	predicate, List[A] → List[B]
mon	contfun-lim	predicate, Stream[S] × Stream[A] → Stream[B]
mon	contfun-lim	predicate, Stream[A] → Stream[B]
mon	streamseq-mon-lim	predicate, Stream[Stream[A]]
mon<	stut-mon-old	predicate, Stream[Nat]
mon<	stut-mon	predicate, Stream[Nat]
monotone	monotone-set-fixpoint	predicate, (A → Bool) → A → Bool
mon≤	stut-mon-old	predicate, Stream[Nat]
mon≤	stut-mon	predicate, Stream[Nat]
move	array-copy	partial function, Array[A] × Nat × Nat × Nat → Array[A]
moveAndFill#	array-copy	procedure, Nat × Nat × Nat × A : Array[A]
mx	matrixops	variable, Matrix[Ring]
mx	matrix	variable, Matrix[A]
mx	rowcol-upd	variable, Matrix[A]
mx	matrix+array	variable, Matrix[A]
n	list-getput	variable, Nat
n	array-listops	variable, Nat
n	putoutside-id	variable, Nat
n	array	variable, Nat
n	list-del	variable, Nat
n	woarray	variable, Nat
n	olist	variable, Nat
n	streamseq-mon-lim-old	variable, Nat
n	stut-mon-old	variable, Nat
n	nat-mult	variable, Nat
n	wolist	variable, Nat
n	list-perm	variable, Nat
n	matrixops	variable, Nat
n	filter-count	variable, Nat
n	array-as-listinstance	variable, Nat
n	nat-inf	partial function, Natinf → Nat
n	nat-inf	variable, Nat
n	array-copy	variable, Nat
n	list	variable, Nat
n	infinite-append	variable, Nat
n	olist-min-max	variable, Nat
n	relops	variable, Nat
n	stream	variable, Nat
n	mon-lim-filter-count-old	variable, Nat
n	list-data	variable, Nat
n	oarray-sort	variable, Nat
n	approx-fixpoint	variable, Nat
n	inf-app-list	variable, Nat
n	list-last	variable, Nat
n	set-basic	variable, Nat
n	rowcol-upd	variable, Nat
n	mon-lim-filter-count	variable, Nat
n	set-union	variable, Nat
n	list-as-arrayinstance	variable, Nat
n	stream-old	variable, Nat
n	path-reachable	variable, Nat
n	get-outside	variable, Nat
n	contfun-lim	variable, Nat
n	infinite-append-old	variable, Nat
n	natset	variable, Nat
n	list-set	variable, Nat
n	streamseq-mon-lim	variable, Nat
n	stut-mon	variable, Nat
n	inf-app-list-old	variable, Nat
n	fsarray	variable, Nat
n	fsarray-copy	variable, Nat
n	array-fsarray	variable, Nat
nexta	infinite-append	variable, Nat × A → A
nextj	infinite-append	variable, Nat × A → Nat
nextj	infinite-append-old	variable, Nat × A → Nat
nextl	infinite-append	variable, Nat × A → List[A]
nextl	infinite-append-old	variable, Nat × A → List[A]
nextli	inf-app-list	variable, List[A] → List[A]
nextli	inf-app-list-old	variable, List[A] → List[A]
nextnli	inf-app-list	variable, List[A] × Nat → List[A]
nextnli	inf-app-list-old	variable, List[A] × Nat → List[A]
nf	streamseq-mon-lim-old	variable, Nat → A
nf	stut-mon-old	variable, Nat → Nat
nf	stream-basic	variable, Nat → A
nf	infinite-append	variable, Nat → A
nf	stream	variable, Nat → A
nf	mon-lim-filter-count-old	variable, Nat → A
nf	mon-lim-filter-count	variable, Nat → A
nf	stream-old	variable, Nat → A
nf	infinite-append-old	variable, Nat → A
nf	streamseq-mon-lim	variable, Nat → A
nf	stut-mon	variable, Nat → Nat
nfgen	infinite-append	variable, Nat → Nat → A
nfgen	infinite-append-old	variable, Nat → Nat → A
nl	stut-mon-old	variable, List[Nat]
nl	stut-mon	variable, List[Nat]
nnf	streamseq-mon-lim-old	variable, Nat → Nat
nnf	stut-mon-old	variable, Nat → Nat
nnf	mon-lim-filter-count-old	variable, Nat → Nat
nnf	mon-lim-filter-count	variable, Nat → Nat
nnf	streamseq-mon-lim	variable, Nat → Nat
nnf	stut-mon	variable, Nat → Nat
np	streamseq-mon-lim-old	variable, Nat → Bool
np	stut-mon-old	variable, Nat → Bool
np	mon-lim-filter-count-old	variable, Nat → Bool
np	mon-lim-filter-count	variable, Nat → Bool
np	streamseq-mon-lim	variable, Nat → Bool
np	stut-mon	variable, Nat → Bool
ns	matrixops	variable, Set[Nat]
ns	natset	variable, Set[Nat]
null	Ref	constant, Ref
nx	cube	variable, Nat
nx	cube+array	variable, Nat
nxt	lincell	function, Cell → Ref
ny	cube	variable, Nat
ny	cube+array	variable, Nat
nz	cube	variable, Nat
nz	cube+array	variable, Nat
nσ	stut-mon-old	variable, Stream[Nat]
nσ	stut-mon	variable, Stream[Nat]
nσf	stut-mon-old	variable, Nat → Stream[Nat]
nσf	stut-mon	variable, Nat → Stream[Nat]
n∞	streamseq-mon-lim-old	variable, Natinf
n∞	stut-mon-old	variable, Natinf
n∞	nat-inf	variable, Natinf
n∞	stream	variable, Natinf
n∞	mon-lim-filter-count-old	variable, Natinf
n∞	mon-lim-filter-count	variable, Natinf
n∞	stream-old	variable, Natinf
n∞	streamseq-mon-lim	variable, Natinf
n∞	stut-mon	variable, Natinf
o	option	function, B → Option[C] × A → Option[B] → A → Option[C]
o	relops	function, A × B → Bool × B × C → Bool → A × C → Bool
o	funops	function, A → B × B → C → A → C
oa	either	variable, Option[A]
ob	either	variable, Option[B]
of	option	variable, A → Option[B]
og	option	variable, B → Option[C]
oinj	option	predicate, A → Option[B]
opt	option	variable, Option[A]
optl	either	function, Either[A, B] → Option[A]
optr	either	function, Either[A, B] → Option[B]
ordered<	woarray	predicate, Array[Weakord]
ordered<	olist	predicate, List[Tord]
ordered<	wolist	predicate, List[Weakord]
ordered<	oarray-sort	predicate, Array[Tord]
ordered≤	woarray	predicate, Array[Weakord]
ordered≤	olist	predicate, List[Tord]
ordered≤	wolist	predicate, List[Weakord]
ordered≤	oarray-sort	predicate, Array[Tord]
osurj	option	predicate, A → Option[B]
p	wellfounded	variable, A → Bool
p	map-ops	variable, A → Bool
p	streamseq-mon-lim-old	variable, A → Bool
p	stut-mon-old	variable, A → Bool
p	filter-count	variable, A → Bool
p	forall-indexWhere	variable, A → Bool
p	assoclist	variable, (A, B)
p	mon-lim-filter-count-old	variable, A → Bool
p	mon-lim-filter-count	variable, A → Bool
p	set-union	variable, A → Bool
p	bag-union	variable, A → Bool
p	streamseq-mon-lim	variable, A → Bool
p	stut-mon	variable, A → Bool
path	path-reachable	predicate, List[Ref] × Map[Ref, Cell]
pbd	contfun-lim	predicate, Stream[S] × Stream[A] → Stream[B]
pbd	contfun-lim	predicate, Stream[A] → Stream[B]
pcont	contfun-lim	function, Stream[S] × Stream[A] → Bool → (Stream[S] × Stream[A] → Stream[B]) → Bool
pcont	contfun-lim	function, Stream[A] → Bool → (Stream[A] → Stream[B]) → Bool
pelem	relops	variable, A × A → Bool
perm	list-perm	predicate, List[A] × List[A]
perm	list-as-arrayinstance	predicate, Array[A] × Array[A]
pfunp	relops	predicate, A × B → Bool
pfxclosed	contfun-lim	predicate, List[S] × List[A] → Bool
pfxclosed	contfun-lim	predicate, Stream[S] × Stream[A] → Bool
pfxclosed	contfun-lim	predicate, List[A] → Bool
pfxclosed	contfun-lim	predicate, Stream[A] → Bool
pmon	contfun-lim	function, List[S] × List[A] → Bool → (List[S] × List[A] → List[B]) → Bool
pmon	contfun-lim	function, Stream[S] × Stream[A] → Bool → (Stream[S] × Stream[A] → Stream[B]) → Bool
pmon	contfun-lim	function, List[A] → Bool → (List[A] → List[B]) → Bool
pmon	contfun-lim	function, Stream[A] → Bool → (Stream[A] → Stream[B]) → Bool
ppbd	contfun-lim	function, Stream[S] × Stream[A] → Bool → (Stream[S] × Stream[A] → Stream[B]) → Bool
ppbd	contfun-lim	function, Stream[A] → Bool → (Stream[A] → Stream[B]) → Bool
q	wellfounded	variable, B × C → Bool
q	map-ops	variable, A × B → Bool
r	matrixops	variable, Nat
r	matrix	variable, Nat
r	rowcol-upd	variable, Nat
r	path-reachable	variable, Ref
r	matrix+array	variable, Nat
r	Ref	variable, Ref
reachable	path-reachable	predicate, Ref × Ref × Map[Ref, Cell]
reachable*	path-reachable	predicate, Map[Ref, Cell] × Ref × Ref
reachable-1	path-reachable	predicate, Map[Ref, Cell] × Ref × Ref
reachable-n	path-reachable	predicate, Map[Ref, Cell] × Nat × Ref × Ref
rel	relops	variable, A × B → Bool
relac	relops	variable, A × C → Bool
relbc	relops	variable, B × C → Bool
rem	mon-lim-filter-count-old	function, Stream[A] × Nat → Bool → Stream[A]
rem	mon-lim-filter-count	function, Stream[A] × Nat → Bool → Stream[A]
resize	array-copy	function, Array[A] × Nat → Array[A]
rest	array-listops	partial function, Array[A] → Array[A]
rev	list-last	function, List[A] → List[A]
rev	list-as-arrayinstance	function, Array[A] → Array[A]
rotateLeft	array-copy	partial function, Array[A] × Nat × Nat × Nat → Array[A]
rotateRight	array-copy	partial function, Array[A] × Nat × Nat × Nat → Array[A]
rtc	relops	function, Nat × A × A → Bool → A × A → Bool
s	oset	variable, Set[Tord]
s	omap	variable, Set[Tord]
s	set-basic	variable, Set[A]
s	infset-basic	variable, Iset[A]
s	set-union	variable, Set[A]
s	infset-union	variable, Iset[A]
s	map+set	variable, Set[A]
s	string	variable, String
sf	contfun-lim	variable, Nat → S
shiftLeft	array-copy	partial function, Array[A] × Nat × Nat × Nat → Array[A]
shiftRight	array-copy	partial function, Array[A] × Nat × Nat × Nat → Array[A]
size	fsarray	constant, Nat
sl	contfun-lim	variable, List[S]
slf	contfun-lim	variable, Nat → List[S]
sort	oarray-sort	function, Array[Tord] → Array[Tord]
sort	olist-sort	function, List[Tord] → List[Tord]
st	map	variable, Map[A, B]
st	omap	variable, Map[Tord, B]
st	map+set	variable, Map[A, B]
str	string	function, Char → String
stutf	stut-mon-old	predicate, Stream[Nat]
stutf	stut-mon	predicate, Stream[Nat]
subarray	array-copy	partial function, Array[A] × Nat × Nat → Array[A]
subarray	array-fsarray	partial function, FSArray[A] × Nat × Nat → Array[A]
sublist	list-del	partial function, List[A] × Nat × Nat → List[A]
sublist	list-as-arrayinstance	partial function, Array[A] × Nat × Nat → Array[A]
surj	relops	predicate, A × B → Bool
surj	funops	predicate, A → B
tail	list-data	partial function, List[A] → List[A]
tail	list-data	variable, List[A]
tail	string	partial function, String → String
take	list-del	partial function, List[A] × Nat → List[A]
take	stream	partial function, Stream[A] × Natinf → Stream[A]
take	stream	partial function, Stream[A] × Nat → List[A]
take	stream	function, Nat → A × Nat → List[A]
take	list-as-arrayinstance	partial function, Array[A] × Nat → Array[A]
take	stream-old	partial function, Stream[A] × Natinf → Stream[A]
take	stream-old	partial function, Stream[A] × Nat → Stream[A]
take	stream-old	function, Nat → A × Nat → List[A]
takeRight	list-del	partial function, List[A] × Nat → List[A]
takeRight	list-as-arrayinstance	partial function, Array[A] × Nat → Array[A]
tl	stream	partial function, Stream[A] → Stream[A]
tl	stream-old	partial function, Stream[A] → Stream[A]
to	natset	function, Nat × Nat → Set[Nat]
toArc	rowcol-upd	function, Matrix[A] → Array[A]
toArc	rowcol-upd	function, Matrix[A] × Nat → Array[A]
toArr	rowcol-upd	function, Matrix[A] → Array[A]
toArr	rowcol-upd	function, Matrix[A] × Nat → Array[A]
toArray	array-fsarray	function, FSArray[A] → Array[A]
toFSArray	array-fsarray	partial function, Array[A] → FSArray[A]
toFun	relops	partial function, A × B → Bool → A → B
total	relops	predicate, A × B → Bool
trans	wellfounded	predicate, A × A → Bool
trf	contfun-lim	variable, List[S] × List[A] → List[B]
trlp	contfun-lim	variable, List[S] × List[A] → Bool
trp	contfun-lim	variable, Stream[S] × Stream[A] → Bool
twf	wellfounded	predicate, A × A → Bool
twfinv	wellfounded	predicate, A × A → Bool
unique_al	assoclist	predicate, List[(A, B)]
vec	matrixops	variable, Array[Ring]
wf	wellfounded	predicate, A × A → Bool
wf1≪	wellfounded	variable, B × B → Bool
wf2≪	wellfounded	variable, C × C → Bool
wfinv	wellfounded	predicate, A × A → Bool
wf≪	wellfounded	variable, A × A → Bool
wf≫	wellfounded	variable, A × A → Bool
x	list-getput	variable, List[A]
x	putoutside-id	variable, List[A]
x	list-del	variable, List[A]
x	olist	variable, List[Tord]
x	streamseq-mon-lim-old	variable, List[A]
x	wolist	variable, List[Weakord]
x	list-perm	variable, List[A]
x	filter-count	variable, List[A]
x	array-as-listinstance	variable, List[A]
x	forall-indexWhere	variable, List[A]
x	stream-basic	variable, List[A]
x	list-dup	variable, List[A]
x	list	variable, List[A]
x	olist-min-max	variable, List[Tord]
x	stream	variable, List[A]
x	mon-lim-filter-count-old	variable, List[A]
x	list-data	variable, List[A]
x	approx-fixpoint	variable, A
x	inf-app-list	variable, List[A]
x	list-last	variable, List[A]
x	mon-lim-filter-count	variable, List[A]
x	olist-sort	variable, List[Tord]
x	monotone-set-fixpoint	variable, A
x	stream-old	variable, List[A]
x	path-reachable	variable, List[Ref]
x	list-set	variable, List[A]
x	streamseq-mon-lim	variable, List[A]
x	inf-app-list-old	variable, List[A]
x0	monotone-set-fixpoint	variable, A
x1	monotone-set-fixpoint	variable, A
y	list-getput	variable, List[A]
y	list-del	variable, List[A]
y	olist	variable, List[Tord]
y	wolist	variable, List[Weakord]
y	list-perm	variable, List[A]
y	filter-count	variable, List[A]
y	array-as-listinstance	variable, List[A]
y	list-dup	variable, List[A]
y	list	variable, List[A]
y	olist-min-max	variable, List[A]
y	stream	variable, List[A]
y	list-data	variable, List[A]
y	inf-app-list	variable, List[A]
y	list-last	variable, List[A]
y	olist-sort	variable, List[Tord]
y	stream-old	variable, List[A]
y	path-reachable	variable, List[Ref]
y	list-set	variable, List[A]
y	inf-app-list-old	variable, List[A]
z	list-getput	variable, List[A]
z	list-del	variable, List[A]
z	olist	variable, List[Tord]
z	wolist	variable, List[Weakord]
z	list-perm	variable, List[A]
z	filter-count	variable, List[B]
z	array-as-listinstance	variable, List[A]
z	list-dup	variable, List[A]
z	list	variable, List[A]
z	stream	variable, List[A]
z	list-data	variable, List[A]
z	list-last	variable, List[A]
z	olist-sort	variable, List[Tord]
z	stream-old	variable, List[A]
z	list-set	variable, List[A]
zip	filter-count	function, List[A] × List[B] → List[(A, B)]
zip	list-as-arrayinstance	function, Array[A] × Array[B] → Array[(A, B)]
\|	map+set	function, Map[A, B] × Set[A] → Map[A, B]
}	infset-basic	function, A → Bool → Iset[A]
}	set-union	function, A → Set[A]
}	bag-union	function, A → Bag[A]
}	infset-union	function, A → Iset[A]
Σ	matrixops	function, Set[Nat] × Nat → Ring → Ring
α	contfun-lim	variable, Stream[A]
αf	contfun-lim	variable, Nat → Stream[A]
αp	contfun-lim	variable, Stream[A] → Bool
β	contfun-lim	variable, Stream[B]
βf	contfun-lim	variable, Stream[S] × Stream[A] → Stream[B]
μ	monotone-set-fixpoint	partial function, (A → Bool) → A → Bool → A → Bool
ν	monotone-set-fixpoint	partial function, (A → Bool) → A → Bool → A → Bool
σ	streamseq-mon-lim-old	variable, Stream[A]
σ	stream-basic	variable, Stream[A]
σ	infinite-append	variable, Stream[A]
σ	stream	variable, Stream[A]
σ	mon-lim-filter-count-old	variable, Stream[A]
σ	inf-app-list	variable, Stream[A]
σ	mon-lim-filter-count	variable, Stream[A]
σ	stream-old	variable, Stream[A]
σ	contfun-lim	variable, Stream[S]
σ	infinite-append-old	variable, Stream[A]
σ	streamseq-mon-lim	variable, Stream[A]
σ	inf-app-list-old	variable, Stream[A]
σf	streamseq-mon-lim-old	variable, Nat → Stream[A]
σf	stut-mon-old	variable, Nat → Stream[A]
σf	mon-lim-filter-count-old	variable, Nat → Stream[A]
σf	mon-lim-filter-count	variable, Nat → Stream[A]
σf	contfun-lim	variable, Nat → Stream[S]
σf	streamseq-mon-lim	variable, Nat → Stream[A]
σf	stut-mon	variable, Nat → Stream[A]
σσ	streamseq-mon-lim-old	variable, Stream[Stream[A]]
σσ	streamseq-mon-lim	variable, Stream[Stream[A]]
χ	infset-basic	function, Iset[A] → A → Bool
∅	map	constant, Map[A, B]
∅	set-basic	constant, Set[A]
∅	bag-basic	constant, Bag[A]
∅	infset-basic	constant, Iset[A]
∈	map	predicate, A × Map[A, B]
∈	list	predicate, A × List[A]
∈	assoclist	predicate, A × List[(A, B)]
∈	set-basic	predicate, A × Set[A]
∈	infset-basic	predicate, A × Iset[A]
∈	list-as-arrayinstance	predicate, A × Array[A]
∈	bag-union	predicate, A × Bag[A]
∈	string	predicate, Char × String
∈v	map+set	predicate, B × Map[A, B]
∞	nat-inf	constant, Natinf
∩	set-union	function, Set[A] × Set[A] → Set[A]
∩	infset-union	function, Iset[A] × Iset[A] → Iset[A]
∪	set-union	function, Set[A] × Set[A] → Set[A]
∪	list-as-arrayinstance	function, Array[A] × Array[A] → Array[A]
∪	bag-union	function, Bag[A] × Bag[A] → Bag[A]
∪	infset-union	function, Iset[A] × Iset[A] → Iset[A]
∪	list-set	function, List[A] × List[A] → List[A]
≤	nat	predicate, Nat × Nat
≥	nat	predicate, Nat × Nat
⊆	map	predicate, Map[A, B] × Map[A, B]
⊆	set-basic	predicate, Set[A] × Set[A]
⊆	infset-basic	predicate, Iset[A] × Iset[A]
⊆	list-as-arrayinstance	predicate, Array[A] × Array[A]
⊆	monotone-set-fixpoint	predicate, A → Bool × A → Bool
⊆	bag-union	predicate, Bag[A] × Bag[A]
⊆	list-set	predicate, List[A] × List[A]
⊆m	list-perm	predicate, List[A] × List[A]
⊆m	list-as-arrayinstance	predicate, Array[A] × Array[A]
⊑	stream	predicate, Stream[A] × Stream[A]
⊑	list-last	predicate, List[A] × List[A]
⊑	list-as-arrayinstance	predicate, Array[A] × Array[A]
⊑	stream-old	predicate, Stream[A] × Stream[A]
⊒	list-last	predicate, List[A] × List[A]
⊒	list-as-arrayinstance	predicate, Array[A] × Array[A]
⊕	map+set	function, Map[A, B] × Map[A, B] → Map[A, B]
⌝	nat-inf	function, Nat → Natinf
⌝	stream-basic	function, Nat → A → Stream[A]
⌝	stream-basic	function, List[A] → Stream[A]