fix: containment link translation

Improper equality implementation of representative election literals merged weak
and strong connected components during query canonicalization.

2 files changed, 47 insertions, 2 deletions

diff --git a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
index 9d1b8cf4..eb112d0e 100644
--- a/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
+++ b/subprojects/store-reasoning/src/main/java/tools/refinery/store/reasoning/translator/containment/ContainmentHierarchyTranslator.java
@@ -156,7 +156,7 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 )
                                 .clause(representative -> List.of(
                                                 mayNewHelper.call(parent, child),
-                                                weakComponents.call(child, representative),
+                                                weakComponents.call(parent, representative),
                                                 // Violation of para-consistency:
                                                 // If there is a surely existing node with at least two containers, its (transitive) containers
                                                 // will end up in the same weakly connected component, and we will spuriously mark the
@@ -178,7 +178,7 @@ public class ContainmentHierarchyTranslator implements ModelStoreConfiguration {
                                 .clause(representative -> List.of(
                                                 mayExistingHelper.call(parent, child),
                                                 strongComponents.call(parent, representative),
-                                                not(strongComponents.call(parent, representative))
+                                                not(strongComponents.call(child, representative))
                                 )));
 
                 storeBuilder.with(PartialRelationTranslator.of(linkType)
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
index 9e74cf02..87e28e80 100644
--- 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
@@ -105,4 +105,49 @@ class MetamodelTest {
                 assertThat(enrolledStudentsInterpretation.get(Tuple.of(1, 3)), is(TruthValue.FALSE));
                 assertThat(enrolledStudentsInterpretation.get(Tuple.of(1, 4)), is(TruthValue.UNKNOWN));
         }
+
+        @Test
+        void simpleContainmentTest() {
+                var metamodel = Metamodel.builder()
+                                .type(university)
+                                .type(course)
+                                .reference(courses, university, true, course)
+                                .build();
+
+                var store = ModelStore.builder()
+                                .with(ViatraModelQueryAdapter.builder())
+                                .with(ReasoningAdapter.builder())
+                                .with(new MultiObjectTranslator())
+                                .with(new MetamodelTranslator(metamodel))
+                                .build();
+
+                var seed = ModelSeed.builder(4)
+                                .seed(MultiObjectTranslator.COUNT_SYMBOL, builder -> builder
+                                                .reducedValue(CardinalityIntervals.ONE)
+                                                .put(Tuple.of(0), CardinalityIntervals.SET)
+                                                .put(Tuple.of(1), CardinalityIntervals.SET))
+                                .seed(ContainmentHierarchyTranslator.CONTAINED_SYMBOL, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN))
+                                .seed(ContainmentHierarchyTranslator.CONTAINS_SYMBOL, 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(1), TruthValue.TRUE))
+                                .seed(courses, builder -> builder
+                                                .reducedValue(TruthValue.UNKNOWN)
+                                                .put(Tuple.of(2, 3), TruthValue.TRUE))
+                                .build();
+
+                var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(seed);
+                var coursesInterpretation = model.getAdapter(ReasoningAdapter.class)
+                                .getPartialInterpretation(Concreteness.PARTIAL, courses);
+
+                assertThat(coursesInterpretation.get(Tuple.of(0, 1)), is(TruthValue.UNKNOWN));
+                assertThat(coursesInterpretation.get(Tuple.of(0, 3)), is(TruthValue.FALSE));
+                assertThat(coursesInterpretation.get(Tuple.of(2, 1)), is(TruthValue.UNKNOWN));
+                assertThat(coursesInterpretation.get(Tuple.of(2, 3)), is(TruthValue.TRUE));
+        }
 }