fix: containment link translation

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

4 files changed, 72 insertions, 5 deletions

diff --git a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
index 483d24f6..eb7ab204 100644
--- a/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
+++ b/subprojects/language-web/src/main/java/tools/refinery/language/web/semantics/SemanticsService.java
@@ -54,7 +54,10 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
 
         @Override
         public SemanticsResult compute(IXtextWebDocument doc, CancelIndicator cancelIndicator) {
-                long start = System.currentTimeMillis();
+                long start = 0;
+                if (LOG.isTraceEnabled()) {
+                        start = System.currentTimeMillis();
+                }
                 Problem problem = getProblem(doc, cancelIndicator);
                 if (problem == null) {
                         return null;
@@ -73,8 +76,11 @@ public class SemanticsService extends AbstractCachedService<SemanticsResult> {
                         var model = store.getAdapter(ReasoningStoreAdapter.class).createInitialModel(modelSeed);
                         operationCanceledManager.checkCanceled(cancelIndicator);
                         var partialInterpretation = getPartialInterpretation(initializer, model, cancelIndicator);
-                        long end = System.currentTimeMillis();
-                        LOG.info("Computed semantics for {} ({}) in {}ms", doc.getResourceId(), doc.getStateId(), end - start);
+                        if (LOG.isTraceEnabled()) {
+                                long end = System.currentTimeMillis();
+                                LOG.trace("Computed semantics for {} ({}) in {}ms", doc.getResourceId(), doc.getStateId(),
+                                                end - start);
+                        }
                         return new SemanticsSuccessResult(nodeTrace, partialInterpretation);
                 } catch (RuntimeException e) {
                         LOG.error("Error while computing semantics", e);
diff --git a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
index 5d57c06c..f6545f9f 100644
--- a/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
+++ b/subprojects/store-query/src/main/java/tools/refinery/store/query/literal/RepresentativeElectionLiteral.java
@@ -6,6 +6,8 @@
 package tools.refinery.store.query.literal;
 
 import tools.refinery.store.query.Constraint;
+import tools.refinery.store.query.equality.LiteralEqualityHelper;
+import tools.refinery.store.query.equality.LiteralHashCodeHelper;
 import tools.refinery.store.query.substitution.Substitution;
 import tools.refinery.store.query.term.NodeVariable;
 import tools.refinery.store.query.term.ParameterDirection;
@@ -82,6 +84,20 @@ public class RepresentativeElectionLiteral extends AbstractCallLiteral {
         }
 
         @Override
+        public boolean equalsWithSubstitution(LiteralEqualityHelper helper, Literal other) {
+                if (!super.equalsWithSubstitution(helper, other)) {
+                        return false;
+                }
+                var otherRepresentativeElectionLiteral = (RepresentativeElectionLiteral) other;
+                return connectivity.equals(otherRepresentativeElectionLiteral.connectivity);
+        }
+
+        @Override
+        public int hashCodeWithSubstitution(LiteralHashCodeHelper helper) {
+                return super.hashCodeWithSubstitution(helper) * 31 + connectivity.hashCode();
+        }
+
+        @Override
         public String toString() {
                 var builder = new StringBuilder();
                 builder.append("@Representative(\"");
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));
+        }
 }