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

Back to main index. View the specification. View theorem base summary, View theorem base listing, the used properties by spec, the dependency list, the symbol table,

Signature symbols in this unit

Symbol	Specification	Kind	Type
# .	ref-map	f	ref-map → nat
# .	ref-map	f	refset → nat
# .	list-data	f	list → nat
# .	successors	f	successors → nat
# .	heap	f	heap → nat
# .	set-basic	f	set → nat
. '	list	f	elem → list
. * .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. + .	list	f	elem × elem → list
. + .	nat-basic2	f	nat × nat → nat
. + .	list	f	list × elem → list
. + .	list	f	list × list → list
. + .	list-data	f	elem × list → list
. ++ .	ref-map	f	refset × ref → refset
. ++ .	heap	f	heap × ref → heap
. ++ .	set-basic	f	set × elem → set
. +1	nat-basic1	f	nat → nat
. - .	nat	f	nat × nat → nat
. -* .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. -- .	ref-map	f	ref-map × ref → ref-map
. -- .	heap	f	heap × ref → heap
. -- .	ref-map	f	refset × ref → refset
. -- .	set-union	f	set × elem → set
. -- .	successors	f	successors × elem → successors
. -> .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. -⊗ .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. -1	nat-basic1	f	nat → nat
. .edges	node	f	node → successors
. .edges:= .	node	f	node × successors → node
. .first	list-data	f	list → elem
. .rest	list-data	f	list → list
. .value	node	f	node → elem
. .value:= .	node	f	node × elem → node
. < .	list-data	p	list × list
. < .	nat-basic1	p	nat × nat
. => .	node-heap	f	ref × node → heap → bool
. =>?	maplet	f	ref → heap → bool
. =>_	maplet	f	ref → heap → bool
. > .	nat	p	nat × nat
. [ . ]	ref-map	f	ref-map × ref × ref → ref-map
. [ . ]	ref-map	f	ref-map × ref → ref
. [ . ]	node-heap	f	heap × ref × node → heap
. [ . ]	successors	f	successors × elem × ref → successors
. [ . ]	node-heap	f	heap × ref → node
. [ . ]	successors	f	successors × elem → ref
. \ .	heap	f	heap × heap → heap
. \ .	ref-map	f	refset × refset → refset
. \ .	heap	f	heap × refset → heap
. \ .	ref-map	f	ref-map × refset → ref-map
. \ .	successors	f	successors × set → successors
. \ .	set-union	f	set × set → set
. × .	ref-map	f	ref × ref → refref
. × .	successors	f	elem × ref → elemref
. ∈ .	list	p	elem × list
. ∈ .	heap	p	ref × heap
. ∈ .	successors	p	ref × successors
. ∈ .	ref-map	p	ref × ref-map
. ∈ .	set-basic	p	elem × set
. ∈ .	ref-map	p	refref × ref-map
. ∈ .	successors	p	elemref × successors
. ∈ .	ref-map	p	ref × refset
. ∈ .	successors	p	elem × successors
. ∈ran .	ref-map	p	ref × ref-map
. ∩ .	ref-map	f	refset × refset → refset
. ∩ .	set-union	f	set × set → set
. ∪ .	ref-map	f	refset × refset → refset
. ∪ .	set-union	f	set × set → set
. ∪ .	heap	f	heap × heap → heap
. ≡ .	separation	p	heap × heap
. ≤ .	nat	p	nat × nat
. ≥ .	nat	p	nat × nat
. ⊆ .	heap-sep	p	(heap → bool) × (heap → bool)
. ⊆ .	ref-map	p	ref-map × ref-map
. ⊆ .	heap	p	heap × heap
. ⊆ .	ref-map	p	refset × refset
. ⊆ .	set-basic	p	set × set
. ⊆ .	successors	p	successors × successors
. ⊗ .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. ⊥ .	heap	p	heap × heap
. and .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
. or .	heap-sep	f	(heap → bool) × (heap → bool) → heap → bool
[]	list-data	c	list
_∃ .	node-heap	f	(node → heap → bool) → heap → bool
_∃ .	maplet	f	(ref → heap → bool) → heap → bool
_∃ .	maplet	f	(ref × ref → heap → bool) → heap → bool
{ . }	ref-map	f	ref → refset
{ . }	set-union	f	elem → set
{ . }	heap-sep	f	heap → heap → bool
φe	copy	v	successors × successors × heap × heap × ref-map × ref-map → bool
φe0	copy	v	successors × successors × heap × heap × ref-map × ref-map → bool
φe1	copy	v	successors × successors × heap × heap × ref-map × ref-map → bool
φn	copy	v	ref × ref × heap × heap × ref-map × ref-map → bool
φn0	copy	v	ref × ref × heap × heap × ref-map × ref-map → bool
φn1	copy	v	ref × ref × heap × heap × ref-map × ref-map → bool
∅	ref-map	c	ref-map
∅	ref-map	c	refset
∅	successors	c	successors
∅	set-basic	c	set
∅	heap	c	heap
⌜ . ⌝	heap-sep	f	bool → heap → bool
H	heap	v	heap
H0	heap	v	heap
H1	heap	v	heap
H2	heap	v	heap
Node	node	f	elem × successors → node
Node	functions	f	elem → node
P	heap-sep	v	heap → bool
P0	heap-sep	v	heap → bool
P1	heap-sep	v	heap → bool
P2	heap-sep	v	heap → bool
True	separation	p	bool
a	elem	v	elem
a0	store	v	elem
alloc	ops-impl	pr	: ref, heap
apply	functions	f	heap × ref-map → heap
apply	functions	f	successors × ref-map → successors
b	elem	v	elem
bv	heap-sep	v	bool
c	elem	v	elem
closed	functions	p	heap
closed	functions	p	successors × heap
connected	functions	p	ref × heap
copy#	copy	pr	ref : ref, heap
copy-edges-prepost	copy	p	successors × heap × heap × ref-map
copy-node-prepost	copy	p	heap × heap × ref-map
copy_edges#	copy	pr	successors : successors, ref-map, heap
copy_node#	copy	pr	ref : ref, ref-map, heap
dom .	functions	f	heap → refset
dom .	ref-map	f	ref-map → refset
dom .	successors	f	successors → set
elem	elem	s
elemref	successors	s
elemrefvar	successors	v	elemref
emp	heap-sep	p	heap
false	heap-sep	p	heap
free	ops-impl	pr	ref : heap
heap	heap	s
hom	functions	p	heap × ref-map × heap
inj	functions	p	ref-map
list	list-data	s
m	nat-basic2	v	nat
map	ref-map	v	ref-map
map0	ref-map	v	ref-map
map1	ref-map	v	ref-map
map2	ref-map	v	ref-map
n	nat-basic1	v	nat
n0	nat-basic1	v	nat
n1	nat-basic1	v	nat
nat	nat-basic1	s
nd	node	v	node
nd0	node-heap	v	node
nd1	node-heap	v	node
node	node	s
not .	heap-sep	f	(heap → bool) → heap → bool
null	ref	c	ref
oP	node-heap	v	node → heap → bool
path	functions	p	list × ref × ref × heap
precise	heap-sep	p	(heap → bool)
r	ref	v	ref
r0	ref	v	ref
r1	ref	v	ref
r2	ref-map	v	ref
r3	ref-map	v	ref
r4	ref-map	v	ref
r5	ref-map	v	ref
r6	ref-map	v	ref
rP	maplet	v	ref → heap → bool
ran .	functions	f	ref-map → refset
reachable	functions	p	ref × ref × heap
reachset	functions	f	ref × heap → refset
read	node-heap	pr	ref, heap : node
recursive-edges-property	copy	p	nat × (successors × successors × heap × heap × ref-map × ref-map → bool)
recursive-node-property	copy	p	nat × (ref × ref × heap × heap × ref-map × ref-map → bool)
recursive-property	copy	p	(ref × ref × heap × heap × ref-map × ref-map → bool) × (successors × successors × heap × heap × ref-map × ref-map → bool)
ref	ref	s
ref-map	ref-map	s
refref	ref-map	s
refrefvar	ref-map	v	refref
refset	ref-map	s
rrP	maplet	v	ref × ref → heap → bool
rs	ref-map	v	refset
rs0	ref-map	v	refset
rs1	ref-map	v	refset
rs2	ref-map	v	refset
s	set-basic	v	set
s0	set-basic	v	set
s1	set-basic	v	set
s2	set-basic	v	set
set	set-basic	s
succ	successors	v	successors
succ0	successors	v	successors
succ1	successors	v	successors
succ2	successors	v	successors
successors	successors	s
true	heap-sep	p	heap
write	node-heap	pr	ref, node : heap
x	list-data	v	list
x0	list-data	v	list
x1	list-data	v	list
x2	list-data	v	list
y	list-data	v	list
y0	list-data	v	list
y1	list-data	v	list
y2	list-data	v	list
z	list-data	v	list
z0	list-data	v	list
z1	list-data	v	list
z2	list-data	v	list