feat: metamodel translator

4 files changed, 442 insertions, 16 deletions

diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
index b2188f5d..77560a68 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/PartialModelTest.java
@@ -49,7 +49,7 @@ class PartialModelTest {
                                                 .symbol(personStorage))
                                 .with(PartialRelationTranslator.of(friend)
                                                 .symbol(friendStorage)
-                                                .may(Query.of("mayPerson", (builder, p1, p2) -> builder.clause(
+                                                .may(Query.of("mayFriend", (builder, p1, p2) -> builder.clause(
                                                                 may(person.call(p1)),
                                                                 may(person.call(p2)),
                                                                 not(must(EQUALS_SYMBOL.call(p1, p2))),
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
new file mode 100644
index 00000000..9e74cf02
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/metamodel/MetamodelTest.java
@@ -0,0 +1,108 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.store.reasoning.translator.metamodel;
+
+import org.junit.jupiter.api.Test;
+import tools.refinery.store.model.ModelStore;
+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.representation.PartialRelation;
+import tools.refinery.store.reasoning.seed.ModelSeed;
+import tools.refinery.store.reasoning.translator.containment.ContainmentHierarchyTranslator;
+import tools.refinery.store.reasoning.translator.multiobject.MultiObjectTranslator;
+import tools.refinery.store.reasoning.translator.multiplicity.ConstrainedMultiplicity;
+import tools.refinery.store.representation.TruthValue;
+import tools.refinery.store.representation.cardinality.CardinalityIntervals;
+import tools.refinery.store.tuple.Tuple;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+class MetamodelTest {
+        private final PartialRelation person = new PartialRelation("Person", 1);
+        private final PartialRelation student = new PartialRelation("Student", 1);
+        private final PartialRelation teacher = new PartialRelation("Teacher", 1);
+        private final PartialRelation university = new PartialRelation("University", 1);
+        private final PartialRelation course = new PartialRelation("Course", 1);
+        private final PartialRelation courses = new PartialRelation("courses", 2);
+        private final PartialRelation location = new PartialRelation("location", 2);
+        private final PartialRelation lecturer = new PartialRelation("lecturer", 2);
+        private final PartialRelation invalidLecturerCount = new PartialRelation("invalidLecturerCount", 1);
+        private final PartialRelation enrolledStudents = new PartialRelation("enrolledStudents", 2);
+        private final PartialRelation invalidStudentCount = new PartialRelation("invalidStudentCount", 1);
+
+        @Test
+        void metamodelTest() {
+                var metamodel = Metamodel.builder()
+                                .type(person, true)
+                                .type(student, person)
+                                .type(teacher, person)
+                                .type(university)
+                                .type(course)
+                                .reference(courses, university, true, course, location)
+                                .reference(location, course, university, courses)
+                                .reference(lecturer, course,
+                                                ConstrainedMultiplicity.of(CardinalityIntervals.ONE, invalidLecturerCount), teacher)
+                                .reference(enrolledStudents, course,
+                                                ConstrainedMultiplicity.of(CardinalityIntervals.SOME, invalidStudentCount), student)
+                                .build();
+
+                var store = ModelStore.builder()
+                                .with(ViatraModelQueryAdapter.builder())
+                                .with(ReasoningAdapter.builder())
+                                .with(new MultiObjectTranslator())
+                                .with(new MetamodelTranslator(metamodel))
+                                .build();
+
+                var seed = ModelSeed.builder(5)
+                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
+                                                .reducedValue(CardinalityIntervals.ONE)
+                                                .put(Tuple.of(1), CardinalityIntervals.SET)
+                                                .put(Tuple.of(4), CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN))
+                                .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN))
+                                .seed(person, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(student, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(teacher, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(university, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(0), TruthValue.TRUE))
+                                .seed(course, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(2), TruthValue.TRUE))
+                                .seed(courses, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .seed(location, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(1, 0), TruthValue.TRUE))
+                                .seed(lecturer, builder -> builder
+                                                .reducedValue(TruthValue.FALSE)
+                                                .put(Tuple.of(1, 3), TruthValue.TRUE))
+                                .seed(enrolledStudents, builder -> builder.reducedValue(TruthValue.UNKNOWN))
+                                .build();
+
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(seed);
+                var reasoningAdapter = model.getAdapter(ReasoningAdapter.class);
+
+                var coursesInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL, courses);
+                assertThat(coursesInterpretation.get(Tuple.of(0, 1)), is(TruthValue.TRUE));
+                assertThat(coursesInterpretation.get(Tuple.of(0, 2)), is(TruthValue.UNKNOWN));
+                assertThat(coursesInterpretation.get(Tuple.of(0, 3)), is(TruthValue.FALSE));
+
+                var invalidLecturerCountInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL,
+                                invalidLecturerCount);
+                assertThat(invalidLecturerCountInterpretation.get(Tuple.of(1)), is(TruthValue.FALSE));
+                assertThat(invalidLecturerCountInterpretation.get(Tuple.of(2)), is(TruthValue.ERROR));
+
+                var enrolledStudentsInterpretation = reasoningAdapter.getPartialInterpretation(Concreteness.PARTIAL,
+                                enrolledStudents);
+                assertThat(enrolledStudentsInterpretation.get(Tuple.of(1, 3)), is(TruthValue.FALSE));
+                assertThat(enrolledStudentsInterpretation.get(Tuple.of(1, 4)), is(TruthValue.UNKNOWN));
+        }
+}
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
new file mode 100644
index 00000000..28391ec7
--- /dev/null
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/CandidateCountTest.java
@@ -0,0 +1,321 @@
+/*
+ * 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);
+        }
+}
diff --git a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/ConcreteCountTest.java b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/PartialCountTest.java
index 21111d7c..64230cf6 100644
--- a/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/ConcreteCountTest.java
+++ b/subprojects/store-reasoning/src/test/java/tools/refinery/store/reasoning/translator/multiobject/PartialCountTest.java
@@ -3,7 +3,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  */
-package tools.refinery.store.reasoning;
+package tools.refinery.store.reasoning.translator.multiobject;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.ModelStore;
@@ -12,13 +12,13 @@ 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.literal.Concreteness;
+import tools.refinery.store.reasoning.ReasoningAdapter;
+import tools.refinery.store.reasoning.ReasoningStoreAdapter;
 import tools.refinery.store.reasoning.literal.CountLowerBoundLiteral;
 import tools.refinery.store.reasoning.literal.CountUpperBoundLiteral;
 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.reasoning.translator.multiobject.MultiObjectTranslator;
 import tools.refinery.store.representation.Symbol;
 import tools.refinery.store.representation.TruthValue;
 import tools.refinery.store.representation.cardinality.CardinalityIntervals;
@@ -33,7 +33,7 @@ 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 ConcreteCountTest {
+class PartialCountTest {
         private static final PartialRelation person = new PartialRelation("Person", 1);
         private static final PartialRelation friend = new PartialRelation("friend", 2);
 
@@ -42,7 +42,7 @@ class ConcreteCountTest {
                 var query = Query.of("LowerBound", Integer.class, (builder, p1, p2, output) -> builder.clause(
                                 must(person.call(p1)),
                                 must(person.call(p2)),
-                                new CountLowerBoundLiteral(output, Concreteness.PARTIAL, friend, List.of(p1, p2))
+                                new CountLowerBoundLiteral(output, friend, List.of(p1, p2))
                 ));
 
                 var modelSeed = ModelSeed.builder(2)
@@ -68,7 +68,7 @@ class ConcreteCountTest {
                 var query = Query.of("UpperBound", UpperCardinality.class, (builder, p1, p2, output) -> builder.clause(
                                 must(person.call(p1)),
                                 must(person.call(p2)),
-                                new CountUpperBoundLiteral(output, Concreteness.PARTIAL, friend, List.of(p1, p2))
+                                new CountUpperBoundLiteral(output, friend, List.of(p1, p2))
                 ));
 
                 var modelSeed = ModelSeed.builder(2)
@@ -93,7 +93,7 @@ class ConcreteCountTest {
         void lowerBoundOneTest() {
                 var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(
                                 must(person.call(p1)),
-                                new CountLowerBoundLiteral(output, Concreteness.PARTIAL, friend, List.of(p1, Variable.of()))
+                                new CountLowerBoundLiteral(output, friend, List.of(p1, Variable.of()))
                 ));
 
                 var modelSeed = ModelSeed.builder(4)
@@ -124,7 +124,7 @@ class ConcreteCountTest {
         void upperBoundOneTest() {
                 var query = Query.of("UpperBound", UpperCardinality.class, (builder, p1, output) -> builder.clause(
                                 must(person.call(p1)),
-                                new CountUpperBoundLiteral(output, Concreteness.PARTIAL, friend, List.of(p1, Variable.of()))
+                                new CountUpperBoundLiteral(output, friend, List.of(p1, Variable.of()))
                 ));
 
                 var modelSeed = ModelSeed.builder(4)
@@ -160,8 +160,7 @@ class ConcreteCountTest {
                 ));
                 var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(
                                 must(person.call(p1)),
-                                new CountLowerBoundLiteral(output, Concreteness.PARTIAL, subQuery.getDnf(),
-                                                List.of(p1, Variable.of(), Variable.of()))
+                                new CountLowerBoundLiteral(output, subQuery.getDnf(), List.of(p1, Variable.of(), Variable.of()))
                 ));
 
                 var modelSeed = ModelSeed.builder(4)
@@ -198,8 +197,7 @@ class ConcreteCountTest {
                 ));
                 var query = Query.of("UpperBound", UpperCardinality.class, (builder, p1, output) -> builder.clause(
                                 must(person.call(p1)),
-                                new CountUpperBoundLiteral(output, Concreteness.PARTIAL, subQuery.getDnf(),
-                                                List.of(p1, Variable.of(), Variable.of()))
+                                new CountUpperBoundLiteral(output, subQuery.getDnf(), List.of(p1, Variable.of(), Variable.of()))
                 ));
 
                 var modelSeed = ModelSeed.builder(4)
@@ -236,7 +234,7 @@ class ConcreteCountTest {
                 ));
                 var query = Query.of("LowerBound", Integer.class, (builder, p1, output) -> builder.clause(v1 -> List.of(
                                 must(person.call(p1)),
-                                new CountLowerBoundLiteral(output, Concreteness.PARTIAL, subQuery.getDnf(), List.of(p1, v1, v1))
+                                new CountLowerBoundLiteral(output, subQuery.getDnf(), List.of(p1, v1, v1))
                 )));
 
                 var modelSeed = ModelSeed.builder(4)
@@ -274,8 +272,7 @@ class ConcreteCountTest {
                 var query = Query.of("UpperBound", UpperCardinality.class, (builder, p1, output) -> builder
                                 .clause(v1 -> List.of(
                                                 must(person.call(p1)),
-                                                new CountUpperBoundLiteral(output, Concreteness.PARTIAL, subQuery.getDnf(),
-                                                                List.of(p1, v1, v1))
+                                                new CountUpperBoundLiteral(output, subQuery.getDnf(), List.of(p1, v1, v1))
                                 )));
 
                 var modelSeed = ModelSeed.builder(4)