View Javadoc

1   /*******************************************************************************
2    * SAT4J: a SATisfiability library for Java Copyright (C) 2004, 2012 Artois University and CNRS
3    *
4    * All rights reserved. This program and the accompanying materials
5    * are made available under the terms of the Eclipse Public License v1.0
6    * which accompanies this distribution, and is available at
7    *  http://www.eclipse.org/legal/epl-v10.html
8    *
9    * Alternatively, the contents of this file may be used under the terms of
10   * either the GNU Lesser General Public License Version 2.1 or later (the
11   * "LGPL"), in which case the provisions of the LGPL are applicable instead
12   * of those above. If you wish to allow use of your version of this file only
13   * under the terms of the LGPL, and not to allow others to use your version of
14   * this file under the terms of the EPL, indicate your decision by deleting
15   * the provisions above and replace them with the notice and other provisions
16   * required by the LGPL. If you do not delete the provisions above, a recipient
17   * may use your version of this file under the terms of the EPL or the LGPL.
18   *
19   * Based on the original MiniSat specification from:
20   *
21   * An extensible SAT solver. Niklas Een and Niklas Sorensson. Proceedings of the
22   * Sixth International Conference on Theory and Applications of Satisfiability
23   * Testing, LNCS 2919, pp 502-518, 2003.
24   *
25   * See www.minisat.se for the original solver in C++.
26   *
27   * Contributors:
28   *   CRIL - initial API and implementation
29   *******************************************************************************/
30  package org.sat4j.tools;
31  
32  import static org.junit.Assert.assertEquals;
33  
34  import java.util.List;
35  
36  import org.junit.Before;
37  import org.junit.Test;
38  import org.sat4j.core.VecInt;
39  import org.sat4j.minisat.SolverFactory;
40  import org.sat4j.specs.ContradictionException;
41  import org.sat4j.specs.IConstr;
42  import org.sat4j.specs.ISolver;
43  import org.sat4j.specs.IVecInt;
44  import org.sat4j.specs.TimeoutException;
45  
46  public class TestAllMUSesAndCheckTest {
47  
48      private AllMUSes allMUSes;
49      private ISolver solver;
50      private CheckMUSSolutionListener checkListener;
51  
52      @Before
53      public void setUp() throws Exception {
54          this.allMUSes = new AllMUSes(SolverFactory.instance());
55          this.solver = allMUSes.getSolverInstance();
56          this.checkListener = new CheckMUSSolutionListener(
57                  SolverFactory.instance());
58      }
59  
60      @Test
61      public void testSimpleCase() {
62          IVecInt c1 = new VecInt();
63          IVecInt c2 = new VecInt();
64          IVecInt c3 = new VecInt();
65          IVecInt c4 = new VecInt();
66          IVecInt c5 = new VecInt();
67  
68          c1.push(1);
69          c2.push(2);
70          c3.push(-1).push(-2);
71          c4.push(3);
72          c5.push(-3);
73  
74          this.solver.newVar(3);
75  
76          try {
77              this.checkListener.addOriginalClause(c1);
78              this.checkListener.addOriginalClause(c2);
79              this.checkListener.addOriginalClause(c3);
80              this.checkListener.addOriginalClause(c4);
81              this.checkListener.addOriginalClause(c5);
82  
83              this.solver.addClause(c1);
84              this.solver.addClause(c2);
85              this.solver.addClause(c3);
86              this.solver.addClause(c4);
87              this.solver.addClause(c5);
88  
89              List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
90  
91              assertEquals(muses.size(), 2);
92  
93          } catch (ContradictionException e) {
94              e.printStackTrace();
95          }
96  
97      }
98  
99      @Test
100     public void testVerySimpleCase() {
101         IVecInt c1 = new VecInt();
102         IVecInt c2 = new VecInt();
103 
104         c1.push(1);
105         c2.push(-1);
106 
107         this.solver.newVar(1);
108 
109         try {
110 
111             this.checkListener.addOriginalClause(c1);
112             this.checkListener.addOriginalClause(c2);
113 
114             this.solver.addClause(c1);
115             this.solver.addClause(c2);
116 
117             List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
118 
119             assertEquals(muses.size(), 1);
120 
121         } catch (ContradictionException e) {
122             e.printStackTrace();
123         }
124     }
125 
126     @Test
127     public void testGlobalInconsistency() throws ContradictionException,
128             TimeoutException {
129         this.solver.newVar(2);
130         IVecInt clause = new VecInt();
131         clause.push(1).push(2);
132         this.checkListener.addOriginalClause(clause);
133         this.solver.addClause(clause);
134 
135         clause.clear();
136         clause.push(1).push(-2);
137         this.checkListener.addOriginalClause(clause);
138         this.solver.addClause(clause);
139 
140         clause.clear();
141         clause.push(-1).push(2);
142         this.checkListener.addOriginalClause(clause);
143         this.solver.addClause(clause);
144 
145         clause.clear();
146         clause.push(-1).push(-2);
147         this.checkListener.addOriginalClause(clause);
148         this.solver.addClause(clause);
149         clause.clear();
150 
151         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
152         assertEquals(1, muses.size());
153     }
154 
155     @Test
156     public void testGlobalInconsistencyIndex() throws ContradictionException,
157             TimeoutException {
158         this.solver.newVar(2);
159         IVecInt clause = new VecInt();
160         clause.push(1).push(2);
161         this.checkListener.addOriginalClause(clause);
162         this.solver.addClause(clause);
163         clause.clear();
164         clause.push(1).push(-2);
165         this.checkListener.addOriginalClause(clause);
166         this.solver.addClause(clause);
167         clause.clear();
168         clause.push(-1).push(2);
169         this.checkListener.addOriginalClause(clause);
170         this.solver.addClause(clause);
171         clause.clear();
172         clause.push(-1).push(-2);
173         this.checkListener.addOriginalClause(clause);
174         this.solver.addClause(clause);
175         clause.clear();
176         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
177         assertEquals(1, muses.size());
178     }
179 
180     @Test
181     public void testAlmostGlobalInconsistency() throws ContradictionException,
182             TimeoutException {
183         this.solver.newVar(3);
184         IVecInt clause = new VecInt();
185         clause.push(1).push(2);
186         this.checkListener.addOriginalClause(clause);
187         IConstr c1 = this.solver.addClause(clause);
188         clause.clear();
189         clause.push(1).push(-2);
190         this.checkListener.addOriginalClause(clause);
191         IConstr c2 = this.solver.addClause(clause);
192         clause.clear();
193         clause.push(-1).push(2);
194         this.checkListener.addOriginalClause(clause);
195         IConstr c3 = this.solver.addClause(clause);
196         clause.clear();
197         clause.push(-1).push(-2);
198         this.checkListener.addOriginalClause(clause);
199         IConstr c4 = this.solver.addClause(clause);
200         clause.clear();
201         clause.push(1).push(3);
202         this.solver.addClause(clause);
203         clause.clear();
204         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
205         assertEquals(1, muses.size());
206     }
207 
208     @Test
209     public void testAlmostGlobalInconsistencyIndex()
210             throws ContradictionException, TimeoutException {
211         this.solver.newVar(3);
212         IVecInt clause = new VecInt();
213         clause.push(1).push(2);
214         this.checkListener.addOriginalClause(clause);
215         this.solver.addClause(clause);
216         clause.clear();
217         clause.push(1).push(-2);
218         this.checkListener.addOriginalClause(clause);
219         this.solver.addClause(clause);
220         clause.clear();
221         clause.push(-1).push(2);
222         this.checkListener.addOriginalClause(clause);
223         this.solver.addClause(clause);
224         clause.clear();
225         clause.push(-1).push(-2);
226         this.checkListener.addOriginalClause(clause);
227         this.solver.addClause(clause);
228         clause.clear();
229         clause.push(1).push(3);
230         this.checkListener.addOriginalClause(clause);
231         this.solver.addClause(clause);
232         clause.clear();
233         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
234         assertEquals(1, muses.size());
235     }
236 
237     @Test
238     public void testAlmostGlobalInconsistencyII()
239             throws ContradictionException, TimeoutException {
240         this.solver.newVar(3);
241         IVecInt clause = new VecInt();
242         clause.push(1).push(2);
243         this.checkListener.addOriginalClause(clause);
244         IConstr c1 = this.solver.addClause(clause);
245         clause.clear();
246         clause.push(1).push(-2);
247         this.checkListener.addOriginalClause(clause);
248         IConstr c2 = this.solver.addClause(clause);
249         clause.clear();
250         clause.push(1).push(3);
251         this.checkListener.addOriginalClause(clause);
252         this.solver.addClause(clause);
253         clause.clear();
254         clause.push(-1).push(2);
255         this.checkListener.addOriginalClause(clause);
256         IConstr c4 = this.solver.addClause(clause);
257         clause.clear();
258         clause.push(-1).push(-2);
259         this.checkListener.addOriginalClause(clause);
260         IConstr c5 = this.solver.addClause(clause);
261         clause.clear();
262         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
263         assertEquals(1, muses.size());
264 
265     }
266 
267     @Test
268     public void testAlmostGlobalInconsistencyIIIndex()
269             throws ContradictionException, TimeoutException {
270         this.solver.newVar(3);
271         IVecInt clause = new VecInt();
272         clause.push(1).push(2);
273         this.checkListener.addOriginalClause(clause);
274         this.solver.addClause(clause);
275         clause.clear();
276         clause.push(1).push(-2);
277         this.checkListener.addOriginalClause(clause);
278         this.solver.addClause(clause);
279         clause.clear();
280         clause.push(1).push(3);
281         this.checkListener.addOriginalClause(clause);
282         this.solver.addClause(clause);
283         clause.clear();
284         clause.push(-1).push(2);
285         this.checkListener.addOriginalClause(clause);
286         this.solver.addClause(clause);
287         clause.clear();
288         clause.push(-1).push(-2);
289         this.checkListener.addOriginalClause(clause);
290         this.solver.addClause(clause);
291         clause.clear();
292         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
293         assertEquals(1, muses.size());
294     }
295 
296     @Test
297     public void testTheCaseOfTwoMUSes() throws ContradictionException,
298             TimeoutException {
299         this.solver.newVar(4);
300         IVecInt clause = new VecInt();
301         clause.push(1).push(2);
302         this.checkListener.addOriginalClause(clause);
303         IConstr c1 = this.solver.addClause(clause);
304         clause.clear();
305         clause.push(1).push(-2);
306         this.checkListener.addOriginalClause(clause);
307         IConstr c2 = this.solver.addClause(clause);
308         clause.clear();
309         clause.push(-1).push(3);
310         this.checkListener.addOriginalClause(clause);
311         this.solver.addClause(clause);
312         clause.clear();
313         clause.push(-1).push(-3);
314         this.checkListener.addOriginalClause(clause);
315         this.solver.addClause(clause);
316         clause.clear();
317         clause.push(-1).push(4);
318         this.checkListener.addOriginalClause(clause);
319         this.solver.addClause(clause);
320         clause.clear();
321         clause.push(-1).push(-4);
322         this.checkListener.addOriginalClause(clause);
323         this.solver.addClause(clause);
324         clause.clear();
325         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
326         assertEquals(2, muses.size());
327     }
328 
329     @Test
330     public void testEclipseTestCase() throws ContradictionException,
331             TimeoutException {
332         this.solver.newVar(3);
333         IVecInt clause = new VecInt();
334         clause.push(-1);
335         this.checkListener.addOriginalClause(clause);
336         this.solver.addClause(clause);
337         clause.clear();
338         clause.push(-2).push(3);
339         this.checkListener.addOriginalClause(clause);
340         this.solver.addClause(clause);
341         clause.clear();
342         clause.push(-2).push(1);
343         this.checkListener.addOriginalClause(clause);
344         this.solver.addClause(clause);
345         clause.clear();
346         clause.push(2);
347         this.checkListener.addOriginalClause(clause);
348         this.solver.addClause(clause);
349         clause.clear();
350         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
351         assertEquals(1, muses.size());
352     }
353 
354     @Test
355     public void testEclipseTestCase2() throws ContradictionException,
356             TimeoutException {
357         this.solver.newVar(4);
358         IVecInt clause = new VecInt();
359         clause.push(-1).push(2);
360         this.checkListener.addOriginalClause(clause);
361         this.solver.addClause(clause);
362         clause.clear();
363         clause.push(-1).push(3);
364         this.checkListener.addOriginalClause(clause);
365         this.solver.addClause(clause);
366         clause.clear();
367         clause.push(-2).push(-3);
368         this.checkListener.addOriginalClause(clause);
369         this.solver.addClause(clause);
370         clause.clear();
371         clause.push(-4).push(1);
372         this.checkListener.addOriginalClause(clause);
373         this.solver.addClause(clause);
374         clause.clear();
375         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
376         assertEquals(0, muses.size());
377     }
378 
379     @Test
380     public void testExample1CADECedric() throws ContradictionException,
381             TimeoutException {
382         this.solver.newVar(5);
383         IVecInt clause = new VecInt();
384 
385         clause.push(-4).push(5);
386         this.checkListener.addOriginalClause(clause);
387         this.solver.addClause(clause);
388         clause.clear();
389 
390         clause.push(2).push(-3);
391         this.checkListener.addOriginalClause(clause);
392         this.solver.addClause(clause);
393         clause.clear();
394 
395         clause.push(-4);
396         this.checkListener.addOriginalClause(clause);
397         this.solver.addClause(clause);
398         clause.clear();
399 
400         clause.push(-1).push(2);
401         this.checkListener.addOriginalClause(clause);
402         this.solver.addClause(clause);
403         clause.clear();
404 
405         clause.push(1);
406         this.checkListener.addOriginalClause(clause);
407         this.solver.addClause(clause);
408         clause.clear();
409 
410         clause.push(1).push(-3).push(-5);
411         this.checkListener.addOriginalClause(clause);
412         this.solver.addClause(clause);
413         clause.clear();
414 
415         clause.push(-1).push(3).push(4);
416         this.checkListener.addOriginalClause(clause);
417         this.solver.addClause(clause);
418         clause.clear();
419 
420         clause.push(-2);
421         this.checkListener.addOriginalClause(clause);
422         this.solver.addClause(clause);
423         clause.clear();
424 
425         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
426         assertEquals(2, muses.size());
427     }
428 
429     @Test
430     public void testExample3CADECedric() throws ContradictionException,
431             TimeoutException {
432         this.solver.newVar(6);
433         IVecInt clause = new VecInt();
434 
435         clause.push(1);
436         this.checkListener.addOriginalClause(clause);
437         this.solver.addClause(clause);
438         clause.clear();
439 
440         clause.push(2).push(4);
441         this.checkListener.addOriginalClause(clause);
442         this.solver.addClause(clause);
443         clause.clear();
444 
445         clause.push(-2).push(-5);
446         this.checkListener.addOriginalClause(clause);
447         this.solver.addClause(clause);
448         clause.clear();
449 
450         clause.push(1).push(4);
451         this.checkListener.addOriginalClause(clause);
452         this.solver.addClause(clause);
453         clause.clear();
454 
455         clause.push(2).push(-3);
456         this.checkListener.addOriginalClause(clause);
457         this.solver.addClause(clause);
458         clause.clear();
459 
460         clause.push(6);
461         this.checkListener.addOriginalClause(clause);
462         this.solver.addClause(clause);
463         clause.clear();
464 
465         clause.push(3).push(-4);
466         this.checkListener.addOriginalClause(clause);
467         this.solver.addClause(clause);
468         clause.clear();
469 
470         clause.push(-1);
471         this.checkListener.addOriginalClause(clause);
472         this.solver.addClause(clause);
473         clause.clear();
474 
475         clause.push(-2).push(-3);
476         this.checkListener.addOriginalClause(clause);
477         this.solver.addClause(clause);
478         clause.clear();
479 
480         clause.push(2).push(4).push(6);
481         this.checkListener.addOriginalClause(clause);
482         this.solver.addClause(clause);
483         clause.clear();
484 
485         clause.push(5);
486         this.checkListener.addOriginalClause(clause);
487         this.solver.addClause(clause);
488         clause.clear();
489 
490         clause.push(-6).push(4);
491         this.checkListener.addOriginalClause(clause);
492         this.solver.addClause(clause);
493         clause.clear();
494 
495         clause.push(-5).push(-6);
496         this.checkListener.addOriginalClause(clause);
497         this.solver.addClause(clause);
498         clause.clear();
499 
500         clause.push(1).push(-3).push(4);
501         this.checkListener.addOriginalClause(clause);
502         this.solver.addClause(clause);
503         clause.clear();
504 
505         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
506         assertEquals(9, muses.size());
507     }
508 
509     @Test
510     public void testExample3IJCAICedric() throws ContradictionException,
511             TimeoutException {
512         this.solver.newVar(5);
513         IVecInt clause = new VecInt();
514 
515         clause.push(4);
516         this.checkListener.addOriginalClause(clause);
517         this.solver.addClause(clause);
518         clause.clear();
519 
520         clause.push(2).push(3);
521         this.checkListener.addOriginalClause(clause);
522         this.solver.addClause(clause);
523         clause.clear();
524 
525         clause.push(1).push(2);
526         this.checkListener.addOriginalClause(clause);
527         this.solver.addClause(clause);
528         clause.clear();
529 
530         clause.push(1).push(-3);
531         this.checkListener.addOriginalClause(clause);
532         this.solver.addClause(clause);
533         clause.clear();
534 
535         clause.push(-2).push(-5);
536         this.checkListener.addOriginalClause(clause);
537         this.solver.addClause(clause);
538         clause.clear();
539 
540         clause.push(-1).push(-2);
541         this.checkListener.addOriginalClause(clause);
542         this.solver.addClause(clause);
543         clause.clear();
544 
545         clause.push(1).push(5);
546         this.checkListener.addOriginalClause(clause);
547         this.solver.addClause(clause);
548         clause.clear();
549 
550         clause.push(-1).push(-5);
551         this.checkListener.addOriginalClause(clause);
552         this.solver.addClause(clause);
553         clause.clear();
554 
555         clause.push(2).push(5);
556         this.checkListener.addOriginalClause(clause);
557         this.solver.addClause(clause);
558         clause.clear();
559 
560         clause.push(-1).push(2).push(-3);
561         this.checkListener.addOriginalClause(clause);
562         this.solver.addClause(clause);
563         clause.clear();
564 
565         clause.push(-1).push(2).push(-4);
566         this.checkListener.addOriginalClause(clause);
567         this.solver.addClause(clause);
568         clause.clear();
569 
570         clause.push(1).push(-2).push(3);
571         this.checkListener.addOriginalClause(clause);
572         this.solver.addClause(clause);
573         clause.clear();
574 
575         clause.push(1).push(-2).push(-4);
576         this.checkListener.addOriginalClause(clause);
577         this.solver.addClause(clause);
578         clause.clear();
579 
580         List<IVecInt> muses = allMUSes.computeAllMUSes(checkListener);
581 
582         assertEquals(17, muses.size());
583     }
584 
585 }