refactor: DNF atoms

Restore count != capability.

Still needs semantics and tests for count atoms over partial models.

32 files changed, 648 insertions, 288 deletions

diff --git a/subprojects/frontend/src/language/problem.grammar b/subprojects/frontend/src/language/problem.grammar
index 1e1ef70f..d630b9c4 100644
--- a/subprojects/frontend/src/language/problem.grammar
+++ b/subprojects/frontend/src/language/problem.grammar
@@ -153,7 +153,7 @@ sep1<separator, content> { content (separator content)* }
     "\"" (![\\"\n] | "\\" (![\n] | "\n"))* "\""
   }
 
-  ComparisonOp { ">" | ">=" | "<" | "<=" | "==" }
+  ComparisonOp { ">" | ">=" | "<" | "<=" | "==" | "!=" }
 
   NotOp { "!" }
 
diff --git a/subprojects/language-model/problem.aird b/subprojects/language-model/problem.aird
index a02adf78..b877ac3b 100644
--- a/subprojects/language-model/problem.aird
+++ b/subprojects/language-model/problem.aird
@@ -7,7 +7,7 @@
     <semanticResources>build/resources/main/model/problem.genmodel</semanticResources>
     <ownedViews xmi:type="viewpoint:DView" uid="_CsAAYKA4EeuqkpDnuik1sg">
       <viewpoint xmi:type="description:Viewpoint" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']"/>
-      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" uid="_CsYa4KA4EeuqkpDnuik1sg" name="problem" repPath="#_CsUwgKA4EeuqkpDnuik1sg" changeId="289bce27-d1d3-48e4-ba46-87251d9867ca">
+      <ownedRepresentationDescriptors xmi:type="viewpoint:DRepresentationDescriptor" uid="_CsYa4KA4EeuqkpDnuik1sg" name="problem" repPath="#_CsUwgKA4EeuqkpDnuik1sg" changeId="abc164e8-7868-44c9-a3f3-3aee2fd8009a">
         <description xmi:type="description_1:DiagramDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']"/>
         <target xmi:type="ecore:EPackage" href="src/main/resources/model/problem.ecore#/"/>
       </ownedRepresentationDescriptors>
@@ -601,11 +601,15 @@
               <styles xmi:type="notation:FontStyle" xmi:id="_RN1AMRg0Ee2_erjsEmF9GQ" fontName="Noto Sans" fontHeight="8"/>
               <layoutConstraint xmi:type="notation:Location" xmi:id="_RN1AMhg0Ee2_erjsEmF9GQ"/>
             </children>
+            <children xmi:type="notation:Node" xmi:id="_iSdpcFCpEe20ctwQhs06ZQ" type="3010" element="_iRojAFCpEe20ctwQhs06ZQ">
+              <styles xmi:type="notation:FontStyle" xmi:id="_iSdpcVCpEe20ctwQhs06ZQ" fontName="Noto Sans" fontHeight="8"/>
+              <layoutConstraint xmi:type="notation:Location" xmi:id="_iSdpclCpEe20ctwQhs06ZQ"/>
+            </children>
             <styles xmi:type="notation:SortingStyle" xmi:id="_LinJ1Rg0Ee2_erjsEmF9GQ"/>
             <styles xmi:type="notation:FilteringStyle" xmi:id="_LinJ1hg0Ee2_erjsEmF9GQ"/>
           </children>
           <styles xmi:type="notation:ShapeStyle" xmi:id="_LinJ0Rg0Ee2_erjsEmF9GQ" fontName="Noto Sans" fontHeight="8"/>
-          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LinJ0hg0Ee2_erjsEmF9GQ" x="2232" y="60" width="120" height="111"/>
+          <layoutConstraint xmi:type="notation:Bounds" xmi:id="_LinJ0hg0Ee2_erjsEmF9GQ" x="2232" y="60" width="120" height="135"/>
         </children>
         <children xmi:type="notation:Node" xmi:id="_xp1icDNlEe2fD4dIhR_vzA" type="2003" element="_xpDfUDNlEe2fD4dIhR_vzA">
           <children xmi:type="notation:Node" xmi:id="_xp2JgDNlEe2fD4dIhR_vzA" type="5007"/>
@@ -3754,6 +3758,14 @@
         </ownedStyle>
         <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']"/>
       </ownedElements>
+      <ownedElements xmi:type="diagram:DNodeListElement" uid="_iRojAFCpEe20ctwQhs06ZQ" name="NOT_EQ" tooltipText="">
+        <target xmi:type="ecore:EEnumLiteral" href="src/main/resources/model/problem.ecore#//ComparisonOp/NOT_EQ"/>
+        <semanticElements xmi:type="ecore:EEnumLiteral" href="src/main/resources/model/problem.ecore#//ComparisonOp/NOT_EQ"/>
+        <ownedStyle xmi:type="diagram:BundledImage" uid="_iRqYMFCpEe20ctwQhs06ZQ" labelAlignment="LEFT">
+          <description xmi:type="style:BundledImageDescription" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']/@style"/>
+        </ownedStyle>
+        <actualMapping xmi:type="description_1:NodeMapping" href="platform:/plugin/org.eclipse.emf.ecoretools.design/description/ecore.odesign#//@ownedViewpoints[name='Design']/@ownedRepresentations[name='Entities']/@defaultLayer/@containerMappings[name='EC%20EEnum']/@subNodeMappings[name='EC%20EEnumLiteral']"/>
+      </ownedElements>
     </ownedDiagramElements>
     <ownedDiagramElements xmi:type="diagram:DNodeList" uid="_xpDfUDNlEe2fD4dIhR_vzA" name="ReferenceKind" tooltipText="" width="12" height="10">
       <target xmi:type="ecore:EEnum" href="src/main/resources/model/problem.ecore#//ReferenceKind"/>
diff --git a/subprojects/language-model/src/main/resources/model/problem.ecore b/subprojects/language-model/src/main/resources/model/problem.ecore
index 0106dd61..4ef023c1 100644
--- a/subprojects/language-model/src/main/resources/model/problem.ecore
+++ b/subprojects/language-model/src/main/resources/model/problem.ecore
@@ -191,6 +191,7 @@
     <eLiterals name="GREATER" value="2"/>
     <eLiterals name="GREATER_EQ" value="3"/>
     <eLiterals name="EQ" value="4"/>
+    <eLiterals name="NOT_EQ" value="5"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EEnum" name="ReferenceKind">
     <eLiterals name="DEFAULT"/>
diff --git a/subprojects/language-model/src/main/resources/model/problem.genmodel b/subprojects/language-model/src/main/resources/model/problem.genmodel
index da70f922..9ff4989b 100644
--- a/subprojects/language-model/src/main/resources/model/problem.genmodel
+++ b/subprojects/language-model/src/main/resources/model/problem.genmodel
@@ -28,6 +28,7 @@
       <genEnumLiterals ecoreEnumLiteral="problem.ecore#//ComparisonOp/GREATER"/>
       <genEnumLiterals ecoreEnumLiteral="problem.ecore#//ComparisonOp/GREATER_EQ"/>
       <genEnumLiterals ecoreEnumLiteral="problem.ecore#//ComparisonOp/EQ"/>
+      <genEnumLiterals ecoreEnumLiteral="problem.ecore#//ComparisonOp/NOT_EQ"/>
     </genEnums>
     <genEnums typeSafeEnumCompatible="false" ecoreEnum="problem.ecore#//ReferenceKind">
       <genEnumLiterals ecoreEnumLiteral="problem.ecore#//ReferenceKind/DEFAULT"/>
diff --git a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
index 830d4a2c..0378983c 100644
--- a/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
+++ b/subprojects/language-semantics/src/main/java/tools/refinery/language/semantics/model/ModelInitializer.java
@@ -1,9 +1,96 @@
 package tools.refinery.language.semantics.model;
 
-import tools.refinery.language.utils.CollectedSymbols;
+import com.google.inject.Inject;
+import org.eclipse.collections.api.factory.primitive.ObjectIntMaps;
+import org.eclipse.collections.api.map.primitive.MutableObjectIntMap;
+import tools.refinery.language.model.problem.*;
+import tools.refinery.language.semantics.model.internal.DecisionTree;
+import tools.refinery.language.utils.ProblemDesugarer;
+import tools.refinery.language.utils.RelationInfo;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.model.representation.TruthValue;
+import tools.refinery.store.tuple.Tuple;
+
+import java.util.HashMap;
+import java.util.Map;
 
 public class ModelInitializer {
-        public void createModel(CollectedSymbols symbols) {
+        @Inject
+        private ProblemDesugarer desugarer;
+
+        private final MutableObjectIntMap<Node> nodeTrace = ObjectIntMaps.mutable.empty();
+
+        private final Map<tools.refinery.language.model.problem.Relation, Relation<TruthValue>> relationTrace =
+                        new HashMap<>();
+
+        private int nodeCount = 0;
+
+        public void createModel(Problem problem) {
+                var builtinSymbols = desugarer.getBuiltinSymbols(problem).orElseThrow(() -> new IllegalArgumentException(
+                                "Problem has no builtin library"));
+                var collectedSymbols = desugarer.collectSymbols(problem);
+                for (var node : collectedSymbols.nodes().keySet()) {
+                        nodeTrace.put(node, nodeCount);
+                        nodeCount += 1;
+                }
+                for (var pair : collectedSymbols.relations().entrySet()) {
+                        var relation = pair.getKey();
+                        var relationInfo = pair.getValue();
+                        var isEqualsRelation = relation == builtinSymbols.equals();
+                        var decisionTree = mergeAssertions(relationInfo, isEqualsRelation);
+                        var defaultValue = isEqualsRelation ? TruthValue.FALSE : TruthValue.UNKNOWN;
+                        relationTrace.put(relation, new Relation<>(relationInfo.name(), relationInfo.arity(), defaultValue));
+                }
+        }
+
+        private DecisionTree mergeAssertions(RelationInfo relationInfo, boolean isEqualsRelation) {
+                var arity = relationInfo.arity();
+                var defaultAssertions = new DecisionTree(arity, isEqualsRelation ? null : TruthValue.UNKNOWN);
+                var assertions = new DecisionTree(arity);
+                for (var assertion : relationInfo.assertions()) {
+                        var tuple = getTuple(assertion);
+                        var value = getTruthValue(assertion.getValue());
+                        if (assertion.isDefault()) {
+                                defaultAssertions.mergeValue(tuple, value);
+                        } else {
+                                assertions.mergeValue(tuple, value);
+                        }
+                }
+                defaultAssertions.overwriteValues(assertions);
+                if (isEqualsRelation) {
+                        for (int i = 0; i < nodeCount; i++) {
+                                defaultAssertions.setIfMissing(Tuple.of(i, i), TruthValue.TRUE);
+                        }
+                        defaultAssertions.setAllMissing(TruthValue.FALSE);
+                }
+                return defaultAssertions;
+        }
+
+        private Tuple getTuple(Assertion assertion) {
+                var arguments = assertion.getArguments();
+                int arity = arguments.size();
+                var nodes = new int[arity];
+                for (int i = 0; i < arity; i++) {
+                        var argument = arguments.get(i);
+                        if (argument instanceof NodeAssertionArgument nodeArgument) {
+                                nodes[i] = nodeTrace.getOrThrow(nodeArgument.getNode());
+                        } else if (argument instanceof ConstantAssertionArgument constantArgument) {
+                                nodes[i] = nodeTrace.getOrThrow(constantArgument.getNode());
+                        } else if (argument instanceof WildcardAssertionArgument) {
+                                nodes[i] = -1;
+                        } else {
+                                throw new IllegalArgumentException("Unknown assertion argument: " + argument);
+                        }
+                }
+                return Tuple.of(nodes);
+        }
 
+        private static TruthValue getTruthValue(LogicValue value) {
+                return switch (value) {
+                        case TRUE -> TruthValue.TRUE;
+                        case FALSE -> TruthValue.FALSE;
+                        case UNKNOWN -> TruthValue.UNKNOWN;
+                        case ERROR -> TruthValue.ERROR;
+                };
         }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
index f514e96c..2a8429a3 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
+++ b/subprojects/language/src/main/java/tools/refinery/language/Problem.xtext
@@ -72,7 +72,7 @@ NegativeLiteral:
         modality=Modality? "!" atom=Atom;
 
 enum ComparisonOp:
-        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==";
+        LESS="<" | LESS_EQ="<=" | GREATER=">" | GREATER_EQ=">=" | EQ="==" | NOT_EQ="!=";
 
 CountLiteral:
         modality=Modality? "count" atom=Atom op=ComparisonOp threshold=INT;
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/RelationInfo.java b/subprojects/language/src/main/java/tools/refinery/language/utils/RelationInfo.java
index ae56e3a5..2253d257 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/RelationInfo.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/RelationInfo.java
@@ -1,27 +1,24 @@
 package tools.refinery.language.utils;
 
+import tools.refinery.language.model.problem.*;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 
-import tools.refinery.language.model.problem.Assertion;
-import tools.refinery.language.model.problem.Conjunction;
-import tools.refinery.language.model.problem.Multiplicity;
-import tools.refinery.language.model.problem.Parameter;
-import tools.refinery.language.model.problem.PredicateKind;
-import tools.refinery.language.model.problem.Relation;
-import tools.refinery.language.model.problem.TypeScope;
-
-public record RelationInfo(String name, PredicateKind kind, List<Parameter> parameters, Multiplicity multiplicity,
-                Relation opposite, Collection<Conjunction> bodies, Collection<Assertion> defaultAssertions,
-                Collection<Assertion> assertions, Collection<TypeScope> typeScopes) {
-        public RelationInfo(String name, PredicateKind kind, List<Parameter> parameters, Multiplicity multiplicity,
-                        Relation opposite, Collection<Conjunction> bodies) {
-                this(name, kind, parameters, multiplicity, opposite, bodies, new ArrayList<>(), new ArrayList<>(),
-                                new ArrayList<>());
+public record RelationInfo(String name, ContainmentRole containmentRole, List<Parameter> parameters,
+                                                   Multiplicity multiplicity, Relation opposite, Collection<Conjunction> bodies,
+                                                   Collection<Assertion> assertions, Collection<TypeScope> typeScopes) {
+        public RelationInfo(String name, ContainmentRole containmentRole, List<Parameter> parameters,
+                                                Multiplicity multiplicity, Relation opposite, Collection<Conjunction> bodies) {
+                this(name, containmentRole, parameters, multiplicity, opposite, bodies, new ArrayList<>(), new ArrayList<>());
         }
 
         public boolean hasDefinition() {
                 return bodies != null && !bodies.isEmpty();
         }
+
+        public int arity() {
+                return parameters.size();
+        }
 }
diff --git a/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java b/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
index a386db7f..210e96ab 100644
--- a/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
+++ b/subprojects/language/src/main/java/tools/refinery/language/utils/SymbolCollector.java
@@ -19,10 +19,12 @@ class SymbolCollector {
         private IQualifiedNameConverter qualifiedNameConverter;
 
         @Inject
-        ProblemDesugarer desugarer;
+        private ProblemDesugarer desugarer;
 
         private BuiltinSymbols builtinSymbols;
+
         private final Map<Node, NodeInfo> nodes = new LinkedHashMap<>();
+
         private final Map<Relation, RelationInfo> relations = new LinkedHashMap<>();
 
         public CollectedSymbols collectSymbols(Problem problem) {
@@ -54,9 +56,10 @@ class SymbolCollector {
         }
 
         private void collectPredicate(PredicateDefinition predicateDefinition) {
+                var predicateKind = predicateDefinition.getKind();
                 var info = new RelationInfo(getQualifiedNameString(predicateDefinition),
-                                predicateDefinition.getKind(),
-                                predicateDefinition.getParameters(), null, null, predicateDefinition.getBodies());
+                                ContainmentRole.fromPredicateKind(predicateKind), predicateDefinition.getParameters(), null, null,
+                                predicateDefinition.getBodies());
                 relations.put(predicateDefinition, info);
         }
 
@@ -65,10 +68,10 @@ class SymbolCollector {
                 // contained, including data types.
                 var contained =
                                 classDeclaration != builtinSymbols.node() && classDeclaration != builtinSymbols.domain();
-                var classKind = contained ? PredicateKind.CONTAINED : PredicateKind.DEFAULT;
+                var containmentRole = contained ? ContainmentRole.CONTAINED : ContainmentRole.NONE;
                 var instanceParameter = ProblemFactory.eINSTANCE.createParameter();
                 instanceParameter.setName("instance");
-                var classInfo = new RelationInfo(getQualifiedNameString(classDeclaration), classKind,
+                var classInfo = new RelationInfo(getQualifiedNameString(classDeclaration), containmentRole,
                                 List.of(instanceParameter), null, null, List.of());
                 relations.put(classDeclaration, classInfo);
                 collectReferences(classDeclaration);
@@ -76,9 +79,9 @@ class SymbolCollector {
 
         private void collectReferences(ClassDeclaration classDeclaration) {
                 for (var referenceDeclaration : classDeclaration.getReferenceDeclarations()) {
-                        var referenceKind = desugarer.isContainmentReference(referenceDeclaration) ?
-                                        PredicateKind.CONTAINMENT :
-                                        PredicateKind.DEFAULT;
+                        var referenceRole = desugarer.isContainmentReference(referenceDeclaration) ?
+                                        ContainmentRole.CONTAINMENT :
+                                        ContainmentRole.NONE;
                         var sourceParameter = ProblemFactory.eINSTANCE.createParameter();
                         sourceParameter.setName("source");
                         sourceParameter.setParameterType(classDeclaration);
@@ -91,7 +94,7 @@ class SymbolCollector {
                                 multiplicity = exactMultiplicity;
                         }
                         targetParameter.setParameterType(referenceDeclaration.getReferenceType());
-                        var referenceInfo = new RelationInfo(getQualifiedNameString(referenceDeclaration), referenceKind,
+                        var referenceInfo = new RelationInfo(getQualifiedNameString(referenceDeclaration), referenceRole,
                                         List.of(sourceParameter, targetParameter), multiplicity, referenceDeclaration.getOpposite(),
                                         List.of());
                         this.relations.put(referenceDeclaration, referenceInfo);
@@ -101,7 +104,7 @@ class SymbolCollector {
         private void collectEnum(EnumDeclaration enumDeclaration) {
                 var instanceParameter = ProblemFactory.eINSTANCE.createParameter();
                 instanceParameter.setName("instance");
-                var info = new RelationInfo(getQualifiedNameString(enumDeclaration), PredicateKind.DEFAULT,
+                var info = new RelationInfo(getQualifiedNameString(enumDeclaration), ContainmentRole.NONE,
                                 List.of(instanceParameter), null, null, List.of());
                 this.relations.put(enumDeclaration, info);
         }
@@ -172,6 +175,8 @@ class SymbolCollector {
                                 collectAssertion(assertion);
                         } else if (statement instanceof NodeValueAssertion nodeValueAssertion) {
                                 collectNodeValueAssertion(nodeValueAssertion);
+                        } else if (statement instanceof PredicateDefinition predicateDefinition) {
+                                collectPredicateAssertion(predicateDefinition);
                         } else if (statement instanceof ClassDeclaration classDeclaration) {
                                 collectClassAssertion(classDeclaration);
                         } else if (statement instanceof EnumDeclaration enumDeclaration) {
@@ -190,11 +195,7 @@ class SymbolCollector {
                         // Problem during editing. The errors can still be detected by the Problem validator.
                         return;
                 }
-                if (assertion.isDefault()) {
-                        relationInfo.defaultAssertions().add(assertion);
-                } else {
-                        relationInfo.assertions().add(assertion);
-                }
+                relationInfo.assertions().add(assertion);
                 for (var argument : assertion.getArguments()) {
                         if (argument instanceof ConstantAssertionArgument constantAssertionArgument) {
                                 var constantNode = constantAssertionArgument.getNode();
@@ -239,6 +240,14 @@ class SymbolCollector {
                 addAssertion(dataType, LogicValue.TRUE, node);
         }
 
+        private void collectPredicateAssertion(PredicateDefinition predicateDefinition) {
+                if (predicateDefinition.getKind() != PredicateKind.ERROR) {
+                        return;
+                }
+                int arity = predicateDefinition.getParameters().size();
+                addAssertion(predicateDefinition, LogicValue.FALSE, new Node[arity]);
+        }
+
         private void collectClassAssertion(ClassDeclaration classDeclaration) {
                 var node = classDeclaration.getNewNode();
                 if (node == null) {
@@ -259,8 +268,14 @@ class SymbolCollector {
                 var assertion = ProblemFactory.eINSTANCE.createAssertion();
                 assertion.setRelation(relation);
                 for (var node : nodes) {
-                        var argument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
-                        argument.setNode(node);
+                        AssertionArgument argument;
+                        if (node == null) {
+                                argument = ProblemFactory.eINSTANCE.createWildcardAssertionArgument();
+                        } else {
+                                var nodeArgument = ProblemFactory.eINSTANCE.createNodeAssertionArgument();
+                                nodeArgument.setNode(node);
+                                argument = nodeArgument;
+                        }
                         assertion.getArguments().add(argument);
                 }
                 assertion.setValue(logicValue);
diff --git a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java b/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java
index e2e3218c..a05f3335 100644
--- a/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java
+++ b/subprojects/language/src/test/java/tools/refinery/language/tests/utils/SymbolCollectorTest.java
@@ -12,6 +12,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 import tools.refinery.language.model.problem.*;
 import tools.refinery.language.model.tests.utils.ProblemParseHelper;
 import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.utils.ContainmentRole;
 import tools.refinery.language.utils.ProblemDesugarer;
 
 import java.util.stream.Stream;
@@ -61,7 +62,7 @@ class SymbolCollectorTest {
                 assertThat(collectedSymbols.relations(), hasKey(classDeclaration));
                 var classInfo = collectedSymbols.relations().get(classDeclaration);
                 assertThat(classInfo.parameters(), hasSize(1));
-                assertThat(classInfo.kind(), is(PredicateKind.CONTAINED));
+                assertThat(classInfo.containmentRole(), is(ContainmentRole.CONTAINED));
                 assertThat(classInfo.hasDefinition(), is(false));
                 var newNode = classDeclaration.getNewNode();
                 assertThat(collectedSymbols.nodes(), hasKey(newNode));
@@ -96,11 +97,11 @@ class SymbolCollectorTest {
                 var barInfo = collectedSymbols.relations().get(barReference);
                 var quuxReference = fooClass.reference("quux");
                 var quuxInfo = collectedSymbols.relations().get(quuxReference);
-                assertThat(barInfo.kind(), is(PredicateKind.DEFAULT));
+                assertThat(barInfo.containmentRole(), is(ContainmentRole.NONE));
                 assertThat(barInfo.opposite(), is(quuxReference));
                 assertThat(barInfo.multiplicity(), is(instanceOf(UnboundedMultiplicity.class)));
                 assertThat(barInfo.hasDefinition(), is(false));
-                assertThat(quuxInfo.kind(), is(PredicateKind.DEFAULT));
+                assertThat(quuxInfo.containmentRole(), is(ContainmentRole.NONE));
                 assertThat(quuxInfo.opposite(), is(barReference));
                 assertThat(quuxInfo.multiplicity(), is(instanceOf(ExactMultiplicity.class)));
                 assertThat(quuxInfo.multiplicity(), hasProperty("exactValue", is(1)));
@@ -115,8 +116,8 @@ class SymbolCollectorTest {
                                 }
                                 """);
                 var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").reference("bar")).kind(),
-                                is(PredicateKind.CONTAINMENT));
+                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").reference("bar")).containmentRole(),
+                                is(ContainmentRole.CONTAINMENT));
         }
 
         @Test
@@ -127,8 +128,8 @@ class SymbolCollectorTest {
                                 }
                                 """);
                 var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").reference("bar")).kind(),
-                                is(PredicateKind.CONTAINMENT));
+                assertThat(collectedSymbols.relations().get(problem.findClass("Foo").reference("bar")).containmentRole(),
+                                is(ContainmentRole.CONTAINMENT));
         }
 
         @Test
@@ -141,27 +142,27 @@ class SymbolCollectorTest {
                 var collectedSymbols = desugarer.collectSymbols(problem.get());
                 var enumDeclaration = problem.findEnum("Foo");
                 var enumInfo = collectedSymbols.relations().get(enumDeclaration.get());
-                assertThat(enumInfo.kind(), is(PredicateKind.DEFAULT));
+                assertThat(enumInfo.containmentRole(), is(ContainmentRole.NONE));
                 assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("bar"), LogicValue.TRUE));
                 assertThat(enumInfo.assertions(), assertsNode(enumDeclaration.literal("quux"), LogicValue.TRUE));
         }
 
         @ParameterizedTest
         @MethodSource
-        void predicateTest(String keyword, PredicateKind kind) {
+        void predicateTest(String keyword, ContainmentRole containmentRole) {
                 var problem = parseHelper.parse(keyword + " foo(node x) <-> domain(x); data(x).");
                 var collectedSymbols = desugarer.collectSymbols(problem.get());
                 var predicateInfo = collectedSymbols.relations().get(problem.pred("foo").get());
-                assertThat(predicateInfo.kind(), is(kind));
+                assertThat(predicateInfo.containmentRole(), is(containmentRole));
                 assertThat(predicateInfo.parameters(), hasSize(1));
                 assertThat(predicateInfo.bodies(), hasSize(2));
                 assertThat(predicateInfo.hasDefinition(), is(true));
         }
 
         static Stream<Arguments> predicateTest() {
-                return Stream.of(Arguments.of("pred", PredicateKind.DEFAULT), Arguments.of("error", PredicateKind.ERROR),
-                                Arguments.of("contained", PredicateKind.CONTAINED), Arguments.of("containment",
-                                                PredicateKind.CONTAINMENT));
+                return Stream.of(Arguments.of("pred", ContainmentRole.NONE), Arguments.of("error", ContainmentRole.NONE),
+                                Arguments.of("contained", ContainmentRole.CONTAINED), Arguments.of("containment",
+                                                ContainmentRole.CONTAINMENT));
         }
 
         @ParameterizedTest
@@ -184,7 +185,7 @@ class SymbolCollectorTest {
                                 default foo(a): %s.
                                 """.formatted(keyword));
                 var collectedSymbols = desugarer.collectSymbols(problem.get());
-                assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).defaultAssertions(),
+                assertThat(collectedSymbols.relations().get(problem.pred("foo").get()).assertions(),
                                 assertsNode(problem.node("a"), value));
         }
 
@@ -254,6 +255,10 @@ class SymbolCollectorTest {
                                 LogicValue.UNKNOWN));
         }
 
+        static Stream<Arguments> valueTypes() {
+                return Stream.of(Arguments.of("3", "int"), Arguments.of("3.14", "real"), Arguments.of("\"foo\"", "string"));
+        }
+
         @Test
         void invalidProblemTest() {
                 var problem = parseHelper.parse("""
@@ -265,8 +270,18 @@ class SymbolCollectorTest {
                 assertDoesNotThrow(() -> desugarer.collectSymbols(problem));
         }
 
-        static Stream<Arguments> valueTypes() {
-                return Stream.of(Arguments.of("3", "int"), Arguments.of("3.14", "real"), Arguments.of("\"foo\"", "string"));
+        @Test
+        void errorAssertionTest() {
+                var problem = parseHelper.parse("""
+                                error foo(node a, node b) <-> equals(a, b).
+                                """);
+                var collectedSymbols = desugarer.collectSymbols(problem.get());
+                var fooInfo = collectedSymbols.relations().get(problem.pred("foo").get());
+                assertThat(fooInfo.assertions(), hasSize(1));
+                var assertion = fooInfo.assertions().stream().findFirst().orElseThrow();
+                assertThat(assertion.getValue(), is(LogicValue.FALSE));
+                assertThat(assertion.getArguments(), hasSize(2));
+                assertThat(assertion.getArguments(), everyItem(instanceOf(WildcardAssertionArgument.class)));
         }
 
         private static Matcher<Iterable<? super Assertion>> assertsNode(Node node, LogicValue value) {
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
index 702eb659..59fb1171 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/ViatraQueryableModelStore.java
@@ -4,12 +4,10 @@ import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification;
 import tools.refinery.store.model.ModelDiffCursor;
 import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.model.ModelStoreImpl;
+import tools.refinery.store.model.RelationLike;
 import tools.refinery.store.model.representation.DataRepresentation;
 import tools.refinery.store.query.*;
-import tools.refinery.store.query.atom.DNFAtom;
-import tools.refinery.store.query.atom.DNFCallAtom;
-import tools.refinery.store.query.atom.EquivalenceAtom;
-import tools.refinery.store.query.atom.RelationViewAtom;
+import tools.refinery.store.query.atom.*;
 import tools.refinery.store.query.viatra.internal.RawPatternMatcher;
 import tools.refinery.store.query.viatra.internal.ViatraQueryableModel;
 import tools.refinery.store.query.viatra.internal.pquery.DNF2PQuery;
@@ -57,9 +55,11 @@ public class ViatraQueryableModelStore implements QueryableModelStore {
                                 for (DNFAtom atom : clause.constraints()) {
                                         if (atom instanceof RelationViewAtom relationViewAtom) {
                                                 validateRelationAtom(relationViews, dnfPredicate, relationViewAtom);
-                                        } else if (atom instanceof DNFCallAtom queryCallAtom) {
+                                        } else if (atom instanceof CallAtom<?> queryCallAtom) {
                                                 validatePredicateAtom(predicates, dnfPredicate, queryCallAtom);
-                                        } else if (!(atom instanceof EquivalenceAtom)) {
+                                        } else if (atom instanceof CountNotEqualsAtom<?> countNotEqualsAtom) {
+                                                validateCountNotEqualsAtom(predicates, dnfPredicate, countNotEqualsAtom);
+                                        } else if (!(atom instanceof EquivalenceAtom || atom instanceof ConstantAtom)) {
                                                 throw new IllegalArgumentException("Unknown constraint: " + atom.toString());
                                         }
                                 }
@@ -77,16 +77,24 @@ public class ViatraQueryableModelStore implements QueryableModelStore {
                 }
         }
 
-        private void validatePredicateAtom(Set<DNF> predicates, DNF dnfPredicate,
-                                                                           DNFCallAtom queryCallAtom) {
-                if (!predicates.contains(queryCallAtom.getTarget())) {
+        private void validatePredicateReference(Set<DNF> predicates, DNF dnfPredicate, RelationLike target) {
+                if (!(target instanceof DNF dnfTarget) || !predicates.contains(dnfTarget)) {
                         throw new IllegalArgumentException(
                                         "%s %s contains reference to a predicate %s that is not in the model.".formatted(
-                                                        DNF.class.getSimpleName(), dnfPredicate.getUniqueName(),
-                                                        queryCallAtom.getTarget().getName()));
+                                                        DNF.class.getSimpleName(), dnfPredicate.getUniqueName(), target.getName()));
                 }
         }
 
+        private void validatePredicateAtom(Set<DNF> predicates, DNF dnfPredicate, CallAtom<?> queryCallAtom) {
+                validatePredicateReference(predicates, dnfPredicate, queryCallAtom.getTarget());
+        }
+
+        private void validateCountNotEqualsAtom(Set<DNF> predicates, DNF dnfPredicate,
+                                                                                        CountNotEqualsAtom<?> countNotEqualsAtom) {
+                validatePredicateReference(predicates, dnfPredicate, countNotEqualsAtom.mayTarget());
+                validatePredicateReference(predicates, dnfPredicate, countNotEqualsAtom.mustTarget());
+        }
+
         private Map<DNF, GenericQuerySpecification<RawPatternMatcher>> initPredicates(Set<DNF> predicates) {
                 Map<DNF, GenericQuerySpecification<RawPatternMatcher>> result = new HashMap<>();
                 var dnf2PQuery = new DNF2PQuery();
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountExpressionEvaluator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountExpressionEvaluator.java
new file mode 100644
index 00000000..6fc96c05
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountExpressionEvaluator.java
@@ -0,0 +1,38 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.store.query.atom.ComparisonOperator;
+import tools.refinery.store.query.atom.CountCallKind;
+
+import java.util.List;
+
+public record CountExpressionEvaluator(String variableName, ComparisonOperator operator,
+                                                                           int threshold) implements IExpressionEvaluator {
+        public CountExpressionEvaluator(String variableName, CountCallKind callKind) {
+                this(variableName, callKind.operator(), callKind.threshold());
+        }
+
+        @Override
+        public String getShortDescription() {
+                return "%s %s %d".formatted(variableName, operator, threshold);
+        }
+
+        @Override
+        public Iterable<String> getInputParameterNames() {
+                return List.of(variableName);
+        }
+
+        @Override
+        public Object evaluateExpression(IValueProvider provider) {
+                int value = (Integer) provider.getValue(variableName);
+                return switch (operator) {
+                        case EQUALS -> value == threshold;
+                        case NOT_EQUALS -> value != threshold;
+                        case LESS -> value < threshold;
+                        case LESS_EQUALS -> value <= threshold;
+                        case GREATER -> value > threshold;
+                        case GREATER_EQUALS -> value >= threshold;
+                };
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountNotEqualsExpressionEvaluator.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountNotEqualsExpressionEvaluator.java
new file mode 100644
index 00000000..6f333a06
--- /dev/null
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/CountNotEqualsExpressionEvaluator.java
@@ -0,0 +1,30 @@
+package tools.refinery.store.query.viatra.internal.pquery;
+
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+
+import java.util.List;
+
+public record CountNotEqualsExpressionEvaluator(boolean must, int threshold, String mayVariableName,
+                                                                                                String mustVariableName) implements IExpressionEvaluator {
+        @Override
+        public String getShortDescription() {
+                return "%d %s not in [%s; %s]".formatted(threshold, must ? "must" : "may", mustVariableName, mayVariableName);
+        }
+
+        @Override
+        public Iterable<String> getInputParameterNames() {
+                return List.of(mayVariableName, mustVariableName);
+        }
+
+        @Override
+        public Object evaluateExpression(IValueProvider provider) throws Exception {
+                int mayCount = (Integer) provider.getValue(mayVariableName);
+                int mustCount = (Integer) provider.getValue(mustVariableName);
+                if (must) {
+                        return mayCount < threshold || mustCount > threshold;
+                } else {
+                        return mayCount > threshold || mustCount < threshold;
+                }
+        }
+}
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
index e3c586a0..61b984ae 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/DNF2PQuery.java
@@ -2,20 +2,16 @@ package tools.refinery.store.query.viatra.internal.pquery;
 
 import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
 import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.*;
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue;
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
 import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.query.*;
-import tools.refinery.store.query.atom.DNFAtom;
-import tools.refinery.store.query.atom.EquivalenceAtom;
-import tools.refinery.store.query.atom.DNFCallAtom;
-import tools.refinery.store.query.atom.RelationViewAtom;
+import tools.refinery.store.query.atom.*;
 import tools.refinery.store.query.view.RelationView;
 
 import java.util.*;
@@ -85,8 +81,12 @@ public class DNF2PQuery {
                         translateEquivalenceAtom(equivalenceAtom, body);
                 } else if (constraint instanceof RelationViewAtom relationViewAtom) {
                         translateRelationViewAtom(relationViewAtom, body);
-                } else if (constraint instanceof DNFCallAtom dnfCallAtom) {
-                        translateDNFCallAtom(dnfCallAtom, body);
+                } else if (constraint instanceof CallAtom<?> callAtom) {
+                        translateCallAtom(callAtom, body);
+                } else if (constraint instanceof ConstantAtom constantAtom) {
+                        translateConstantAtom(constantAtom, body);
+                } else if (constraint instanceof CountNotEqualsAtom<?> countNotEqualsAtom) {
+                        translateCountNotEqualsAtom(countNotEqualsAtom, body);
                 } else {
                         throw new IllegalArgumentException("Unknown constraint: " + constraint.toString());
                 }
@@ -103,32 +103,66 @@ public class DNF2PQuery {
         }
 
         private void translateRelationViewAtom(RelationViewAtom relationViewAtom, PBody body) {
-                int arity = relationViewAtom.getSubstitution().size();
+                new TypeConstraint(body, translateSubstitution(relationViewAtom.getSubstitution(), body),
+                                wrapView(relationViewAtom.getTarget()));
+        }
+
+        private static Tuple translateSubstitution(List<Variable> substitution, PBody body) {
+                int arity = substitution.size();
                 Object[] variables = new Object[arity];
                 for (int i = 0; i < arity; i++) {
-                        var variable = relationViewAtom.getSubstitution().get(i);
+                        var variable = substitution.get(i);
                         variables[i] = body.getOrCreateVariableByName(variable.getUniqueName());
                 }
-                new TypeConstraint(body, Tuples.flatTupleOf(variables), wrapView(relationViewAtom.getTarget()));
+                return Tuples.flatTupleOf(variables);
         }
 
         private RelationViewWrapper wrapView(RelationView<?> relationView) {
                 return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
         }
 
-        private void translateDNFCallAtom(DNFCallAtom queryCallAtom, PBody body) {
-                int arity = queryCallAtom.getSubstitution().size();
-                Object[] variables = new Object[arity];
-                for (int i = 0; i < arity; i++) {
-                        var variable = queryCallAtom.getSubstitution().get(i);
-                        variables[i] = body.getOrCreateVariableByName(variable.getUniqueName());
+        private void translateCallAtom(CallAtom<?> callAtom, PBody body) {
+                if (!(callAtom.getTarget() instanceof DNF target)) {
+                        throw new IllegalArgumentException("Only calls to DNF are supported");
+                }
+                var variablesTuple = translateSubstitution(callAtom.getSubstitution(), body);
+                var translatedReferred = translate(target);
+                var callKind = callAtom.getKind();
+                if (callKind instanceof BasicCallKind basicCallKind) {
+                        switch (basicCallKind) {
+                        case POSITIVE -> new PositivePatternCall(body, variablesTuple, translatedReferred);
+                        case TRANSITIVE -> new BinaryTransitiveClosure(body, variablesTuple, translatedReferred);
+                        case NEGATIVE -> new NegativePatternCall(body, variablesTuple, translatedReferred);
+                        default -> throw new IllegalArgumentException("Unknown BasicCallKind: " + basicCallKind);
+                        }
+                } else if (callKind instanceof CountCallKind countCallKind) {
+                        var countVariableName = DNFUtils.generateUniqueName("count");
+                        var countPVariable = body.getOrCreateVariableByName(countVariableName);
+                        new PatternMatchCounter(body, variablesTuple, translatedReferred, countPVariable);
+                        new ExpressionEvaluation(body, new CountExpressionEvaluator(countVariableName, countCallKind), null);
+                } else {
+                        throw new IllegalArgumentException("Unknown CallKind: " + callKind);
                 }
-                var variablesTuple = Tuples.flatTupleOf(variables);
-                var translatedReferred = translate(queryCallAtom.getTarget());
-                switch (queryCallAtom.getKind()) {
-                case POSITIVE -> new PositivePatternCall(body, variablesTuple, translatedReferred);
-                case TRANSITIVE -> new BinaryTransitiveClosure(body, variablesTuple, translatedReferred);
-                case NEGATIVE -> new NegativePatternCall(body, variablesTuple, translatedReferred);
+        }
+
+        private void translateConstantAtom(ConstantAtom constantAtom, PBody body) {
+                var variable = body.getOrCreateVariableByName(constantAtom.variable().getUniqueName());
+                new ConstantValue(body, variable, constantAtom.nodeId());
+        }
+
+        private void translateCountNotEqualsAtom(CountNotEqualsAtom<?> countNotEqualsAtom, PBody body) {
+                if (!(countNotEqualsAtom.mayTarget() instanceof DNF mayTarget) ||
+                                !(countNotEqualsAtom.mustTarget() instanceof DNF mustTarget)) {
+                        throw new IllegalArgumentException("Only calls to DNF are supported");
                 }
+                var variablesTuple = translateSubstitution(countNotEqualsAtom.substitution(), body);
+                var mayCountName = DNFUtils.generateUniqueName("countMay");
+                var mayCountVariable = body.getOrCreateVariableByName(mayCountName);
+                new PatternMatchCounter(body, variablesTuple, translate(mayTarget), mayCountVariable);
+                var mustCountName = DNFUtils.generateUniqueName("countMust");
+                var mustCountVariable = body.getOrCreateVariableByName(mustCountName);
+                new PatternMatchCounter(body, variablesTuple, translate(mustTarget), mustCountVariable);
+                new ExpressionEvaluation(body, new CountNotEqualsExpressionEvaluator(countNotEqualsAtom.must(),
+                                countNotEqualsAtom.threshold(), mayCountName, mustCountName), null);
         }
 }
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
index 8984cb2c..224df362 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/tests/QueryTest.java
@@ -4,10 +4,7 @@ import org.junit.jupiter.api.Test;
 import tools.refinery.store.model.representation.Relation;
 import tools.refinery.store.model.representation.TruthValue;
 import tools.refinery.store.query.*;
-import tools.refinery.store.query.atom.CallKind;
-import tools.refinery.store.query.atom.EquivalenceAtom;
-import tools.refinery.store.query.atom.DNFCallAtom;
-import tools.refinery.store.query.atom.RelationViewAtom;
+import tools.refinery.store.query.atom.*;
 import tools.refinery.store.query.viatra.ViatraQueryableModelStore;
 import tools.refinery.store.query.view.FilteredRelationView;
 import tools.refinery.store.query.view.KeyOnlyRelationView;
@@ -61,7 +58,7 @@ class QueryTest {
                                 .parameters(p1, p2)
                                 .clause(
                                                 new RelationViewAtom(personView, p1),
-                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(personView, p2),
                                                 new RelationViewAtom(friendMustView, p1, p2)
                                 )
                                 .build();
@@ -308,7 +305,7 @@ class QueryTest {
                                 .clause(
                                                 new RelationViewAtom(personView, p3),
                                                 new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(friendPredicate, p3, p4)
+                                                new CallAtom<>(friendPredicate, p3, p4)
                                 )
                                 .build();
 
@@ -354,7 +351,7 @@ class QueryTest {
                                 .clause(
                                                 new RelationViewAtom(personView, p3),
                                                 new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(CallKind.NEGATIVE, friendPredicate, p3, p4)
+                                                new CallAtom<>(false, friendPredicate, p3, p4)
                                 )
                                 .build();
 
@@ -374,6 +371,48 @@ class QueryTest {
         }
 
         @Test
+        void negativeWithQuantificationTest() {
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+
+                DNF called = DNF.builder("Called")
+                                .parameters(p1, p2)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(personView, p2),
+                                                new RelationViewAtom(friendMustView, p1, p2)
+                                )
+                                .build();
+
+                DNF predicate = DNF.builder("Count")
+                                .parameters(p1)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new CallAtom<>(false, called, p1, p2)
+                                )
+                                .build();
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(called, predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(0, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(2, model.countResults(predicate));
+        }
+
+        @Test
         void transitivePatternCallTest() {
                 Relation<Boolean> person = new Relation<>("Person", 1, false);
                 Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
@@ -399,7 +438,7 @@ class QueryTest {
                                 .clause(
                                                 new RelationViewAtom(personView, p3),
                                                 new RelationViewAtom(personView, p4),
-                                                new DNFCallAtom(CallKind.TRANSITIVE, friendPredicate, p3, p4)
+                                                new CallAtom<>(BasicCallKind.TRANSITIVE, friendPredicate, p3, p4)
                                 )
                                 .build();
 
@@ -417,6 +456,48 @@ class QueryTest {
                 assertEquals(3, model.countResults(predicate));
         }
 
+        @Test
+        void countMatchTest() {
+                Relation<Boolean> person = new Relation<>("Person", 1, false);
+                Relation<TruthValue> friend = new Relation<>("friend", 2, TruthValue.FALSE);
+                RelationView<Boolean> personView = new KeyOnlyRelationView(person);
+                RelationView<TruthValue> friendMustView = new FilteredRelationView<>(friend, "must",
+                                TruthValue::must);
+
+                Variable p1 = new Variable("p1");
+                Variable p2 = new Variable("p2");
+
+                DNF called = DNF.builder("Called")
+                                .parameters(p1, p2)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(personView, p2),
+                                                new RelationViewAtom(friendMustView, p1, p2)
+                                )
+                                .build();
+
+                DNF predicate = DNF.builder("Count")
+                                .parameters(p1)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new CallAtom<>(new CountCallKind(ComparisonOperator.EQUALS, 2), called, p1, p2)
+                                )
+                                .build();
+
+                QueryableModelStore store = new ViatraQueryableModelStore(Set.of(person, friend),
+                                Set.of(personView, friendMustView), Set.of(called, predicate));
+                QueryableModel model = store.createModel();
+
+                model.put(person, Tuple.of(0), true);
+                model.put(person, Tuple.of(1), true);
+                model.put(person, Tuple.of(2), true);
+                model.put(friend, Tuple.of(0, 1), TruthValue.TRUE);
+                model.put(friend, Tuple.of(0, 2), TruthValue.TRUE);
+
+                model.flushChanges();
+                assertEquals(1, model.countResults(predicate));
+        }
+
         static void compareMatchSets(Stream<TupleLike> matchSet, Set<Tuple> expected) {
                 Set<Tuple> translatedMatchSet = new HashSet<>();
                 var iterator = matchSet.iterator();
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java
index f68734ab..9397dede 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/ImmutableNode.java
@@ -35,7 +35,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
 
         /**
          * Constructor that copies a mutable node to an immutable.
-         * 
+         *
          * @param node  A mutable node.
          * @param cache A cache of existing immutable nodes. It can be used to search
          *              and place reference immutable nodes. It can be null, if no cache
@@ -151,7 +151,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                         oldValue.setOldValue(value);
                                         return this;
                                 } else {
-                                        // update existing value
+                                        // update existing nodeId
                                         MutableNode<K, V> mutable = this.toMutable();
                                         return mutable.updateValue(value, oldValue, selectedHashFragment);
                                 }
@@ -161,7 +161,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                         oldValue.setOldValue(defaultValue);
                                         return this;
                                 } else {
-                                        // add new key + value
+                                        // add new key + nodeId
                                         MutableNode<K, V> mutable = this.toMutable();
                                         return mutable.putValue(key, value, oldValue, hashProvider, defaultValue, hash, depth);
                                 }
@@ -182,7 +182,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 return mutable.updateWithSubNode(selectedHashFragment, newsubNode, value.equals(defaultValue));
                         }
                 } else {
-                        // add new key + value
+                        // add new key + nodeId
                         MutableNode<K, V> mutable = this.toMutable();
                         return mutable.putValue(key, value, oldValue, hashProvider, defaultValue, hash, depth);
                 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
index 42333635..a4ca813c 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MapDiffCursor.java
@@ -10,13 +10,13 @@ import tools.refinery.store.map.VersionedMap;
 
 /**
  * A cursor representing the difference between two states of a map.
- * 
+ *
  * @author Oszkar Semerath
  *
  */
 public class MapDiffCursor<K, V> implements DiffCursor<K, V>, Cursor<K, V> {
         /**
-         * Default value representing missing elements.
+         * Default nodeId representing missing elements.
          */
         private V defaultValue;
         private MapCursor<K, V> cursor1;
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java
index 54853010..7c3cf7e8 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/MutableNode.java
@@ -31,7 +31,7 @@ public class MutableNode<K, V> extends Node<K, V> {
 
         /**
          * Constructs a {@link MutableNode} as a copy of an {@link ImmutableNode}
-         * 
+         *
          * @param node
          */
         protected MutableNode(ImmutableNode<K, V> node) {
@@ -107,18 +107,18 @@ public class MutableNode<K, V> extends Node<K, V> {
                                 }
                         }
                 } else {
-                        // If it does not have key, check for value
+                        // If it does not have key, check for nodeId
                         @SuppressWarnings("unchecked")
                         var nodeCandidate = (Node<K, V>) content[2 * selectedHashFragment + 1];
                         if (nodeCandidate != null) {
-                                // If it has value, it is a subnode -> upate that
+                                // If it has nodeId, it is a subnode -> upate that
                                 var newNode = nodeCandidate.putValue(key, value, oldValueBox, hashProvider, defaultValue,
                                                 newHash(hashProvider, key, hash, depth + 1), depth + 1);
                                 return updateWithSubNode(selectedHashFragment, newNode, value.equals(defaultValue));
                         } else {
-                                // If it does not have value, put it in the empty place
+                                // If it does not have nodeId, put it in the empty place
                                 if (value == defaultValue) {
-                                        // dont need to add new key-value pair
+                                        // dont need to add new key-nodeId pair
                                         oldValueBox.setOldValue(defaultValue);
                                         return this;
                                 } else {
@@ -138,8 +138,8 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         /**
-         * Updates an entry in a selected hash-fragment to a non-default value.
-         * 
+         * Updates an entry in a selected hash-fragment to a non-default nodeId.
+         *
          * @param value
          * @param selectedHashFragment
          * @return
@@ -153,7 +153,7 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         /**
-         * 
+         *
          * @param selectedHashFragment
          * @param newNode
          * @return
@@ -400,7 +400,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                                 V value = (V) this.content[2 * i + 1];
 
                                 if (value == defaultValue) {
-                                        throw new IllegalStateException("Node contains default value!");
+                                        throw new IllegalStateException("Node contains default nodeId!");
                                 }
                                 int hashCode = hashProvider.getHash(key, hashDepth(depth));
                                 int shiftDepth = shiftDepth(depth);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java b/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java
index 234a4ff3..2260cd5b 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/map/internal/Node.java
@@ -10,7 +10,7 @@ public abstract class Node<K,V>{
         protected static final int NUMBER_OF_FACTORS = Integer.SIZE / BRANCHING_FACTOR_BITS;
         protected static final int FACTOR_MASK = FACTOR-1;
         public static final int EFFECTIVE_BITS = BRANCHING_FACTOR_BITS * NUMBER_OF_FACTORS;
-        
+
         /**
          * Calculates the index for the continuous hash.
          * @param depth The depth of the node in the tree.
@@ -19,10 +19,10 @@ public abstract class Node<K,V>{
         protected static int hashDepth(int depth) {
                 return depth/NUMBER_OF_FACTORS;
         }
-        
+
         /**
          * Calculates the which segment of a single hash should be used.
-         * @param depth The depth of the node in the tree. 
+         * @param depth The depth of the node in the tree.
          * @return The segment of a hash code.
          */
         protected static int shiftDepth(int depth) {
@@ -38,7 +38,7 @@ public abstract class Node<K,V>{
                 if(shiftDepth<0 || Node.NUMBER_OF_FACTORS<shiftDepth) throw new IllegalArgumentException("Invalid shift depth! valid intervall=[0;5], input="+shiftDepth);
                 return (hash >>> shiftDepth*BRANCHING_FACTOR_BITS) & FACTOR_MASK;
         }
-        
+
         /**
          * Returns the hash code for a given depth. It may calculate new hash code, or reuse a hash code calculated for depth-1.
          * @param key The key.
@@ -55,12 +55,12 @@ public abstract class Node<K,V>{
                                 hashProvider.getHash(key, hashDepth) :
                                 hash;
         }
-        
-        
+
+
         public abstract V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue,  int hash, int depth);
         public abstract Node<K,V> putValue(K key, V value, OldValueBox<V> old, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth);
         public abstract long getSize();
-        
+
         abstract MutableNode<K, V> toMutable();
         public abstract ImmutableNode<K, V> toImmutable(
                         Map<Node<K, V>,ImmutableNode<K, V>> cache);
@@ -68,10 +68,10 @@ public abstract class Node<K,V>{
         /**
          * Moves a {@link MapCursor} to its next position.
          * @param cursor the cursor
-         * @return Whether there was a next value to move on.
+         * @return Whether there was a next nodeId to move on.
          */
         abstract boolean moveToNext(MapCursor<K,V> cursor);
-        
+
         ///////// FOR printing
         public abstract void prettyPrint(StringBuilder builder, int depth, int code);
         @Override
@@ -81,5 +81,5 @@ public abstract class Node<K,V>{
                 return stringBuilder.toString();
         }
         public void checkIntegrity(ContinousHashProvider<? super K> hashProvider, V defaultValue, int depth) {}
-        
+
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractCallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractCallAtom.java
deleted file mode 100644
index fb8d7432..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractCallAtom.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.model.RelationLike;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-import java.util.Set;
-
-public abstract class AbstractCallAtom<T extends RelationLike> extends AbstractSubstitutionAtom<T> {
-        private final CallKind kind;
-
-        protected AbstractCallAtom(CallKind kind, T target, List<Variable> substitution) {
-                super(target, substitution);
-                if (kind.isTransitive() && target.getArity() != 2) {
-                        throw new IllegalArgumentException("Transitive closures can only take binary relations");
-                }
-                this.kind = kind;
-        }
-
-        public CallKind getKind() {
-                return kind;
-        }
-
-        @Override
-        public void collectAllVariables(Set<Variable> variables) {
-                if (kind.isPositive()) {
-                        super.collectAllVariables(variables);
-                }
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/BasicCallKind.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/BasicCallKind.java
new file mode 100644
index 00000000..cf2ffc07
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/BasicCallKind.java
@@ -0,0 +1,26 @@
+package tools.refinery.store.query.atom;
+
+public enum BasicCallKind implements CallKind {
+        POSITIVE(true, false),
+        NEGATIVE(false, false),
+        TRANSITIVE(true, true);
+
+        private final boolean positive;
+
+        private final boolean transitive;
+
+        BasicCallKind(boolean positive, boolean transitive) {
+                this.positive = positive;
+                this.transitive = transitive;
+        }
+
+        @Override
+        public boolean isPositive() {
+                return positive;
+        }
+
+        @Override
+        public boolean isTransitive() {
+                return transitive;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
new file mode 100644
index 00000000..e52e33ac
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallAtom.java
@@ -0,0 +1,66 @@
+package tools.refinery.store.query.atom;
+
+import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.query.Variable;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+
+public final class CallAtom<T extends RelationLike> extends AbstractSubstitutionAtom<T> {
+        private final CallKind kind;
+
+        public CallAtom(CallKind kind, T target, List<Variable> substitution) {
+                super(target, substitution);
+                if (kind.isTransitive() && target.getArity() != 2) {
+                        throw new IllegalArgumentException("Transitive closures can only take binary relations");
+                }
+                this.kind = kind;
+        }
+
+        public CallAtom(CallKind kind, T target, Variable... substitution) {
+                this(kind, target, List.of(substitution));
+        }
+
+        public CallAtom(boolean positive, T target, List<Variable> substitution) {
+                this(CallKind.fromBoolean(positive), target, substitution);
+        }
+
+        public CallAtom(boolean positive, T target, Variable... substitution) {
+                this(positive, target, List.of(substitution));
+        }
+
+        public CallAtom(T target, List<Variable> substitution) {
+                this(true, target, substitution);
+        }
+
+        public CallAtom(T target, Variable... substitution) {
+                this(target, List.of(substitution));
+        }
+
+        public CallKind getKind() {
+                return kind;
+        }
+
+        @Override
+        public void collectAllVariables(Set<Variable> variables) {
+                if (kind.isPositive()) {
+                        super.collectAllVariables(variables);
+                }
+        }
+
+        @Override
+        public boolean equals(Object o) {
+                if (this == o) return true;
+                if (o == null || getClass() != o.getClass()) return false;
+                CallAtom<?> that = (CallAtom<?>) o;
+                return Objects.equals(kind, that.kind)
+                                && Objects.equals(getTarget(), that.getTarget())
+                                && Objects.equals(getSubstitution(), that.getSubstitution());
+        }
+
+        @Override
+        public int hashCode() {
+                return Objects.hash(kind, getTarget(), getSubstitution());
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallKind.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallKind.java
index c7cbc955..86066b8e 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallKind.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CallKind.java
@@ -1,24 +1,11 @@
 package tools.refinery.store.query.atom;
 
-public enum CallKind {
-        POSITIVE(true, false),
-        NEGATIVE(false, false),
-        TRANSITIVE(true, true);
+public sealed interface CallKind permits BasicCallKind, CountCallKind {
+        boolean isPositive();
 
-        private final boolean positive;
+        boolean isTransitive();
 
-        private final boolean transitive;
-
-        CallKind(boolean positive, boolean transitive) {
-                this.positive = positive;
-                this.transitive = transitive;
-        }
-
-        public boolean isPositive() {
-                return positive;
-        }
-
-        public boolean isTransitive() {
-                return transitive;
+        static CallKind fromBoolean(boolean positive) {
+                return positive ? BasicCallKind.POSITIVE : BasicCallKind.NEGATIVE;
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ComparisonOperator.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ComparisonOperator.java
new file mode 100644
index 00000000..ca113181
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ComparisonOperator.java
@@ -0,0 +1,22 @@
+package tools.refinery.store.query.atom;
+
+public enum ComparisonOperator {
+        EQUALS,
+        NOT_EQUALS,
+        LESS,
+        LESS_EQUALS,
+        GREATER,
+        GREATER_EQUALS;
+
+        @Override
+        public String toString() {
+                return switch (this) {
+                        case EQUALS -> "==";
+                        case NOT_EQUALS -> "!=";
+                        case LESS -> "<";
+                        case LESS_EQUALS -> "<=";
+                        case GREATER -> ">";
+                        case GREATER_EQUALS -> ">=";
+                };
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java
new file mode 100644
index 00000000..13dae7d0
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ConstantAtom.java
@@ -0,0 +1,12 @@
+package tools.refinery.store.query.atom;
+
+import tools.refinery.store.query.Variable;
+
+import java.util.Set;
+
+public record ConstantAtom(Variable variable, int nodeId) implements DNFAtom {
+        @Override
+        public void collectAllVariables(Set<Variable> variables) {
+                variables.add(variable);
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountCallKind.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountCallKind.java
new file mode 100644
index 00000000..2c85cb4f
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountCallKind.java
@@ -0,0 +1,13 @@
+package tools.refinery.store.query.atom;
+
+public record CountCallKind(ComparisonOperator operator, int threshold) implements CallKind {
+        @Override
+        public boolean isPositive() {
+                return false;
+        }
+
+        @Override
+        public boolean isTransitive() {
+                return false;
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountNotEqualsAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountNotEqualsAtom.java
new file mode 100644
index 00000000..312e5fb8
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/CountNotEqualsAtom.java
@@ -0,0 +1,31 @@
+package tools.refinery.store.query.atom;
+
+import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.query.Variable;
+
+import java.util.List;
+import java.util.Set;
+
+public record CountNotEqualsAtom<T extends RelationLike>(boolean must, int threshold, T mayTarget, T mustTarget,
+                                                                                                                 List<Variable> substitution) implements DNFAtom {
+        public CountNotEqualsAtom {
+                if (substitution.size() != mayTarget.getArity()) {
+                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(mayTarget.getName(),
+                                        mayTarget.getArity(), substitution.size()));
+                }
+                if (substitution.size() != mustTarget.getArity()) {
+                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(mustTarget.getName(),
+                                        mustTarget.getArity(), substitution.size()));
+                }
+        }
+
+        public CountNotEqualsAtom(boolean must, int threshold, T mayTarget, T mustTarget, Variable... substitution) {
+                this(must, threshold, mayTarget, mustTarget, List.of(substitution));
+        }
+
+        @Override
+        public void collectAllVariables(Set<Variable> variables) {
+                // No variables to collect, because all variables should either appear in other clauses,
+                // or are quantified by this clause.
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
deleted file mode 100644
index 9d2efa53..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/DNFCallAtom.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.query.DNF;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-import java.util.Objects;
-
-public final class DNFCallAtom extends AbstractCallAtom<DNF> {
-        public DNFCallAtom(CallKind kind, DNF target, List<Variable> substitution) {
-                super(kind, target, substitution);
-        }
-
-        public DNFCallAtom(CallKind kind, DNF target, Variable... substitution) {
-                super(kind, target, List.of(substitution));
-        }
-
-        public DNFCallAtom(DNF target, List<Variable> substitution) {
-                this(CallKind.POSITIVE, target, substitution);
-        }
-
-        public DNFCallAtom(DNF target, Variable... substitution) {
-                this(target, List.of(substitution));
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                DNFCallAtom dnfCallAtom = (DNFCallAtom) o;
-                return Objects.equals(getKind(), dnfCallAtom.getKind())
-                                && Objects.equals(getTarget(), dnfCallAtom.getTarget())
-                                && Objects.equals(getSubstitution(), dnfCallAtom.getSubstitution());
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(getKind(), getTarget(), getSubstitution());
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java
new file mode 100644
index 00000000..1e4f8f55
--- /dev/null
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelation.java
@@ -0,0 +1,17 @@
+package tools.refinery.store.query.atom;
+
+import tools.refinery.store.model.RelationLike;
+import tools.refinery.store.model.representation.Relation;
+import tools.refinery.store.model.representation.TruthValue;
+
+public record ModalRelation(Modality modality, Relation<TruthValue> relation) implements RelationLike {
+        @Override
+        public String getName() {
+                return "%s %s".formatted(modality, relation);
+        }
+
+        @Override
+        public int getArity() {
+                return relation.getArity();
+        }
+}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelationAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelationAtom.java
deleted file mode 100644
index 2480e82e..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/ModalRelationAtom.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.model.representation.Relation;
-import tools.refinery.store.model.representation.TruthValue;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-import java.util.Objects;
-
-public final class ModalRelationAtom extends AbstractCallAtom<Relation<TruthValue>> {
-        private final Modality modality;
-
-        public ModalRelationAtom(CallKind kind, Modality modality, Relation<TruthValue> target,
-                                                         List<Variable> substitution) {
-                super(kind, target, substitution);
-                this.modality = modality;
-        }
-
-        public ModalRelationAtom(Modality modality, Relation<TruthValue> target, List<Variable> substitution) {
-                this(CallKind.POSITIVE, modality, target, substitution);
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                ModalRelationAtom modalRelationAtom = (ModalRelationAtom) o;
-                return Objects.equals(getKind(), modalRelationAtom.getKind())
-                                && modality == modalRelationAtom.modality
-                                && Objects.equals(getTarget(), modalRelationAtom.getTarget())
-                                && Objects.equals(getSubstitution(), modalRelationAtom.getSubstitution());
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(getKind(), modality, getTarget(), getSubstitution());
-        }
-}
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
index 9344a9d3..bc107b76 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/Modality.java
@@ -1,7 +1,14 @@
 package tools.refinery.store.query.atom;
 
+import java.util.Locale;
+
 public enum Modality {
         MUST,
         MAY,
         CURRENT;
+
+        @Override
+        public String toString() {
+                return name().toLowerCase(Locale.ROOT);
+        }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationAtom.java
deleted file mode 100644
index 06098139..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationAtom.java
+++ /dev/null
@@ -1,32 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.model.representation.Relation;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-import java.util.Objects;
-
-public final class RelationAtom extends AbstractCallAtom<Relation<?>> {
-        public RelationAtom(CallKind kind, Relation<?> target, List<Variable> substitution) {
-                super(kind, target, substitution);
-        }
-
-        public RelationAtom(Relation<?> target, List<Variable> substitution) {
-                this(CallKind.POSITIVE, target, substitution);
-        }
-
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                RelationAtom relationAtom = (RelationAtom) o;
-                return Objects.equals(getKind(), relationAtom.getKind())
-                                && Objects.equals(getTarget(), relationAtom.getTarget())
-                                && Objects.equals(getSubstitution(), relationAtom.getSubstitution());
-        }
-
-        @Override
-        public int hashCode() {
-                return Objects.hash(getKind(), getTarget(), getSubstitution());
-        }
-}
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
index 991b4f51..a4ba7441 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
@@ -56,7 +56,7 @@ public class MapTestEnvironment<K, V> {
                 }
 
         }
-        
+
         public static <K, V> void compareTwoMaps(String title, VersionedMapImpl<K, V> map1,
                         VersionedMapImpl<K, V> map2) {
                 compareTwoMaps(title, map1, map2, null);
@@ -112,7 +112,7 @@ public class MapTestEnvironment<K, V> {
                         oldOracleValue = oracle.remove(key);
                 }
                 if(oldSutValue == sut.getDefaultValue() && oldOracleValue != null) {
-                        fail("After put, SUT old value was default, but oracle old walue was " + oldOracleValue);
+                        fail("After put, SUT old nodeId was default, but oracle old walue was " + oldOracleValue);
                 }
                 if(oldSutValue != sut.getDefaultValue()) {
                         assertEquals(oldOracleValue, oldSutValue);
@@ -127,8 +127,8 @@ public class MapTestEnvironment<K, V> {
                         fail(title + ":  " + e.getMessage());
                 }
 
-                // 1. Checking: if Reference contains <key,value> pair, then SUT contains
-                // <key,value> pair.
+                // 1. Checking: if Reference contains <key,nodeId> pair, then SUT contains
+                // <key,nodeId> pair.
                 // Tests get functions
                 for (Entry<K, V> entry : oracle.entrySet()) {
                         V sutValue = sut.get(entry.getKey());
@@ -140,8 +140,8 @@ public class MapTestEnvironment<K, V> {
                         }
                 }
 
-                // 2. Checking: if SUT contains <key,value> pair, then Reference contains
-                // <key,value> pair.
+                // 2. Checking: if SUT contains <key,nodeId> pair, then Reference contains
+                // <key,nodeId> pair.
                 // Tests iterators
                 int elementsInSutEntrySet = 0;
                 Cursor<K, V> cursor = sut.getAll();
@@ -160,7 +160,7 @@ public class MapTestEnvironment<K, V> {
                 }
 
                 // 3. Checking sizes
-                // Counting of non-default value pairs.
+                // Counting of non-default nodeId pairs.
                 int oracleSize = oracle.entrySet().size();
                 long sutSize = sut.getSize();
                 if (oracleSize != sutSize || oracleSize != elementsInSutEntrySet) {