[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
# .	heap	f	Heap[A] → Nat
# .	set-basic	f	Set[A] → Nat
# .	tree	f	Tree[A] → Nat
# .	list-data	f	List[A] → Nat
. '	list	f	A → List[A]
. ( . )	heap	pf	Heap[A] × Ref[A] → A with λ h, r. r ≠ null ∧ r ∈ h
. ( . )	tree-path	pf	Tree[A] × List[Bool] → Tree[A] with λ t, p. p ∈ t
. ( . := . )	heap	pf	Heap[A] × Ref[A] × A → Heap[A] with λ h, r, o. r ≠ null ∧ r ∈ h
. ( . := . )	tree-path	pf	Tree[A] × List[Bool] × Tree[A] → Tree[A] with λ t, p, t0. p ∈ t
. * .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. + .	nat-basic	f	Nat × Nat → Nat
. + .	list-data	f	A × List[A] → List[A]
. + .	list	f	List[A] × List[A] → List[A]
. + .	list	f	List[A] × A → List[A]
. ++ .	set-basic	f	Set[A] × A → Set[A]
. ++ .	heap	pf	Heap[A] × Ref[A] → Heap[A] with λ h, r. r ≠ null ∧ ¬ r ∈ h
. +1	nat-basic	f	Nat → Nat
. +2 .	list	f	A × A → List[A]
. - .	nat	pf	Nat × Nat → Nat with λ n, m. n ≥ m
. -* .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. -- .	set-union	f	Set[A] × A → Set[A]
. -- .	heap	pf	Heap[A] × Ref[A] → Heap[A] with λ h, r. r ≠ null ∧ r ∈ h
. -> .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. -⊗ .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. -1	nat-basic	pf	Nat → Nat with λ n. n ≠ 0
. < .	nat-basic	p	Nat × Nat
. < .	list-data	p	List('A) × List('A)
. => .	maplet	f	Ref[A] × A → Heap[A] → Bool
. =>?	ex-maplet	f	Ref[A] → Heap[A] → Bool
. =>_	ex-maplet	f	Ref[A] → Heap[A] → Bool
. > .	nat	p	Nat × Nat
. \ .	set-union	f	Set[A] × Set[A] → Set[A]
. \ .	heapfuns	f	Heap[A] × Set[Ref[A]] → Heap[A]
. \ .	heapfuns	f	Heap[A] × Heap[A] → Heap[A]
. ∈ .	heap	p	Ref('A) × Heap('A)
. ∈ .	set-basic	p	'A × Set('A)
. ∈ .	list	p	'A × List('A)
. ∈ .	tree-path	p	List(Bool) × Tree('A)
. ∩ .	set-union	f	Set[A] × Set[A] → Set[A]
. ∪ .	set-union	f	Set[A] × Set[A] → Set[A]
. ∪ .	heapfuns	f	Heap[A] × Heap[A] → Heap[A]
. ≡ .	separation	p	Heap('A) × Heap('A)
. ≤ .	nat	p	Nat × Nat
. ≥ .	nat	p	Nat × Nat
. ⊆ .	set-basic	p	Set('A) × Set('A)
. ⊆ .	heapfuns	p	Heap('A) × Heap('A)
. ⊆ .	heap-sep	p	(Heap('A) → Bool) × (Heap('A) → Bool)
. ⊗ .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. ⊥ .	heapfuns	p	Heap('A) × Heap('A)
. and .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. exists ( . )	set-union	p	Set('A) × ('A → Bool)
. filter ( . )	set-union	f	Set[A] × (A → Bool) → Set[A]
. foldLeft ( . )	list	f	List[A] × B × (B × A → B) → B
. forall ( . )	set-union	p	Set('A) × ('A → Bool)
. head	list-data	pf	List[A] → A with λ x. x ≠ []
. left	node	f	Node[A] → Ref[Node[A]]
. left	tree	pf	Tree[A] → Tree[A] with λ t. t ≠ leaf
. left:= .	node	f	Node[A] × Ref[Node[A]] → Node[A]
. left:= .	tree	pf	Tree[A] × Tree[A] → Tree[A] with λ t, t0. t ≠ leaf
. map ( . )	set-union	f	Set[A] × (A → B) → Set[B]
. map ( . )	list	f	List[A] × (A → B) → List[B]
. or .	heap-sep	f	(Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
. right	node	f	Node[A] → Ref[Node[A]]
. right	tree	pf	Tree[A] → Tree[A] with λ t. t ≠ leaf
. right:= .	node	f	Node[A] × Ref[Node[A]] → Node[A]
. right:= .	tree	pf	Tree[A] × Tree[A] → Tree[A] with λ t, t0. t ≠ leaf
. tail	list-data	pf	List[A] → List[A] with λ x. x ≠ []
. val	node	f	Node[A] → A
. val	tree	pf	Tree[A] → A with λ t. t ≠ leaf
. val:= .	node	f	Node[A] × A → Node[A]
. val:= .	tree	pf	Tree[A] × A → Tree[A] with λ t, val. t ≠ leaf
[]	list-data	c	List[A]
_∃ .	maplet	f	(B → Heap[A] → Bool) → Heap[A] → Bool
_∃ .	maplet	f	(B × C → Heap[A] → Bool) → Heap[A] → Bool
_∃ .	maplet	f	(B × C × D → Heap[A] → Bool) → Heap[A] → Bool
{ . }	set-union	f	A → Set[A]
{ . }	heap-sep	f	Heap[A] → Heap[A] → Bool
∅	heap	c	Heap[A]
∅	set-basic	c	Set[A]
⌜ . ⌝	heap-sep	f	Bool → Heap[A] → Bool
Heap	heap	s
List	list-data	s
Nat	nat-basic	s
Node	node	s
Ref	polyref	s
Set	set-basic	s
Tree	tree	s
True	separation	p	Bool
a	linked-tree-path	v	A
alloc#	heap	pr	: Heap[A] → Ref[A] (nondeterministic)
b	linked-tree-path	v	Bool
branch	tree	f	Tree[A] × A × Tree[A] → Tree[A]
disjoint	set-union	p	Set('A) × Set('A)
dom .	heapfuns	f	Heap[A] → Set[Ref[A]]
emp	heap-sep	p	Heap('A)
false	heap-sep	p	Heap('A)
h	linked-tree-path	v	Heap[Node[A]]
hP	linked-tree-path	v	Heap[Node[A]] → Bool
ite	heap-sep	f	Bool × (Heap[A] → Bool) × (Heap[A] → Bool) → Heap[A] → Bool
leaf	tree	c	Tree[A]
mknode	node	f	Ref[Node[A]] × A × Ref[Node[A]] → Node[A]
nd	linked-tree-path	v	Node[A]
not .	heap-sep	f	(Heap[A] → Bool) → Heap[A] → Bool
null	polyref	c	Ref[A]
p	linked-tree-path	v	List[Bool]
precise	heap-sep	p	(Heap('A) → Bool)
r	linked-tree-path	v	Ref[Node[A]]
t	linked-tree-path	v	Tree[A]
tr	linked-tree	f	Ref[Node[A]] × Tree[A] → Heap[Node[A]] → Bool
trp	linked-tree-path	pf	Ref[Node[A]] × Tree[A] × List[Bool] × Ref[Node[A]] → Heap[Node[A]] → Bool with λ r, t, p, r0. λ h. p ∈ t
true	heap-sep	p	Heap('A)