Search in sources :

Example 66 with Universe

use of kodkod.instance.Universe in project org.alloytools.alloy by AlloyTools.

the class BugTests method testFelix_11122006.

public final void testFelix_11122006() {
    Relation x0 = Relation.nary("Q", 1);
    Relation x1 = Relation.nary("B", 1);
    Relation x2 = Relation.nary("A", 1);
    Relation x3 = Relation.nary("QQ", 3);
    List<String> atomlist = Arrays.asList("A", "B", "Q");
    Universe universe = new Universe(atomlist);
    TupleFactory factory = universe.factory();
    Bounds bounds = new Bounds(universe);
    TupleSet x0_upper = factory.noneOf(1);
    x0_upper.add(factory.tuple("Q"));
    bounds.boundExactly(x0, x0_upper);
    TupleSet x1_upper = factory.noneOf(1);
    x1_upper.add(factory.tuple("B"));
    bounds.boundExactly(x1, x1_upper);
    TupleSet x2_upper = factory.noneOf(1);
    x2_upper.add(factory.tuple("A"));
    bounds.boundExactly(x2, x2_upper);
    TupleSet x3_upper = factory.noneOf(3);
    x3_upper.add(factory.tuple("Q").product(factory.tuple("A")).product(factory.tuple("A")));
    x3_upper.add(factory.tuple("Q").product(factory.tuple("B")).product(factory.tuple("B")));
    bounds.bound(x3, x3_upper);
    Expression x7 = x2.product(x2);
    Expression x8 = x0.join(x3);
    Formula x6 = x7.in(x8);
    Formula x5 = x6.not();
    Expression x18 = x1.product(x1);
    Expression x17 = x7.union(x18);
    Expression x16 = x0.product(x17);
    Formula x15 = x3.in(x16);
    Formula x4 = x5.and(x15);
    Solver solver = new Solver();
    solver.options().setSolver(SATFactory.DefaultSAT4J);
    solver.options().setBitwidth(4);
    solver.options().setIntEncoding(Options.IntEncoding.TWOSCOMPLEMENT);
    // System.out.println(bounds);
    // System.out.println(x4);
    Solution sol = solver.solve(x4, bounds);
    assertEquals(sol.outcome(), Solution.Outcome.SATISFIABLE);
// System.out.println(sol.toString());
}
Also used : TupleSet(kodkod.instance.TupleSet) Formula(kodkod.ast.Formula) Relation(kodkod.ast.Relation) Solver(kodkod.engine.Solver) IntExpression(kodkod.ast.IntExpression) Expression(kodkod.ast.Expression) Bounds(kodkod.instance.Bounds) TupleFactory(kodkod.instance.TupleFactory) Universe(kodkod.instance.Universe) Solution(kodkod.engine.Solution)

Example 67 with Universe

use of kodkod.instance.Universe in project org.alloytools.alloy by AlloyTools.

the class BugTests method testVincent_02172006.

