|
1 Introduction and Basic Concepts |
|
|
1 | (26) |
|
1.1 Two Approaches to Formal Reasoning |
|
|
3 | (2) |
|
|
3 | (1) |
|
1.1.2 Proof by Enumeration |
|
|
4 | (1) |
|
1.1.3 Deduction and Enumeration |
|
|
5 | (1) |
|
|
5 | (3) |
|
1.3 Normal Forms and Some of Their Properties |
|
|
8 | (6) |
|
1.4 The Theoretical Point of View |
|
|
14 | (4) |
|
1.4.1 The Problem We Solve |
|
|
17 | (1) |
|
1.4.2 Our Presentation of Theories |
|
|
18 | (1) |
|
1.5 Expressiveness vs. Decidability |
|
|
18 | (2) |
|
1.6 Boolean Structure in Decision Problems |
|
|
20 | (2) |
|
1.7 Logic as a Modeling Language |
|
|
22 | (1) |
|
|
23 | (1) |
|
|
24 | (3) |
|
2 Decision Procedures for Propositional Logic |
|
|
27 | (32) |
|
|
27 | (2) |
|
|
27 | (2) |
|
|
29 | (21) |
|
2.2.1 The Progress of SAT Solving |
|
|
29 | (2) |
|
|
31 | (1) |
|
2.2.3 BCP and the Implication Graph |
|
|
32 | (6) |
|
2.2.4 Conflict Clauses and Resolution |
|
|
38 | (4) |
|
2.2.5 Decision Heuristics |
|
|
42 | (3) |
|
2.2.6 The Resolution Graph and the Unsatisfiable Core |
|
|
45 | (1) |
|
2.2.7 Incremental Satisfiability |
|
|
46 | (2) |
|
2.2.8 From SAT to the Constraint Satisfaction Problem |
|
|
48 | (1) |
|
2.2.9 SAT Solvers: Summary |
|
|
49 | (1) |
|
|
50 | (4) |
|
|
50 | (1) |
|
2.3.2 Propositional Logic |
|
|
51 | (1) |
|
|
51 | (1) |
|
|
52 | (1) |
|
|
53 | (1) |
|
|
54 | (1) |
|
|
54 | (4) |
|
|
58 | (1) |
|
3 From Propositional to Quantifier-Free Theories |
|
|
59 | (18) |
|
|
59 | (2) |
|
3.2 An Overview of DPLL(T) |
|
|
61 | (3) |
|
|
64 | (2) |
|
3.4 Theory Propagation and the DPLL(T) Framework |
|
|
66 | (6) |
|
3.4.1 Propagating Theory Implications |
|
|
66 | (3) |
|
3.4.2 Performance, Performance |
|
|
69 | (1) |
|
3.4.3 Returning Implied Assignments Instead of Clauses |
|
|
70 | (1) |
|
3.4.4 Generating Strong Lemmas |
|
|
71 | (1) |
|
3.4.5 Immediate Propagation |
|
|
72 | (1) |
|
|
72 | (1) |
|
|
73 | (2) |
|
|
75 | (2) |
|
4 Equalities and Uninterpreted Functions |
|
|
77 | (20) |
|
|
77 | (2) |
|
4.1.1 Complexity and Expressiveness |
|
|
77 | (1) |
|
|
78 | (1) |
|
4.1.3 Removing the Constants: a Simplification |
|
|
78 | (1) |
|
4.2 Uninterpreted Functions |
|
|
79 | (6) |
|
4.2.1 How Uninterpreted Functions Are Used |
|
|
80 | (1) |
|
4.2.2 An Example: Proving Equivalence of Programs |
|
|
81 | (4) |
|
|
85 | (1) |
|
4.4 Functional Consistency Is Not Enough |
|
|
86 | (1) |
|
4.5 Two Examples of the Use of Uninterpreted Functions |
|
|
87 | (5) |
|
4.5.1 Proving Equivalence of Circuits |
|
|
89 | (2) |
|
4.5.2 Verifying a Compilation Process with Translation Validation |
|
|
91 | (1) |
|
|
92 | (1) |
|
|
93 | (2) |
|
|
95 | (2) |
|
|
97 | (38) |
|
|
97 | (2) |
|
5.1.1 Solvers for Linear Arithmetic |
|
|
98 | (1) |
|
5.2 The Simplex Algorithm |
|
|
99 | (7) |
|
|
99 | (1) |
|
5.2.2 Basics of the Simplex Algorithm |
|
|
100 | (2) |
|
5.2.3 Simplex with Upper and Lower Bounds |
|
|
102 | (4) |
|
5.3 The Branch and Bound Method |
|
|
106 | (6) |
|
|
108 | (4) |
|
5.4 Fourier--Motzkin Variable Elimination |
|
|
112 | (3) |
|
5.4.1 Equality Constraints |
|
|
112 | (1) |
|
5.4.2 Variable Elimination |
|
|
112 | (3) |
|
|
115 | (1) |
|
|
115 | (9) |
|
5.5.1 Problem Description |
|
|
115 | (1) |
|
5.5.2 Equality Constraints |
|
|
116 | (3) |
|
5.5.3 Inequality Constraints |
|
|
119 | (5) |
|
|
124 | (2) |
|
5.6.1 Preprocessing of Linear Systems |
|
|
124 | (1) |
|
5.6.2 Preprocessing of Integer Linear Systems |
|
|
125 | (1) |
|
|
126 | (3) |
|
|
126 | (2) |
|
5.7.2 A Decision Procedure for Difference Logic |
|
|
128 | (1) |
|
|
129 | (2) |
|
|
129 | (1) |
|
|
129 | (1) |
|
5.8.3 Integer Linear Systems |
|
|
130 | (1) |
|
|
130 | (1) |
|
|
131 | (1) |
|
|
131 | (2) |
|
|
133 | (2) |
|
|
135 | (22) |
|
6.1 Bit-Vector Arithmetic |
|
|
135 | (7) |
|
|
135 | (2) |
|
|
137 | (1) |
|
|
138 | (4) |
|
6.2 Deciding Bit-Vector Arithmetic with Flattening |
|
|
142 | (4) |
|
6.2.1 Converting the Skeleton |
|
|
142 | (2) |
|
6.2.2 Arithmetic Operators |
|
|
144 | (2) |
|
6.3 Incremental Bit Flattening |
|
|
146 | (3) |
|
6.3.1 Some Operators Are Hard |
|
|
146 | (2) |
|
6.3.2 Abstraction with Uninterpreted Functions |
|
|
148 | (1) |
|
6.4 Fixed-Point Arithmetic |
|
|
149 | (2) |
|
|
149 | (1) |
|
|
150 | (1) |
|
|
151 | (3) |
|
|
151 | (1) |
|
6.5.2 Bit-Level Encodings of Bit-Vector Arithmetic |
|
|
152 | (1) |
|
6.5.3 Using Solvers for Linear Arithmetic |
|
|
152 | (2) |
|
|
154 | (2) |
|
|
156 | (1) |
|
|
157 | (16) |
|
|
157 | (2) |
|
|
158 | (1) |
|
|
159 | (1) |
|
7.2 Eliminating the Array Terms |
|
|
159 | (3) |
|
7.3 A Reduction Algorithm for a Fragment of the Array Theory |
|
|
162 | (3) |
|
|
162 | (1) |
|
7.3.2 The Reduction Algorithm |
|
|
163 | (2) |
|
7.4 A Lazy Encoding Procedure |
|
|
165 | (4) |
|
7.4.1 Incremental Encoding with DPLL(T) |
|
|
165 | (1) |
|
7.4.2 Lazy Instantiation of the Read-Over-Write Axiom |
|
|
165 | (2) |
|
7.4.3 Lazy Instantiation of the Extensionality Rule |
|
|
167 | (2) |
|
|
169 | (1) |
|
|
170 | (1) |
|
|
171 | (2) |
|
|
173 | (26) |
|
|
173 | (4) |
|
8.1.1 Pointers and Their Applications |
|
|
173 | (1) |
|
8.1.2 Dynamic Memory Allocation |
|
|
174 | (2) |
|
8.1.3 Analysis of Programs with Pointers |
|
|
176 | (1) |
|
8.2 A Simple Pointer Logic |
|
|
177 | (5) |
|
|
177 | (2) |
|
|
179 | (1) |
|
8.2.3 Axiomatization of the Memory Model |
|
|
180 | (1) |
|
8.2.4 Adding Structure Types |
|
|
181 | (1) |
|
8.3 Modeling Heap-Allocated Data Structures |
|
|
182 | (3) |
|
|
182 | (1) |
|
|
183 | (2) |
|
|
185 | (4) |
|
8.4.1 Applying the Semantic Translation |
|
|
185 | (2) |
|
|
187 | (1) |
|
8.4.3 Partitioning the Memory |
|
|
188 | (1) |
|
8.5 Rule-Based Decision Procedures |
|
|
189 | (5) |
|
8.5.1 A Reachability Predicate for Linked Structures |
|
|
190 | (1) |
|
8.5.2 Deciding Reachability Predicate Formulas |
|
|
191 | (3) |
|
|
194 | (2) |
|
|
194 | (1) |
|
8.6.2 Reachability Predicates |
|
|
195 | (1) |
|
|
196 | (2) |
|
|
198 | (1) |
|
|
199 | (30) |
|
|
199 | (4) |
|
9.1.1 Example: Quantified Boolean Formulas |
|
|
201 | (2) |
|
9.1.2 Example: Quantified Disjunctive Linear Arithmetic |
|
|
203 | (1) |
|
9.2 Quantifier Elimination |
|
|
203 | (7) |
|
|
203 | (2) |
|
9.2.2 Quantifier Elimination Algorithms |
|
|
205 | (1) |
|
9.2.3 Quantifier Elimination for Quantified Boolean Formulas |
|
|
206 | (3) |
|
9.2.4 Quantifier Elimination for Quantified Disjunctive Linear Arithmetic |
|
|
209 | (1) |
|
9.3 Search-Based Algorithms for QBF |
|
|
210 | (2) |
|
9.4 Effectively Propositional Logic |
|
|
212 | (3) |
|
9.5 General Quantification |
|
|
215 | (7) |
|
|
222 | (3) |
|
|
222 | (1) |
|
|
223 | (1) |
|
|
224 | (1) |
|
9.6.4 General Quantification |
|
|
224 | (1) |
|
|
225 | (2) |
|
|
227 | (2) |
|
10 Deciding a Combination of Theories |
|
|
229 | (16) |
|
|
229 | (1) |
|
|
229 | (2) |
|
10.3 The Nelson--Oppen Combination Procedure |
|
|
231 | (9) |
|
10.3.1 Combining Convex Theories |
|
|
231 | (3) |
|
10.3.2 Combining Nonconvex Theories |
|
|
234 | (3) |
|
10.3.3 Proof of Correctness of the Nelson--Oppen Procedure |
|
|
237 | (3) |
|
|
240 | (1) |
|
|
240 | (4) |
|
|
244 | (1) |
|
11 Propositional Encodings |
|
|
245 | (36) |
|
11.1 Lazy vs. Eager Encodings |
|
|
245 | (1) |
|
11.2 From Uninterpreted Functions to Equality Logic |
|
|
245 | (8) |
|
11.2.1 Ackermann's Reduction |
|
|
246 | (3) |
|
11.2.2 Bryant's Reduction |
|
|
249 | (4) |
|
|
253 | (2) |
|
11.4 Simplifications of the Formula |
|
|
255 | (4) |
|
11.5 A Graph-Based Reduction to Propositional Logic |
|
|
259 | (3) |
|
11.6 Equalities and Small-Domain Instantiations |
|
|
262 | (10) |
|
11.6.1 Some Simple Bounds |
|
|
263 | (2) |
|
11.6.2 Graph-Based Domain Allocation |
|
|
265 | (1) |
|
11.6.3 The Domain Allocation Algorithm |
|
|
266 | (3) |
|
11.6.4 A Proof of Soundness |
|
|
269 | (2) |
|
|
271 | (1) |
|
11.7 Ackermann's vs. Bryant's Reduction: Where Does It Matter? |
|
|
272 | (1) |
|
|
273 | (3) |
|
|
274 | (2) |
|
|
276 | (1) |
|
|
276 | (3) |
|
|
279 | (2) |
|
12 Applications in Software Engineering and Computational Biology |
|
|
281 | (28) |
|
|
281 | (2) |
|
12.2 Bounded Program Analysis |
|
|
283 | (6) |
|
12.2.1 Checking Feasibility of a Single Path |
|
|
283 | (4) |
|
12.2.2 Checking Feasibility of All Paths in a Bounded Program |
|
|
287 | (2) |
|
12.3 Unbounded Program Analysis |
|
|
289 | (8) |
|
12.3.1 Overapproximation with Nondeterministic Assignments |
|
|
289 | (2) |
|
12.3.2 The Overapproximation Can Be Too Coarse |
|
|
291 | (3) |
|
|
294 | (1) |
|
12.3.4 Refining the Abstraction with Loop Invariants |
|
|
295 | (2) |
|
12.4 SMT-Based Methods in Biology |
|
|
297 | (5) |
|
|
298 | (2) |
|
12.4.2 Uncovering Gene Regulatory Networks |
|
|
300 | (2) |
|
|
302 | (2) |
|
|
302 | (1) |
|
12.5.2 Bounded Symbolic Simulation |
|
|
302 | (1) |
|
12.5.3 Overapproximating Programs |
|
|
303 | (1) |
|
|
304 | (5) |
|
A SMT-LIB: a Brief Tutorial |
|
|
309 | (6) |
|
A.1 The SMT-LIB Initiative |
|
|
309 | (1) |
|
A.2 The SMT-LIB File Interface |
|
|
310 | (5) |
|
A.2.1 Propositional Logic |
|
|
311 | (1) |
|
|
312 | (1) |
|
A.2.3 Bit-Vector Arithmetic |
|
|
313 | (1) |
|
|
313 | (1) |
|
A.2.5 Equalities and Uninterpreted Functions |
|
|
314 | (1) |
|
B A C++ Library for Developing Decision Procedures |
|
|
315 | (14) |
|
|
315 | (1) |
|
|
316 | (2) |
|
|
318 | (1) |
|
|
318 | (4) |
|
B.3.1 A Grammar for First-Order Logic |
|
|
318 | (2) |
|
B.3.2 The Problem File Format |
|
|
320 | (1) |
|
B.3.3 A Class for Storing Identifiers |
|
|
321 | (1) |
|
|
321 | (1) |
|
|
322 | (3) |
|
|
322 | (3) |
|
B.4.2 Converting the Propositional Skeleton |
|
|
325 | (1) |
|
B.5 A Template for a Lazy Decision Procedure |
|
|
325 | (4) |
References |
|
329 | (18) |
Tools Index |
|
347 | (2) |
Algorithms Index |
|
349 | (2) |
Index |
|
351 | |