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 TestAllMUSes {
47  
48      private AllMUSes allMUSes;
49      private ISolver solver;
50  
51      @Before
52      public void setUp() throws Exception {
53          this.allMUSes = new AllMUSes(SolverFactory.instance());
54          this.solver = allMUSes.getSolverInstance();
55      }
56  
57      @Test
58      public void testSimpleCase() {
59          IVecInt c1 = new VecInt();
60          IVecInt c2 = new VecInt();
61          IVecInt c3 = new VecInt();
62          IVecInt c4 = new VecInt();
63          IVecInt c5 = new VecInt();
64  
65          c1.push(1);
66          c2.push(2);
67          c3.push(-1).push(-2);
68          c4.push(3);
69          c5.push(-3);
70  
71          this.solver.newVar(3);
72  
73          try {
74              this.solver.addClause(c1);
75              this.solver.addClause(c2);
76              this.solver.addClause(c3);
77              this.solver.addClause(c4);
78              this.solver.addClause(c5);
79  
80              List<IVecInt> muses = allMUSes.computeAllMUSes();
81  
82              assertEquals(muses.size(), 2);
83  
84          } catch (ContradictionException e) {
85              e.printStackTrace();
86          }
87  
88      }
89  
90      @Test
91      public void testVerySimpleCase() {
92          IVecInt c1 = new VecInt();
93          IVecInt c2 = new VecInt();
94  
95          c1.push(1);
96          c2.push(-1);
97  
98          this.solver.newVar(1);
99  
100         try {
101             this.solver.addClause(c1);
102             this.solver.addClause(c2);
103 
104             List<IVecInt> muses = allMUSes.computeAllMUSes();
105 
106             assertEquals(muses.size(), 1);
107 
108         } catch (ContradictionException e) {
109             e.printStackTrace();
110         }
111     }
112 
113     @Test
114     public void testGlobalInconsistency() throws ContradictionException,
115             TimeoutException {
116         this.solver.newVar(2);
117         IVecInt clause = new VecInt();
118         clause.push(1).push(2);
119         this.solver.addClause(clause);
120         clause.clear();
121         clause.push(1).push(-2);
122         this.solver.addClause(clause);
123         clause.clear();
124         clause.push(-1).push(2);
125         this.solver.addClause(clause);
126         clause.clear();
127         clause.push(-1).push(-2);
128         this.solver.addClause(clause);
129         clause.clear();
130         List<IVecInt> muses = allMUSes.computeAllMUSes();
131         assertEquals(1, muses.size());
132     }
133 
134     @Test
135     public void testGlobalInconsistencyIndex() throws ContradictionException,
136             TimeoutException {
137         this.solver.newVar(2);
138         IVecInt clause = new VecInt();
139         clause.push(1).push(2);
140         this.solver.addClause(clause);
141         clause.clear();
142         clause.push(1).push(-2);
143         this.solver.addClause(clause);
144         clause.clear();
145         clause.push(-1).push(2);
146         this.solver.addClause(clause);
147         clause.clear();
148         clause.push(-1).push(-2);
149         this.solver.addClause(clause);
150         clause.clear();
151         List<IVecInt> muses = allMUSes.computeAllMUSes();
152         assertEquals(1, muses.size());
153     }
154 
155     @Test
156     public void testAlmostGlobalInconsistency() throws ContradictionException,
157             TimeoutException {
158         this.solver.newVar(3);
159         IVecInt clause = new VecInt();
160         clause.push(1).push(2);
161         IConstr c1 = this.solver.addClause(clause);
162         clause.clear();
163         clause.push(1).push(-2);
164         IConstr c2 = this.solver.addClause(clause);
165         clause.clear();
166         clause.push(-1).push(2);
167         IConstr c3 = this.solver.addClause(clause);
168         clause.clear();
169         clause.push(-1).push(-2);
170         IConstr c4 = this.solver.addClause(clause);
171         clause.clear();
172         clause.push(1).push(3);
173         this.solver.addClause(clause);
174         clause.clear();
175         List<IVecInt> muses = allMUSes.computeAllMUSes();
176         assertEquals(1, muses.size());
177     }
178 
179     @Test
180     public void testAlmostGlobalInconsistencyIndex()
181             throws ContradictionException, TimeoutException {
182         this.solver.newVar(3);
183         IVecInt clause = new VecInt();
184         clause.push(1).push(2);
185         this.solver.addClause(clause);
186         clause.clear();
187         clause.push(1).push(-2);
188         this.solver.addClause(clause);
189         clause.clear();
190         clause.push(-1).push(2);
191         this.solver.addClause(clause);
192         clause.clear();
193         clause.push(-1).push(-2);
194         this.solver.addClause(clause);
195         clause.clear();
196         clause.push(1).push(3);
197         this.solver.addClause(clause);
198         clause.clear();
199         List<IVecInt> muses = allMUSes.computeAllMUSes();
200         assertEquals(1, muses.size());
201     }
202 
203     @Test
204     public void testAlmostGlobalInconsistencyII()
205             throws ContradictionException, TimeoutException {
206         this.solver.newVar(3);
207         IVecInt clause = new VecInt();
208         clause.push(1).push(2);
209         IConstr c1 = this.solver.addClause(clause);
210         clause.clear();
211         clause.push(1).push(-2);
212         IConstr c2 = this.solver.addClause(clause);
213         clause.clear();
214         clause.push(1).push(3);
215         this.solver.addClause(clause);
216         clause.clear();
217         clause.push(-1).push(2);
218         IConstr c4 = this.solver.addClause(clause);
219         clause.clear();
220         clause.push(-1).push(-2);
221         IConstr c5 = this.solver.addClause(clause);
222         clause.clear();
223         List<IVecInt> muses = allMUSes.computeAllMUSes();
224         assertEquals(1, muses.size());
225 
226     }
227 
228     @Test
229     public void testAlmostGlobalInconsistencyIIIndex()
230             throws ContradictionException, TimeoutException {
231         this.solver.newVar(3);
232         IVecInt clause = new VecInt();
233         clause.push(1).push(2);
234         this.solver.addClause(clause);
235         clause.clear();
236         clause.push(1).push(-2);
237         this.solver.addClause(clause);
238         clause.clear();
239         clause.push(1).push(3);
240         this.solver.addClause(clause);
241         clause.clear();
242         clause.push(-1).push(2);
243         this.solver.addClause(clause);
244         clause.clear();
245         clause.push(-1).push(-2);
246         this.solver.addClause(clause);
247         clause.clear();
248         List<IVecInt> muses = allMUSes.computeAllMUSes();
249         assertEquals(1, muses.size());
250     }
251 
252     @Test
253     public void testTheCaseOfTwoMUSes() throws ContradictionException,
254             TimeoutException {
255         this.solver.newVar(4);
256         IVecInt clause = new VecInt();
257         clause.push(1).push(2);
258         IConstr c1 = this.solver.addClause(clause);
259         clause.clear();
260         clause.push(1).push(-2);
261         IConstr c2 = this.solver.addClause(clause);
262         clause.clear();
263         clause.push(-1).push(3);
264         this.solver.addClause(clause);
265         clause.clear();
266         clause.push(-1).push(-3);
267         this.solver.addClause(clause);
268         clause.clear();
269         clause.push(-1).push(4);
270         this.solver.addClause(clause);
271         clause.clear();
272         clause.push(-1).push(-4);
273         this.solver.addClause(clause);
274         clause.clear();
275         List<IVecInt> muses = allMUSes.computeAllMUSes();
276         assertEquals(2, muses.size());
277     }
278 
279     @Test
280     public void testEclipseTestCase() throws ContradictionException,
281             TimeoutException {
282         this.solver.newVar(3);
283         IVecInt clause = new VecInt();
284         clause.push(-1);
285         this.solver.addClause(clause);
286         clause.clear();
287         clause.push(-2).push(3);
288         this.solver.addClause(clause);
289         clause.clear();
290         clause.push(-2).push(1);
291         this.solver.addClause(clause);
292         clause.clear();
293         clause.push(2);
294         this.solver.addClause(clause);
295         clause.clear();
296         List<IVecInt> muses = allMUSes.computeAllMUSes();
297         assertEquals(1, muses.size());
298     }
299 
300     @Test
301     public void testEclipseTestCase2() throws ContradictionException,
302             TimeoutException {
303         this.solver.newVar(4);
304         IVecInt clause = new VecInt();
305         clause.push(-1).push(2);
306         this.solver.addClause(clause);
307         clause.clear();
308         clause.push(-1).push(3);
309         this.solver.addClause(clause);
310         clause.clear();
311         clause.push(-2).push(-3);
312         this.solver.addClause(clause);
313         clause.clear();
314         clause.push(-4).push(1);
315         this.solver.addClause(clause);
316         clause.clear();
317         List<IVecInt> muses = allMUSes.computeAllMUSes();
318         assertEquals(0, muses.size());
319     }
320 
321     @Test
322     public void testExample1CADECedric() throws ContradictionException,
323             TimeoutException {
324         this.solver.newVar(5);
325         IVecInt clause = new VecInt();
326 
327         clause.push(-4).push(5);
328         this.solver.addClause(clause);
329         clause.clear();
330 
331         clause.push(2).push(-3);
332         this.solver.addClause(clause);
333         clause.clear();
334 
335         clause.push(-4);
336         this.solver.addClause(clause);
337         clause.clear();
338 
339         clause.push(-1).push(2);
340         this.solver.addClause(clause);
341         clause.clear();
342 
343         clause.push(1);
344         this.solver.addClause(clause);
345         clause.clear();
346 
347         clause.push(1).push(-3).push(-5);
348         this.solver.addClause(clause);
349         clause.clear();
350 
351         clause.push(-1).push(3).push(4);
352         this.solver.addClause(clause);
353         clause.clear();
354 
355         clause.push(-2);
356         this.solver.addClause(clause);
357         clause.clear();
358 
359         List<IVecInt> muses = allMUSes.computeAllMUSes();
360         assertEquals(2, muses.size());
361     }
362 
363     @Test
364     public void testExample3CADECedric() throws ContradictionException,
365             TimeoutException {
366         this.solver.newVar(6);
367         IVecInt clause = new VecInt();
368 
369         clause.push(1);
370         this.solver.addClause(clause);
371         clause.clear();
372 
373         clause.push(2).push(4);
374         this.solver.addClause(clause);
375         clause.clear();
376 
377         clause.push(-2).push(-5);
378         this.solver.addClause(clause);
379         clause.clear();
380 
381         clause.push(1).push(4);
382         this.solver.addClause(clause);
383         clause.clear();
384 
385         clause.push(2).push(-3);
386         this.solver.addClause(clause);
387         clause.clear();
388 
389         clause.push(6);
390         this.solver.addClause(clause);
391         clause.clear();
392 
393         clause.push(3).push(-4);
394         this.solver.addClause(clause);
395         clause.clear();
396 
397         clause.push(-1);
398         this.solver.addClause(clause);
399         clause.clear();
400 
401         clause.push(-2).push(-3);
402         this.solver.addClause(clause);
403         clause.clear();
404 
405         clause.push(2).push(4).push(6);
406         this.solver.addClause(clause);
407         clause.clear();
408 
409         clause.push(5);
410         this.solver.addClause(clause);
411         clause.clear();
412 
413         clause.push(-6).push(4);
414         this.solver.addClause(clause);
415         clause.clear();
416 
417         clause.push(-5).push(-6);
418         this.solver.addClause(clause);
419         clause.clear();
420 
421         clause.push(1).push(-3).push(4);
422         this.solver.addClause(clause);
423         clause.clear();
424 
425         List<IVecInt> muses = allMUSes.computeAllMUSes();
426         assertEquals(9, muses.size());
427     }
428 
429     @Test
430     public void testExample3IJCAICedric() throws ContradictionException,
431             TimeoutException {
432         this.solver.newVar(5);
433         IVecInt clause = new VecInt();
434 
435         clause.push(4);
436         this.solver.addClause(clause);
437         clause.clear();
438 
439         clause.push(2).push(3);
440         this.solver.addClause(clause);
441         clause.clear();
442 
443         clause.push(1).push(2);
444         this.solver.addClause(clause);
445         clause.clear();
446 
447         clause.push(1).push(-3);
448         this.solver.addClause(clause);
449         clause.clear();
450 
451         clause.push(-2).push(-5);
452         this.solver.addClause(clause);
453         clause.clear();
454 
455         clause.push(-1).push(-2);
456         this.solver.addClause(clause);
457         clause.clear();
458 
459         clause.push(1).push(5);
460         this.solver.addClause(clause);
461         clause.clear();
462 
463         clause.push(-1).push(-5);
464         this.solver.addClause(clause);
465         clause.clear();
466 
467         clause.push(2).push(5);
468         this.solver.addClause(clause);
469         clause.clear();
470 
471         clause.push(-1).push(2).push(-3);
472         this.solver.addClause(clause);
473         clause.clear();
474 
475         clause.push(-1).push(2).push(-4);
476         this.solver.addClause(clause);
477         clause.clear();
478 
479         clause.push(1).push(-2).push(3);
480         this.solver.addClause(clause);
481         clause.clear();
482 
483         clause.push(1).push(-2).push(-4);
484         this.solver.addClause(clause);
485         clause.clear();
486 
487         List<IVecInt> muses = allMUSes.computeAllMUSes();
488 
489         assertEquals(17, muses.size());
490     }
491 
492 }