public final void testVincent_02172006() {
    // set ups universe of atoms [1..257]
    final List<Integer> atoms = new ArrayList<Integer>();
    // change this to 256, and the program works
    for (int i = 0; i < 257; i++) {
        atoms.add(i + 1);
    }
    final Universe universe = new Universe(atoms);
    final Bounds bounds = new Bounds(universe);
    final TupleFactory factory = universe.factory();
    final Relation oneRel = Relation.unary("oneRel");
    final Relation pCourses = Relation.binary("pCourses");
    final Relation prev = Relation.binary("prev");
    final Relation sCourses = Relation.binary("sCourses");
    final Relation prereqs = Relation.binary("prereqs");
    final Relation rel = Relation.unary("rel");
    bounds.bound(oneRel, factory.setOf(factory.tuple(atoms.get(0))), factory.setOf(factory.tuple(atoms.get(0))));
    bounds.bound(rel, factory.allOf(1));
    // list1 and list2 are temp lists for creating bounds for binary
    // relations below
    // list1 = [1, 2]
    // list2 = [3, 2]
    // ts = [ [1, 2], [2, 2], [3, 2] ]
    List<Integer> list1 = new ArrayList<Integer>();
    list1.add(atoms.get(0));
    list1.add(atoms.get(1));
    List<Integer> list2 = new ArrayList<Integer>();
    list2.add(atoms.get(2));
    list2.add(atoms.get(1));
    TupleSet ts = factory.area(factory.tuple(list1), factory.tuple(list2));
    bounds.bound(pCourses, ts);
    bounds.bound(prev, ts);
    bounds.bound(sCourses, ts);
    bounds.bound(prereqs, ts);
    // all s: futureSemesters | all c: s.courses | no c.prereqs or some p:
    // c.prereqs | p.courses in s.prev^.courses
    final Variable s = Variable.unary("s"), c = Variable.unary("c"), p = Variable.unary("p");
    Formula formula = (p.join(pCourses).in(s.join(prev.closure()).join(sCourses)).forAll(p.oneOf(c.join(prereqs)))).forAll(c.oneOf(s.join(sCourses))).forAll(s.oneOf(rel));
    // System.out.println(formula);
    // solve
    final Instance instance = solver.solve(formula, bounds).instance();
    assertNotNull(instance);
}
Also used : TupleSet(kodkod.instance.TupleSet) Formula(kodkod.ast.Formula) Relation(kodkod.ast.Relation) Variable(kodkod.ast.Variable) Instance(kodkod.instance.Instance) Bounds(kodkod.instance.Bounds) ArrayList(java.util.ArrayList) TupleFactory(kodkod.instance.TupleFactory) Universe(kodkod.instance.Universe)

Example 68 with Universe

use of kodkod.instance.Universe in project org.alloytools.alloy by AlloyTools.

the class BugTests method testFelix_03062008.

