Automated Theorem Proving: Scaling to 1000 Threads

1
Automated Theorem ProvingScaling to 1000 Threads

• Nathan Bronson
• CS315B
• 31 May 2007

2
Automated Theorem Proving

• First Order Logic with Equality
• Variables, constants, predicates, functions,
  logical operators, quantifiers
• Can be used to generate human-readable proofs
• Much more expressive than a SAT solver
• man(socrates), mortal(x) or not man(x), therefore
  mortal(socrates)
• General Algorithm
• Start with user-supplied axioms
• Include the negation of the goal
• Extend database of known clauses by applying the
  rules of FOL
• Entailment of false demonstrates contradiction in
  axioms, proof of goal
• Saturation (all useful clauses generated)
  demonstrates goal is not provable
• Problem Many rules combine two clauses to
  produce a new one
• Combinatoric explosion!

3
Choices

• How to choose pairs of clauses for rule
  application?
• We would like to avoid duplicating past pairs
• How do we remember without huge space overhead?
• We would like to eventually process all (useful)
  pairs
• We would like to process good pairs sooner
• Most improvements in ATP since 1970's have come
  here
• Solution Segregate clauses into U and A
• U is unprocessed clauses
• A is active clauses
• Invariant all (useful) pairs drawn from A have
  been processed
• Indexes into A allow useful pairs to be found
  without a linear scan
• Subsumption Discard specific clause if general
  clause known
• For example, discard f(a)b if it is known that
  f(x)b

4
State of the (Sequential) Art
The Given Clause Algorithm U unprocessed A
active g new given clause
5
Parallelism

• Lots of opportunities
• Index effectiveness varies
• Wildcards in trie
• Search for elements
• Load balancing is difficult
• Observation U A2
• A is relatively small

6
Parallelism
7
Strategy for Massive Parallelism

• Allow superfluous (but true) clauses to be added
  to A
• Performance impact will be small if they are
  quickly removed
• Circular superfluousness prevents saturation
• Mark clauses as possibly superfluous (PS)
• Clauses generated from a PS clause are also PS
• Maintain PS dependencies, GC clauses if
  definitely superfluous
• Clauses may not be dequeued from U until no
  longer PS
• Pipeline everything, use credits for flow control
• Replicate A, partition U across nodes
• Loop parallelism within node
• Assign clauses from U to a node
• Responsible node must determine PS
• Other nodes may blindly insert into A then remove
  later if necessary

8
PipelinedDesign
9
Scaling Limits

• Extra work okay past 1,000 threads
• Every node must insert and remove unassigned
  clauses from A
• Work per assigned clause is O(AC), per
  unassigned clause is O(log A)
• A gtgt 1,000,000 - not vigorously proved
• Possible superfluousness must be tracked
• Work per clause is O(1), assuming probability of
  superfluousness is fixed
• Work is discarded if inputs were superfluous
• PS entries make up only a small portion of A
• Inter-node latency okay way past 1,000 threads
• Except for the bad choices effect U operates as
  a giant latency buffer
• Optimal proofs have very few steps compared to
  total number of clauses
• Bad choices effect ?
• Best new clause may be blocked because it is
  marked PS
• Dependent on problem, fitness heuristic, phase of
  the moon?

10
References

• Maria P. Bonacina. A taxonomy of parallel
  strategies for deduction. Annals of Mathematics
  and Artificial Intelligence, volume 29, pages
  223-257, 2000.
• Ewing L. Lusk and William W. McCune. Experiments
  with Roo, a parallel automated deduction system.
  In Parallelization in Inference Systems, Springer
  Lecture Notes in Artificial Intelligence 590,
  pages 139-162, Springer-Verlag, 1990.
• William W. McCune. Otter 3.3 reference manual and
  guide. Technical report, ANL, 2003.
• Stephan Schulz. Algorithms and Data Structures
  for First-Order Equational Deduction. Slides from
  a talk at the 6th International Workshop on the
  Implementation of Logics, 2006.
• J. Schumann and R. Letz. Partheo A
  high-performance parallel theorem prover. In M.
  E. Stickel, editor, Proceedings of the 10th
  International Conference on Automated Deduction,
  Springer Lecture Notes in Artificial Intelligence
  449, pages 40-56. Springer-Verlag, 1990.