fix: build failures after integrating generation

3 files changed, 24 insertions, 351 deletions

diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
index 8470bb99..c745d86e 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsWorker.java
@@ -22,6 +22,7 @@ import tools.refinery.language.semantics.metadata.MetadataCreator;
 import tools.refinery.language.semantics.model.ModelInitializer;
 import tools.refinery.language.semantics.model.SemanticsUtils;
 import tools.refinery.language.semantics.model.TracedException;
+import tools.refinery.store.dse.propagation.PropagationAdapter;
 import tools.refinery.store.map.Cursor;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.model.ModelStore;
@@ -29,9 +30,7 @@ import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
 import tools.refinery.store.reasoning.ReasoningAdapter;
 import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.literal.Concreteness;
-import tools.refinery.store.reasoning.refinement.RefinementResult;
 import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.scope.ScopePropagatorAdapter;
 import tools.refinery.store.reasoning.translator.TranslationException;
 import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.tuple.Tuple;
@@ -77,9 +76,9 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                 var builder = ModelStore.builder()
                                 .with(ViatraModelQueryAdapter.builder()
                                                 .cancellationToken(cancellationToken))
+                                .with(PropagationAdapter.builder())
                                 .with(ReasoningAdapter.builder()
-                                                .requiredInterpretations(Concreteness.PARTIAL))
-                                .with(ScopePropagatorAdapter.builder());
+                                                .requiredInterpretations(Concreteness.PARTIAL));
                 cancellationToken.checkCancelled();
                 try {
                         var modelSeed = initializer.createModel(problem, builder);
@@ -94,9 +93,6 @@ class SemanticsWorker implements Callable<SemanticsResult> {
                         cancellationToken.checkCancelled();
                         var cancellableModelSeed = CancellableSeed.wrap(cancellationToken, modelSeed);
                         var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(cancellableModelSeed);
-                        if (model.getAdapter(ScopePropagatorAdapter.class).propagate() == RefinementResult.REJECTED) {
-                                return new SemanticsInternalErrorResult("Scopes are unsatisfiable");
-                        }
                         cancellationToken.checkCancelled();
                         var partialInterpretation = getPartialInterpretation(initializer, model);
 
diff --git a/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/MultiObjectTest.java b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/MultiObjectTest.java
index 5fc70ae1..0132b3f9 100644
--- a/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/MultiObjectTest.java
+++ b/subprojects/store-reasoning-scope/src/test/java/tools/refinery/store/reasoning/scope/MultiObjectTest.java
@@ -27,11 +27,13 @@ import tools.refinery.store.tuple.Tuple;
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.is;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 class MultiObjectTest {
         private static final PartialRelation person = new PartialRelation("Person", 1);
 
         private ModelStore store;
+        private ReasoningStoreAdapter reasoningStoreAdapter;
         private Model model;
         private Interpretation<CardinalityInterval> countStorage;
 
@@ -47,6 +49,7 @@ class MultiObjectTest {
                                 .with(new ScopePropagator()
                                                 .scope(person, CardinalityIntervals.between(5, 15)))
                                 .build();
+                reasoningStoreAdapter = store.getAdapter(ReasoningStoreAdapter.class);
                 model = null;
                 countStorage = null;
         }
@@ -59,7 +62,6 @@ class MultiObjectTest {
                                                 .put(Tuple.of(0), CardinalityIntervals.SET))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
                                 .build());
-                assertThat(propagate(), is(PropagationResult.PROPAGATED));
                 assertThat(countStorage.get(Tuple.of(0)), is(CardinalityIntervals.between(2, 12)));
         }
 
@@ -71,19 +73,18 @@ class MultiObjectTest {
                                                 .put(Tuple.of(0), CardinalityIntervals.between(5, 20)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
                                 .build());
-                assertThat(propagate(), is(PropagationResult.PROPAGATED));
                 assertThat(countStorage.get(Tuple.of(0)), is(CardinalityIntervals.between(5, 12)));
         }
 
         @Test
         void oneMultiObjectUnsatisfiableUpperTest() {
-                createModel(ModelSeed.builder(21)
+                var seed = ModelSeed.builder(21)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.SET))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
@@ -97,33 +98,33 @@ class MultiObjectTest {
 
         @Test
         void noMultiObjectUnsatisfiableTest() {
-                createModel(ModelSeed.builder(2)
+                var seed = ModelSeed.builder(2)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder.reducedValue(CardinalityIntervals.ONE))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
         void oneMultiObjectExistingBoundUnsatisfiableLowerTest() {
-                createModel(ModelSeed.builder(4)
+                var seed = ModelSeed.builder(4)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.atLeast(20)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
         void oneMultiObjectExistingBoundUnsatisfiableUpperTest() {
-                createModel(ModelSeed.builder(4)
+                var seed = ModelSeed.builder(4)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.atMost(1)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
@@ -135,7 +136,6 @@ class MultiObjectTest {
                                                 .put(Tuple.of(1), CardinalityIntervals.SET))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
                                 .build());
-                assertThat(propagate(), is(PropagationResult.PROPAGATED));
                 assertThat(countStorage.get(Tuple.of(0)), is(CardinalityIntervals.atMost(12)));
                 assertThat(countStorage.get(Tuple.of(1)), is(CardinalityIntervals.atMost(12)));
         }
@@ -149,33 +149,32 @@ class MultiObjectTest {
                                                 .put(Tuple.of(1), CardinalityIntervals.atMost(11)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
                                 .build());
-                assertThat(propagate(), is(PropagationResult.PROPAGATED));
                 assertThat(countStorage.get(Tuple.of(0)), is(CardinalityIntervals.between(7, 12)));
                 assertThat(countStorage.get(Tuple.of(1)), is(CardinalityIntervals.atMost(5)));
         }
 
         @Test
         void twoMultiObjectsExistingBoundUnsatisfiableUpperTest() {
-                createModel(ModelSeed.builder(5)
+                var seed = ModelSeed.builder(5)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.between(7, 20))
                                                 .put(Tuple.of(1), CardinalityIntervals.exactly(11)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
         void twoMultiObjectsExistingBoundUnsatisfiableLowerTest() {
-                createModel(ModelSeed.builder(3)
+                var seed = ModelSeed.builder(3)
                                 .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
                                                 .reducedValue(CardinalityIntervals.ONE)
                                                 .put(Tuple.of(0), CardinalityIntervals.LONE)
                                                 .put(Tuple.of(1), CardinalityIntervals.atMost(2)))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .build());
-                assertThat(propagate(), is(PropagationResult.REJECTED));
+                                .build();
+                assertThrows(IllegalArgumentException.class, () -> reasoningStoreAdapter.createInitialModel(seed));
         }
 
         @Test
@@ -187,7 +186,6 @@ class MultiObjectTest {
                                                 .put(Tuple.of(1), CardinalityIntervals.SET))
                                 .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
                                 .build());
-                assertThat(propagate(), is(PropagationResult.PROPAGATED));
                 assertThat(countStorage.get(Tuple.of(0)), is(CardinalityIntervals.LONE));
                 assertThat(countStorage.get(Tuple.of(1)), is(CardinalityIntervals.between(1, 12)));
                 countStorage.put(Tuple.of(0), CardinalityIntervals.ONE);
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/CandidateCountTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/CandidateCountTest.java
deleted file mode 100644
index 28391ec7..00000000
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/CandidateCountTest.java
+++ /dev/null
@@ -1,321 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
- *
- * SPDX-License-Identifier: EPL-2.0
- */
-package tools.refinery.store.reasoning.translator.multiobject;
-
-import org.junit.jupiter.api.Test;
-import tools.refinery.store.model.ModelStore;
-import tools.refinery.store.query.ModelQueryAdapter;
-import tools.refinery.store.query.dnf.Query;
-import tools.refinery.store.query.resultset.ResultSet;
-import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.viatra.ViatraModelQueryAdapter;
-import tools.refinery.store.reasoning.ReasoningAdapter;
-import tools.refinery.store.reasoning.ReasoningStoreAdapter;
-import tools.refinery.store.reasoning.literal.CountCandidateLowerBoundLiteral;
-import tools.refinery.store.reasoning.literal.CountCandidateUpperBoundLiteral;
-import tools.refinery.store.reasoning.representation.PartialRelation;
-import tools.refinery.store.reasoning.seed.ModelSeed;
-import tools.refinery.store.reasoning.translator.PartialRelationTranslator;
-import tools.refinery.store.representation.Symbol;
-import tools.refinery.store.representation.TruthValue;
-import tools.refinery.store.representation.cardinality.CardinalityIntervals;
-import tools.refinery.store.tuple.Tuple;
-
-import java.util.List;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.is;
-import static tools.refinery.store.query.literal.Literals.not;
-import static tools.refinery.store.reasoning.literal.PartialLiterals.must;
-
-class CandidateCountTest {
-        private static final PartialRelation person = new PartialRelation("Person", 1);
-        private static final PartialRelation friend = new PartialRelation("friend", 2);
-
-        @Test
-        void lowerBoundZeroTest() {
-                var query = Query.of("LowerBound", Integer.class, (builder, p1, p2, output) -> builder.clause(
-                                must(person.call(p1)),
-                                must(person.call(p2)),
-                                new CountCandidateLowerBoundLiteral(output, friend, List.of(p1, p2))
-                ));
-
-                var modelSeed = ModelSeed.builder(2)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .put(Tuple.of(0), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(1), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0, 0)), is(0));
-                assertThat(resultSet.get(Tuple.of(0, 1)), is(1));
-                assertThat(resultSet.get(Tuple.of(1, 0)), is(0));
-                assertThat(resultSet.get(Tuple.of(1, 1)), is(1));
-        }
-
-        @Test
-        void upperBoundZeroTest() {
-                var query = Query.of("UpperBound", Integer.class, (builder, p1, p2, output) -> builder.clause(
-                                must(person.call(p1)),
-                                must(person.call(p2)),
-                                new CountCandidateUpperBoundLiteral(output, friend, List.of(p1, p2))
-                ));
-
-                var modelSeed = ModelSeed.builder(2)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .put(Tuple.of(0), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(1), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0, 0)), is(0));
-                assertThat(resultSet.get(Tuple.of(0, 1)), is(1));
-                assertThat(resultSet.get(Tuple.of(1, 0)), is(0));
-                assertThat(resultSet.get(Tuple.of(1, 1)), is(1));
-        }
-
-        @Test
-        void lowerBoundOneTest() {
-                var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(
-                                must(person.call(p1)),
-                                new CountCandidateLowerBoundLiteral(output, friend, List.of(p1, Variable.of()))
-                ));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 3), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(2));
-                assertThat(resultSet.get(Tuple.of(1)), is(1));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        @Test
-        void upperBoundOneTest() {
-                var query = Query.of("UpperBound", Integer.class, (builder, p1, output) -> builder.clause(
-                                must(person.call(p1)),
-                                new CountCandidateUpperBoundLiteral(output, friend, List.of(p1, Variable.of()))
-                ));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 3), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(2));
-                assertThat(resultSet.get(Tuple.of(1)), is(1));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        @Test
-        void lowerBoundTwoTest() {
-                var subQuery = Query.of("SubQuery", (builder, p1, p2, p3) -> builder.clause(
-                                friend.call(p1, p2),
-                                friend.call(p1, p3),
-                                friend.call(p2, p3)
-                ));
-                var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(
-                                must(person.call(p1)),
-                                new CountCandidateLowerBoundLiteral(output, subQuery.getDnf(),
-                                                List.of(p1, Variable.of(), Variable.of()))
-                ));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(0), CardinalityIntervals.between(5, 9))
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(1));
-                assertThat(resultSet.get(Tuple.of(1)), is(1));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        @Test
-        void upperBoundTwoTest() {
-                var subQuery = Query.of("SubQuery", (builder, p1, p2, p3) -> builder.clause(
-                                friend.call(p1, p2),
-                                friend.call(p1, p3),
-                                friend.call(p2, p3)
-                ));
-                var query = Query.of("UpperBound", Integer.class, (builder, p1, output) -> builder.clause(
-                                must(person.call(p1)),
-                                new CountCandidateUpperBoundLiteral(output, subQuery.getDnf(),
-                                                List.of(p1, Variable.of(), Variable.of()))
-                ));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(0), CardinalityIntervals.between(5, 9))
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 3), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(0));
-                assertThat(resultSet.get(Tuple.of(1)), is(0));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        @Test
-        void lowerBoundDiagonalTest() {
-                var subQuery = Query.of("SubQuery", (builder, p1, p2, p3) -> builder.clause(
-                                friend.call(p1, p2),
-                                friend.call(p1, p3),
-                                not(friend.call(p2, p3))
-                ));
-                var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(v1 -> List.of(
-                                must(person.call(p1)),
-                                new CountCandidateLowerBoundLiteral(output, subQuery.getDnf(), List.of(p1, v1, v1))
-                )));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(0), CardinalityIntervals.between(5, 9))
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 3), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(2));
-                assertThat(resultSet.get(Tuple.of(1)), is(1));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        @Test
-        void upperBoundDiagonalTest() {
-                var subQuery = Query.of("SubQuery", (builder, p1, p2, p3) -> builder.clause(
-                                friend.call(p1, p2),
-                                friend.call(p1, p3),
-                                not(friend.call(p2, p3))
-                ));
-                var query = Query.of("UpperBound", Integer.class, (builder, p1, output) -> builder
-                                .clause(v1 -> List.of(
-                                                must(person.call(p1)),
-                                                new CountCandidateUpperBoundLiteral(output, subQuery.getDnf(), List.of(p1, v1, v1))
-                                )));
-
-                var modelSeed = ModelSeed.builder(4)
-                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
-                                                .reducedValue(CardinalityIntervals.ONE)
-                                                .put(Tuple.of(0), CardinalityIntervals.between(5, 9))
-                                                .put(Tuple.of(1), CardinalityIntervals.atLeast(3))
-                                                .put(Tuple.of(2), CardinalityIntervals.atMost(7)))
-                                .seed(person, builder -> builder.reducedValue(TruthValue.TRUE))
-                                .seed(friend, builder -> builder
-                                                .put(Tuple.of(0, 1), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 2), TruthValue.TRUE)
-                                                .put(Tuple.of(0, 3), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(1, 2), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(1, 3), TruthValue.UNKNOWN)
-                                                .put(Tuple.of(2, 0), TruthValue.TRUE)
-                                                .put(Tuple.of(2, 1), TruthValue.ERROR))
-                                .build();
-
-                var resultSet = getResultSet(query, modelSeed);
-                assertThat(resultSet.get(Tuple.of(0)), is(2));
-                assertThat(resultSet.get(Tuple.of(1)), is(1));
-                assertThat(resultSet.get(Tuple.of(2)), is(2));
-                assertThat(resultSet.get(Tuple.of(3)), is(0));
-        }
-
-        private static <T> ResultSet<T> getResultSet(Query<T> query, ModelSeed modelSeed) {
-                var personStorage = Symbol.of("Person", 1, TruthValue.class, TruthValue.FALSE);
-                var friendStorage = Symbol.of("friend", 2, TruthValue.class, TruthValue.FALSE);
-
-                var store = ModelStore.builder()
-                                .with(ViatraModelQueryAdapter.builder()
-                                                .query(query))
-                                .with(ReasoningAdapter.builder())
-                                .with(new MultiObjectTranslator())
-                                .with(PartialRelationTranslator.of(person)
-                                                .symbol(personStorage))
-                                .with(PartialRelationTranslator.of(friend)
-                                                .symbol(friendStorage))
-                                .build();
-
-                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
-                return model.getAdapter(ModelQueryAdapter.class).getResultSet(query);
-        }
-}