public final void testFelix_03062008() {
    Relation x0 = Relation.unary("Int/min");
    Relation x1 = Relation.unary("Int/zero");
    Relation x2 = Relation.unary("Int/max");
    Relation x3 = Relation.nary("Int/next", 2);
    Relation x4 = Relation.unary("seq/Int");
    List<String> atomlist = Arrays.asList("-1", "-2", "-3", "-4", "-5", "-6", "-7", "-8", "0", "1", "2", "3", "4", "5", "6", "7");
    Universe universe = new Universe(atomlist);
    TupleFactory factory = universe.factory();
    Bounds bounds = new Bounds(universe);
    TupleSet x0_upper = factory.noneOf(1);
    x0_upper.add(factory.tuple("-8"));
    bounds.boundExactly(x0, x0_upper);
    TupleSet x1_upper = factory.noneOf(1);
    x1_upper.add(factory.tuple("0"));
    bounds.boundExactly(x1, x1_upper);
    TupleSet x2_upper = factory.noneOf(1);
    x2_upper.add(factory.tuple("7"));
    bounds.boundExactly(x2, x2_upper);
    TupleSet x3_upper = factory.noneOf(2);
    x3_upper.add(factory.tuple("-8").product(factory.tuple("-7")));
    x3_upper.add(factory.tuple("-7").product(factory.tuple("-6")));
    x3_upper.add(factory.tuple("-6").product(factory.tuple("-5")));
    x3_upper.add(factory.tuple("-5").product(factory.tuple("-4")));
    x3_upper.add(factory.tuple("-4").product(factory.tuple("-3")));
    x3_upper.add(factory.tuple("-3").product(factory.tuple("-2")));
    x3_upper.add(factory.tuple("-2").product(factory.tuple("-1")));
    x3_upper.add(factory.tuple("-1").product(factory.tuple("0")));
    x3_upper.add(factory.tuple("0").product(factory.tuple("1")));
    x3_upper.add(factory.tuple("1").product(factory.tuple("2")));
    x3_upper.add(factory.tuple("2").product(factory.tuple("3")));
    x3_upper.add(factory.tuple("3").product(factory.tuple("4")));
    x3_upper.add(factory.tuple("4").product(factory.tuple("5")));
    x3_upper.add(factory.tuple("5").product(factory.tuple("6")));
    x3_upper.add(factory.tuple("6").product(factory.tuple("7")));
    bounds.boundExactly(x3, x3_upper);
    TupleSet x4_upper = factory.noneOf(1);
    x4_upper.add(factory.tuple("0"));
    bounds.boundExactly(x4, x4_upper);
    bounds.boundExactly(-8, factory.range(factory.tuple("-8"), factory.tuple("-8")));
    bounds.boundExactly(-7, factory.range(factory.tuple("-7"), factory.tuple("-7")));
    bounds.boundExactly(-6, factory.range(factory.tuple("-6"), factory.tuple("-6")));
    bounds.boundExactly(-5, factory.range(factory.tuple("-5"), factory.tuple("-5")));
    bounds.boundExactly(-4, factory.range(factory.tuple("-4"), factory.tuple("-4")));
    bounds.boundExactly(-3, factory.range(factory.tuple("-3"), factory.tuple("-3")));
    bounds.boundExactly(-2, factory.range(factory.tuple("-2"), factory.tuple("-2")));
    bounds.boundExactly(-1, factory.range(factory.tuple("-1"), factory.tuple("-1")));
    bounds.boundExactly(0, factory.range(factory.tuple("0"), factory.tuple("0")));
    bounds.boundExactly(1, factory.range(factory.tuple("1"), factory.tuple("1")));
    bounds.boundExactly(2, factory.range(factory.tuple("2"), factory.tuple("2")));
    bounds.boundExactly(3, factory.range(factory.tuple("3"), factory.tuple("3")));
    bounds.boundExactly(4, factory.range(factory.tuple("4"), factory.tuple("4")));
    bounds.boundExactly(5, factory.range(factory.tuple("5"), factory.tuple("5")));
    bounds.boundExactly(6, factory.range(factory.tuple("6"), factory.tuple("6")));
    bounds.boundExactly(7, factory.range(factory.tuple("7"), factory.tuple("7")));
    Variable x9 = Variable.unary("x");
    Decls x8 = x9.oneOf(Expression.INTS);
    Variable x14 = Variable.unary("p_t'");
    Expression x15 = Expression.INTS.difference(x9);
    Decls x13 = x14.oneOf(x15);
    Variable x20 = Variable.unary("p_v");
    Decls x19 = x20.oneOf(Expression.INTS);
    Formula x21 = x14.in(x9);
    Expression x18 = x21.comprehension(x19);
    IntExpression x17 = x18.count();
    IntExpression x22 = IntConstant.constant(0);
    Formula x16 = x17.gt(x22);
    Formula x12 = x16.forAll(x13);
    Formula x11 = x12.not();
    Formula x7 = x11.forAll(x8);
    Formula x25 = x0.eq(x0);
    Formula x26 = x2.eq(x2);
    Formula x24 = x25.and(x26);
    Formula x27 = x3.eq(x3);
    Formula x23 = x24.and(x27);
    Formula x6 = x7.and(x23);
    Formula x29 = x1.eq(x1);
    Formula x30 = x4.eq(x4);
    Formula x28 = x29.and(x30);
    Formula x5 = x6.and(x28);
    Solver solver = new Solver();
    solver.options().setSolver(SATFactory.DefaultSAT4J);
    solver.options().setBitwidth(4);
    // solver.options().setFlatten(false);
    solver.options().setIntEncoding(Options.IntEncoding.TWOSCOMPLEMENT);
    solver.options().setSymmetryBreaking(20);
    // System.out.println(PrettyPrinter.print(x5, 2));
    solver.options().setSkolemDepth(0);
    Solution sol1 = solver.solve(x5, bounds);
    assertNotNull(sol1.instance());
    solver.options().setSkolemDepth(1);
    Solution sol2 = solver.solve(x5, bounds);
    assertNotNull(sol2.instance());
}
Also used : TupleSet(kodkod.instance.TupleSet) Solver(kodkod.engine.Solver) Variable(kodkod.ast.Variable) Decls(kodkod.ast.Decls) Bounds(kodkod.instance.Bounds) IntExpression(kodkod.ast.IntExpression) TupleFactory(kodkod.instance.TupleFactory) Universe(kodkod.instance.Universe) Formula(kodkod.ast.Formula) Relation(kodkod.ast.Relation) IntExpression(kodkod.ast.IntExpression) Expression(kodkod.ast.Expression) Solution(kodkod.engine.Solution)

