Automated Theorem Proving
Term Indexing, Part II
Reiner Hähnle
Department of Computer Science
Technische Universität Darmstadt
30 June 2014
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
1 / 20
Recap
Term Indexing
Retrieve quickly candidates from a set of terms that
I
generalise
I
instantiate
I
unify
a given query term
Automata-Based Indexing
I Convert terms into p-strings
I
Use string matching techniques to identify candidates
I
Indexing techniques differ, e.g., in term traversal strategy
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
2 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
f
g
i
ATP: Term Indexing II
h
x
c
j
TU Darmstadt, Software Engineering Group
140630
3 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
next(1)
f
g
i
ATP: Term Indexing II
h
x
c
j
TU Darmstadt, Software Engineering Group
140630
3 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
after(1)
next(1)
f
g
i
ATP: Term Indexing II
h
x
c
j
TU Darmstadt, Software Engineering Group
140630
3 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
after(1)
next(1)
g
f
next(1.1)
after(1.1)
i
j
ATP: Term Indexing II
h
x
TU Darmstadt, Software Engineering Group
c
140630
3 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
after(1)
f
next(1)
g
next(1.1)
after(1.1)
i
j
h
x
c
next/after(1.1.1)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
3 / 20
Recap: Term Traversal
Let t be a term and p a position in t; assume depth-left-first traversal
nextt (p) returns position visited next after reaching position p
aftert (p) returns position visited directly after visiting the subtree
rooted at position p
q
after(1)
f
next(1)
g
next(1.1)
after(1.1)
i
j
h
x
next/after(1.2)
c
next/after(1.1.1)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
3 / 20
Code Trees: Preliminaries
Main Idea: Compile index into code for faster retrieval
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
4 / 20
Code Trees: Preliminaries
Main Idea: Compile index into code for faster retrieval
I
I
I
Algorithm for subsumption (generalization) only
Terms can be non-linear
Work with flatterm data structure
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
4 / 20
Code Trees: Preliminaries
Main Idea: Compile index into code for faster retrieval
I
I
I
Algorithm for subsumption (generalization) only
Terms can be non-linear
Work with flatterm data structure
Definition (Normalized Term)
Let t be a term and p1 , . . . , pn all positions of variable occurrences in t in
left-to-right order.
In a normalized term, called norm(t), occurrences of variables in t at
position pi have been replaced by ∗i for all i ∈ {1 . . . n}.
Caveat: different occurrences of same variable in t are replaced by
different ∗i , hence, the term norm(t) is linear
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
4 / 20
Code Trees: Preliminaries
Main Idea: Compile index into code for faster retrieval
I
I
I
Algorithm for subsumption (generalization) only
Terms can be non-linear
Work with flatterm data structure
Definition (Normalized Term)
Let t be a term and p1 , . . . , pn all positions of variable occurrences in t in
left-to-right order.
In a normalized term, called norm(t), occurrences of variables in t at
position pi have been replaced by ∗i for all i ∈ {1 . . . n}.
Caveat: different occurrences of same variable in t are replaced by
different ∗i , hence, the term norm(t) is linear
Example
t = f (a, g (x, f (x, y ))) ; norm(t) = f (a, g (∗1 , f (∗2 , ∗3 )))
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
4 / 20
Relating Terms to Normalized Terms
Need to map different variables in norm(t) to same variable in t
Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
How to check efficiently that ∗1 , ∗3 , ∗4 have equal instantiations?
Naı̈ve: check each pair (1, 3), (1, 4), (3, 4)
But only two of these checks are necessary, due to transitivity of equality
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
5 / 20
Relating Terms to Normalized Terms
Need to map different variables in norm(t) to same variable in t
Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
How to check efficiently that ∗1 , ∗3 , ∗4 have equal instantiations?
Naı̈ve: check each pair (1, 3), (1, 4), (3, 4)
But only two of these checks are necessary, due to transitivity of equality
How can we determine the smallest set of pairs requiring comparison?
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
5 / 20
Variable Check of Normalized Terms
Definition (Variable Equivalence Relation for a Term)
Let vp1 , . . . , vpn be all variable positions of l with norm(l)/vpi = ∗i .
E ⊂ IIN × IIN is a variable equivalence relation for the term l iff:
(i, j) ∈ E
ATP: Term Indexing II
⇔
l/vpi = l/vpj
TU Darmstadt, Software Engineering Group
140630
6 / 20
Variable Check of Normalized Terms
Definition (Variable Equivalence Relation for a Term)
Let vp1 , . . . , vpn be all variable positions of l with norm(l)/vpi = ∗i .
E ⊂ IIN × IIN is a variable equivalence relation for the term l iff:
(i, j) ∈ E
⇔
l/vpi = l/vpj
Definition (Frame, Computation Sequence)
A sub-relation B ⊆ E is a frame of E iff B ∗ = E .
B is a minimal frame of E if there is no frame C such that C ( B.
A sequence S = (u1 , v1 ), . . . , (uk , vk ) is a computation sequence of E if
{S} is a minimal frame of E and ui < vi for all i ∈ {1, . . . , k}.
A computation sequence (u1 , v1 ), . . . , (uk , vk ) is canonical if u1 is the
minimal element of E and (u1 , v1 ) < . . . < (uk , vk ), where < is the
component-wise order on IIN × IIN.
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
6 / 20
Variable Check of Normalized Terms: Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
7 / 20
Variable Check of Normalized Terms: Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
Equivalence classes of E : {1, 3, 4}
ATP: Term Indexing II
{2}
TU Darmstadt, Software Engineering Group
140630
7 / 20
Variable Check of Normalized Terms: Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
Equivalence classes of E : {1, 3, 4}
{2}
Frames of E : {(1, 3), (3, 4)}, {(1, 3), (1, 4)}, {(1, 4), (3, 4)}
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
7 / 20
Variable Check of Normalized Terms: Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
Equivalence classes of E : {1, 3, 4}
{2}
Frames of E : {(1, 3), (3, 4)}, {(1, 3), (1, 4)}, {(1, 4), (3, 4)}
Computation sequences of E :
1. (1, 3), (3, 4)
2. (1, 3), (1, 4)
3. (1, 4), (3, 4)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
7 / 20
Variable Check of Normalized Terms: Example
norm(f (g (x1 , x2 ), h(x1 , x1 ))) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
Equivalence classes of E : {1, 3, 4}
{2}
Frames of E : {(1, 3), (3, 4)}, {(1, 3), (1, 4)}, {(1, 4), (3, 4)}
Computation sequences of E :
1. (1, 3), (3, 4)
2. (1, 3), (1, 4)
3. (1, 4), (3, 4)
The canonical computation sequence is (1, 3), (3, 4)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
7 / 20
A Subsumption Algorithm
// return success iff l subsumes t
subsume(Term l, Term t) {
Pos[] subst; //array for storing pos in l
posl , post = , ;
while (posl != null) {
if (norm(l)/posl = *i ) {
subst[i] = posl ;
post , posl = aftert (post ), afterl (posl )
} else {
if (root(l/posl ) != root(t/post )) return fail
else post , posl = nextt (post ), nextl (posl )
} } }
// let <u[1],v[1]>, ..., <u[n],v[n]> be canoncial comp. seq.
for (i = 1 to n) {
if (t/subst[u[i]] != t/subst[v[i]]) return fail
}
return success;
Traversal
ATP: Term Indexing II
Occur Check
TU Darmstadt, Software Engineering Group
140630
8 / 20
Specialization of Subsumption Algorithm
Program Specialization / Partial Evaluation
Application of the s-m-n theorem:
Given: Program p(x1 , . . . , xm , y1 , . . . , yn ) and x1 , . . . , xm static
n (p, x , . . . , x ) such that:
s-m-n theorem: there is specialization p 0 := sm
1
m
(∀y1 , . . . , yn ) p 0 (y1 , . . . , yn ) = p(x1 , . . . , xm , y1 , . . . , yn )
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
9 / 20
Specialization of Subsumption Algorithm
Program Specialization / Partial Evaluation
Application of the s-m-n theorem:
Given: Program p(x1 , . . . , xm , y1 , . . . , yn ) and x1 , . . . , xm static
n (p, x , . . . , x ) such that:
s-m-n theorem: there is specialization p 0 := sm
1
m
(∀y1 , . . . , yn ) p 0 (y1 , . . . , yn ) = p(x1 , . . . , xm , y1 , . . . , yn )
Optimize the code of p by computing an efficient p 0 , which exploits that
x1 , . . . , xm are known when p 0 is constructed
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
9 / 20
Specialization of Subsumption Algorithm
Program Specialization / Partial Evaluation
Application of the s-m-n theorem:
Given: Program p(x1 , . . . , xm , y1 , . . . , yn ) and x1 , . . . , xm static
n (p, x , . . . , x ) such that:
s-m-n theorem: there is specialization p 0 := sm
1
m
(∀y1 , . . . , yn ) p 0 (y1 , . . . , yn ) = p(x1 , . . . , xm , y1 , . . . , yn )
Optimize the code of p by computing an efficient p 0 , which exploits that
x1 , . . . , xm are known when p 0 is constructed
Idea: For each index term l specialize subsume(l,t)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
9 / 20
The Subsumption Algorithm, Revisited
// return success iff l subsumes t
subsume(Term l, Term t) {
Pos[] subst; //array for storing pos in l
posl , post = , ;
while (posl != null) { // (pos|after|next)l fixed in each iteration
// l static: loop has fixed bound ⇒ unwind!
if (norm(l)/posl = *i ) {
subst[i] = posl ;
post , posl = aftert (post ), afterl (posl )
} else {
if (root(l/posl ) != root(t/post )) return fail
else post ,posl = nextt (post ), nextl (posl )
} } }
// let <u[1],v[1]>, ..., <u[n],v[n]> be canoncial comp. seq.
for (i = 1 to n) {
if (t/subst[u[i]] != t/subst[v[i]]) return fail
}
return success;
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
10 / 20
Specialized Algorithm for l = f (g (x1 , x2 ), h(x1 , x1 ))
subsume(Term t) {
norm(l) = f (g (∗1 , ∗2 ), h(∗3 , ∗4 ))
p = ;
if (root(t/p) != f) return fail ;
p = nextt (p);
if (root(t/p) != g) return fail ;
p = nextt (p);
subst[1] = p;
p = aftert (p);
subst[2] = p;
p = aftert (p);
if (root(t/p) != h) return fail;
p = nextt (p);
subst[3] = p;
p = aftert (p);
subst[4] = p;
p = aftert (p);
if (t/subst[1] != t/subst[3]) return fail;
if (t/subst[3] != t/subst[4]) return fail
}
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
11 / 20
Specialized Algorithm for l = f (g (x1 , x2 ), h(x1 , x1 ))
subsume(Term t) {
p = ;
if (root(t/p) != f) return fail;
p = nextt (p);
if (root(t/p) != g) return fail;
p = nextt (p);
subst[1] = p;
p = aftert (p);
subst[2] = p;
p = aftert (p);
if (root(t/p) != h) return fail;
p = nextt (p);
subst[3] = p;
p = aftert (p);
subst[4] = p;
p = aftert (p);
if (t/subst[1] != t/subst[3]) return fail;
if (t/subst[3] != t/subst[4]) return fail;
}
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
12 / 20
Specialized Algorithm for l = f (g (x1 , x2 ), h(x1 , x1 ))
subsume(Term t) {
initl : Initialize(m1)
p = ;
if (root(t/p) != f) return fail;
m1 : Chk(f,m2 ,f )
p = nextt (p);
if (root(t/p) != g) return fail;
m2 : Chk(g,m3 ,f )
p = nextt (p);
subst[1] = p;
m3 : Put(1,m4 )
p = aftert (p);
subst[2] = p;
m4 : Put(2,m5 )
p = aftert (p);
if (root(t/p) != h) return fail;
m5 : Chk(h,m6 ,f )
p = nextt (p);
subst[3] = p;
m6 : Put(3,m7 )
p = aftert (p);
subst[4] = p;
m7 : Put(4,m8 )
p = aftert (p);
if (t/subst[1] != t/subst[3]) return fail; m8 : Cmp(1,3,m9 ,f )
if (t/subst[3] != t/subst[4]) return fail; m9 : Cmp(3,4,m10 ,f)
m10 : Success | f : Fail
}
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
12 / 20
An Abstract Subsumption Machine
Registers
I p to store a position
I subst is an array of positions
I pc the program counter storing the label of the current instruction
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
13 / 20
An Abstract Subsumption Machine
Registers
I p to store a position
I subst is an array of positions
I pc the program counter storing the label of the current instruction
Instruction Set
Initialize (m1 )
Chk(s, m1 , m2 )
p=; goto m1
if (root(t/p) = s) {
p = nextt (p); goto m1
} else { goto m2 }
Put(i, m1 )
subst[i] = p;
p = aftert (p);
goto m1
Cmp(i, j, m1 , m2 )
if (t/subst[i] = t/subst[j]) goto m1
else goto m2
return success
return fail
Success
Fail
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
13 / 20
Compilation of Subsumption Code
Traversal Code
p1 , . . . , pn are positions of l in linear (depth-left-first) order
Sequence m1 : J1 , m2 : J2 , . . . , mk : Jk is the traversal code of l with:
Chk(root(l)/pi , mi+1 , f ) , if l/pi is not a variable
Jl =
Put(k, mi+1 )
, if norm(l)/pi = ∗k
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
14 / 20
Compilation of Subsumption Code
Traversal Code
p1 , . . . , pn are positions of l in linear (depth-left-first) order
Sequence m1 : J1 , m2 : J2 , . . . , mk : Jk is the traversal code of l with:
Chk(root(l)/pi , mi+1 , f ) , if l/pi is not a variable
Jl =
Put(k, mi+1 )
, if norm(l)/pi = ∗k
Compare Code
Let (u1 , v1 ), . . . , (un , vn ) be a canonical computation sequence
The compare code is the the sequence of instructions (1 ≤ i ≤ n):
mk+i : Cmp(ui , vi , mk+i+1 , f )
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
14 / 20
Compilation of Subsumption Code
Traversal Code
p1 , . . . , pn are positions of l in linear (depth-left-first) order
Sequence m1 : J1 , m2 : J2 , . . . , mk : Jk is the traversal code of l with:
Chk(root(l)/pi , mi+1 , f ) , if l/pi is not a variable
Jl =
Put(k, mi+1 )
, if norm(l)/pi = ∗k
Compare Code
Let (u1 , v1 ), . . . , (un , vn ) be a canonical computation sequence
The compare code is the the sequence of instructions (1 ≤ i ≤ n):
mk+i : Cmp(ui , vi , mk+i+1 , f )
Return Code mk+n+1 : Success and f : Fail.
⇒ All together is the code sequence for l.
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
14 / 20
Indexing
Task: Test whether a term t is subsumed by a term l of an index set
Let L denote the set of index terms
A possible indexing procedure:
1. Compile each l ∈ L into its code sequence
2. Run the code sequence for each l
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
15 / 20
Indexing
Task: Test whether a term t is subsumed by a term l of an index set
Let L denote the set of index terms
A possible indexing procedure:
1. Compile each l ∈ L into its code sequence
2. Run the code sequence for each l
Can we optimize the procedure?
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
15 / 20
Indexing
Task: Test whether a term t is subsumed by a term l of an index set
Let L denote the set of index terms
A possible indexing procedure:
1. Compile each l ∈ L into its code sequence
2. Run the code sequence for each l
Can we optimize the procedure?
Yes! Extend the abstract subsumption machine to execute code trees
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
15 / 20
Observation: Common Code Prefixes
L = {f (f (x1 , x2 ), f (x1 , x1 )), f (f (x1 , x2 ), f (x2 , x2 ))}
initl: Initialize(m1)
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(1,3,m9,f)
m9: Compare(3,4,m10,f)
m10: Success
f: Fail
ATP: Term Indexing II
initl: Initialize(m1)
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(2,3,m9,f)
m9: Compare(3,4,m10,f)
m10: Success
f: Fail
TU Darmstadt, Software Engineering Group
140630
16 / 20
Observation: Common Code Prefixes
L = {f (f (x1 , x2 ), f (x1 , x1 )), f (f (x1 , x2 ), f (x2 , x2 ))}
initl: Initialize(m1)
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(1,3,m9,f)
m9: Compare(3,4,m10,f)
m10: Success
f: Fail
initl: Initialize(m1)
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(2,3,m9,f)
m9: Compare(3,4,m10,f)
m10: Success
f: Fail
Prefix sharing of terms reflected in prefix sharing of code sequences
I Normalization
I Separation between traversal and compare code
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
16 / 20
Combined Code Sequences in Code Tree
initl: Initialize(m1)
f: Fail
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(1,3, m9, m11)
m9: Compare(3,4, m10, f)
m10: Success
ATP: Term Indexing II
m11: Compare(2,3,m12,f)
m12: Compare(3,4,m13,f)
m13: Success
TU Darmstadt, Software Engineering Group
140630
17 / 20
Combined Code Sequences in Code Tree
initl: Initialize(m1)
f: Fail
m1: Chk(f,m2,f)
m2: Chk(f,m3,f)
m3: Put(1, m4)
m4: Put(2, m5)
m5: Chk(f,m6,f)
m6: Put(3, m7)
m7: Put(4, m8)
m8: Compare(1,3, m9, m11)
m9: Compare(3,4, m10, f)
m10: Success
m11: Compare(2,3,m12,f)
m12: Compare(3,4,m13,f)
m13: Success
In case of failure for m9 we need to backtrack!
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
17 / 20
Extending Abstract Subsumption Machine
Registers
I
p position, subst array of positions, pc program counter as before
I
backtr stack storing backtracking points, i.e., pair (label, position)
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
18 / 20
Extending Abstract Subsumption Machine
Registers
I
p position, subst array of positions, pc program counter as before
I
backtr stack storing backtracking points, i.e., pair (label, position)
Instruction Set
Initialize (m1 )
Chk(s, m1 , m2 )
p=; backtr = new Stack(); goto m1
if (root(t/p) = s) {
p = nextt (p); backtr.push(m2, p); goto m1
} else goto m2
Put(i, m1 )
subst[i]=p; p = aftert (p); goto m1
Cmp(i, j, m1 , m2 )
if (l/subst[i] = l/subst[j]) {
backtr.push(m2, p); goto m1
} else goto m2
return success
Success
Fail
ATP: Term Indexing II
if (backtr.isEmpty()) {return fail};
(lbl, p) = backtr.pop(); goto lbl
TU Darmstadt, Software Engineering Group
140630
18 / 20
Term Indexing: Summary
I
Automata-Based Indexing
I
I
I
I
String matching techniques
Term traversal strategy decides amount of common prefix sharing
“Easy” to implement
Code-Trees
I
I
I
Program specialisation technique
Reuse common control flow structure
Used in state-of-art resolution theorem prover Vampire
I
Most theorem provers implement more than one indexing technique!
I
Indexing less crucial for tableau calculi, because of
space efficiency, lack of subsumption rule
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
19 / 20
Literature
[1]
R. Sekar, I. V. Ramakrishnan, and Andrei Voronkov.
Term Indexing.
In Alan Robinson and Andrei Voronkov, editors.
Handbook of Automated Reasoning, chapter 26, pages 1853–1963.
Elsevier Science B.V., 2001.
ATP: Term Indexing II
TU Darmstadt, Software Engineering Group
140630
20 / 20