Example 69 with Universe

use of kodkod.instance.Universe in project org.alloytools.alloy by AlloyTools.

the class IncrementalOverflowNumTest method testBasic.

@Test
public void testBasic() {
    Options opt = new Options();
    opt.setNoOverflow(true);
    opt.setBitwidth(2);
    IncrementalSolver solver = IncrementalSolver.solver(opt);
    Universe univ = new Universe("-2", "-1", "0", "1");
    Bounds b = new Bounds(univ);
    TupleFactory factory = univ.factory();
    b.boundExactly(-2, factory.range(factory.tuple("-2"), factory.tuple("-2")));
    b.boundExactly(-1, factory.range(factory.tuple("-1"), factory.tuple("-1")));
    b.boundExactly(0, factory.range(factory.tuple("0"), factory.tuple("0")));
    b.boundExactly(1, factory.range(factory.tuple("1"), factory.tuple("1")));
    Variable n = Variable.unary("n");
    Formula f = n.sum().plus(IntConstant.constant(1)).lte(n.sum()).forSome(n.oneOf(Expression.INTS));
    Solution sol = solver.solve(f, b);
    assertNoInstance(sol);
}
Also used : Options(kodkod.engine.config.Options) Formula(kodkod.ast.Formula) Variable(kodkod.ast.Variable) Bounds(kodkod.instance.Bounds) TupleFactory(kodkod.instance.TupleFactory) Universe(kodkod.instance.Universe) IncrementalSolver(kodkod.engine.IncrementalSolver) Solution(kodkod.engine.Solution) Test(org.junit.Test)

Example 70 with Universe

use of kodkod.instance.Universe in project org.alloytools.alloy by AlloyTools.

the class InstanceCreator method getInstance.

/**
 * Fills the instance with the relations specified in this.document; if an error
 * occurs during processing, the instance remains null
 */
private Instance getInstance() {
    initAtomsAndRelations();
    final Universe u = new Universe(atoms);
    final TupleFactory f = u.factory();
    final Instance instance = new Instance(u);
    for (Map.Entry<Relation, Set<List<String>>> entry : relations.entrySet()) {
        Relation r = entry.getKey();
        TupleSet s = f.noneOf(r.arity());
        for (List<?> atoms : entry.getValue()) {
            s.add(f.tuple(atoms));
        }
        instance.add(r, s);
    }
    return instance;
}
Also used : TupleSet(kodkod.instance.TupleSet) Relation(kodkod.ast.Relation) LinkedHashSet(java.util.LinkedHashSet) TupleSet(kodkod.instance.TupleSet) Set(java.util.Set) Instance(kodkod.instance.Instance) TupleFactory(kodkod.instance.TupleFactory) Universe(kodkod.instance.Universe) HashMap(java.util.HashMap) Map(java.util.Map)

Aggregations

Universe (kodkod.instance.Universe)83 Bounds (kodkod.instance.Bounds)79 TupleFactory (kodkod.instance.TupleFactory)77 TupleSet (kodkod.instance.TupleSet)50 ArrayList (java.util.ArrayList)46 Relation (kodkod.ast.Relation)45 Formula (kodkod.ast.Formula)37 Solution (kodkod.engine.Solution)32 Solver (kodkod.engine.Solver)26 Variable (kodkod.ast.Variable)21 Expression (kodkod.ast.Expression)20 IntExpression (kodkod.ast.IntExpression)20 Instance (kodkod.instance.Instance)14 Decls (kodkod.ast.Decls)11 Evaluator (kodkod.engine.Evaluator)9 LinkedList (java.util.LinkedList)4 Tuple (kodkod.instance.Tuple)4 LinkedHashSet (java.util.LinkedHashSet)3 Map (java.util.Map)2 Set (java.util.Set)2