feat: negative and transitive RelationViewAtom

Use PVisibility.EMBEDDED helper patterns to avoid superfluous production
nodes in the Rete net.

6 files changed, 210 insertions, 69 deletions

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 2b5618d2..eb815588 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
@@ -12,10 +12,12 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.Consta
 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.psystem.queries.PVisibility;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.query.DNF;
 import tools.refinery.store.query.DNFAnd;
+import tools.refinery.store.query.DNFUtils;
 import tools.refinery.store.query.Variable;
 import tools.refinery.store.query.atom.*;
 import tools.refinery.store.query.view.AnyRelationView;
@@ -124,8 +126,19 @@ public class DNF2PQuery {
         }
 
         private void translateRelationViewAtom(RelationViewAtom relationViewAtom, PBody body) {
-                new TypeConstraint(body, translateSubstitution(relationViewAtom.getSubstitution(), body),
-                                wrapView(relationViewAtom.getTarget()));
+                var substitution = translateSubstitution(relationViewAtom.getSubstitution(), body);
+                var polarity = relationViewAtom.getPolarity();
+                var relationView = relationViewAtom.getTarget();
+                if (polarity == CallPolarity.POSITIVE) {
+                        new TypeConstraint(body, substitution, wrapView(relationView));
+                } else {
+                        var embeddedPQuery = translateEmbeddedRelationViewPQuery(relationView);
+                        switch (polarity) {
+                        case TRANSITIVE -> new BinaryTransitiveClosure(body, substitution, embeddedPQuery);
+                        case NEGATIVE -> new NegativePatternCall(body, substitution, embeddedPQuery);
+                        default -> throw new IllegalArgumentException("Unknown polarity: " + polarity);
+                        }
+                }
         }
 
         private static Tuple translateSubstitution(List<Variable> substitution, PBody body) {
@@ -138,16 +151,36 @@ public class DNF2PQuery {
                 return Tuples.flatTupleOf(variables);
         }
 
+        private RawPQuery translateEmbeddedRelationViewPQuery(AnyRelationView relationView) {
+                var embeddedPQuery = new RawPQuery(DNFUtils.generateUniqueName(relationView.name()), PVisibility.EMBEDDED);
+                var body = new PBody(embeddedPQuery);
+                int arity = relationView.arity();
+                var parameters = new ArrayList<PParameter>(arity);
+                var arguments = new Object[arity];
+                var symbolicParameters = new ArrayList<ExportedParameter>(arity);
+                for (int i = 0; i < arity; i++) {
+                        var parameterName = "p" + i;
+                        var parameter = new PParameter(parameterName);
+                        parameters.add(parameter);
+                        var variable = body.getOrCreateVariableByName(parameterName);
+                        arguments[i] = variable;
+                        symbolicParameters.add(new ExportedParameter(body, variable, parameter));
+                }
+                embeddedPQuery.setParameters(parameters);
+                body.setSymbolicParameters(symbolicParameters);
+                var argumentTuple = Tuples.flatTupleOf(arguments);
+                new TypeConstraint(body, argumentTuple, wrapView(relationView));
+                embeddedPQuery.addBody(body);
+                return embeddedPQuery;
+        }
+
         private RelationViewWrapper wrapView(AnyRelationView relationView) {
                 return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
         }
 
-        private void translateCallAtom(CallAtom<?> callAtom, PBody body) {
-                if (!(callAtom.getTarget() instanceof DNF target)) {
-                        throw new IllegalArgumentException("Only calls to DNF are supported");
-                }
+        private void translateCallAtom(DNFCallAtom callAtom, PBody body) {
                 var variablesTuple = translateSubstitution(callAtom.getSubstitution(), body);
-                var translatedReferred = translate(target);
+                var translatedReferred = translate(callAtom.getTarget());
                 var polarity = callAtom.getPolarity();
                 switch (polarity) {
                 case POSITIVE -> new PositivePatternCall(body, variablesTuple, translatedReferred);
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
index 5d0b9e82..830495b2 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RawPQuery.java
@@ -18,11 +18,15 @@ public class RawPQuery extends BasePQuery {
         private List<PParameter> parameters;
         private final LinkedHashSet<PBody> bodies = new LinkedHashSet<>();
 
-        public RawPQuery(String name) {
-                super(PVisibility.PUBLIC);
+        public RawPQuery(String name, PVisibility visibility) {
+                super(visibility);
                 fullyQualifiedName = name;
         }
 
+        public RawPQuery(String name) {
+                this(name, PVisibility.PUBLIC);
+        }
+
         @Override
         public String getFullyQualifiedName() {
                 return fullyQualifiedName;
diff --git a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
index 72e8d7e5..ba0abca0 100644
--- a/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
+++ b/subprojects/store-query-viatra/src/test/java/tools/refinery/store/query/viatra/QueryTest.java
@@ -391,6 +391,48 @@ class QueryTest {
         }
 
         @Test
+        void negativeRelationViewTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = new Variable("p1");
+                var p2 = new Variable("p2");
+                var predicate = DNF.builder("NegativePatternCall")
+                                .parameters(p1, p2)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(personView, p2),
+                                                new RelationViewAtom(false, friendMustView, p1, p2)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 0), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertEquals(6, predicateResultSet.countResults());
+        }
+
+        @Test
         void negativePatternCallTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
@@ -444,6 +486,47 @@ class QueryTest {
         }
 
         @Test
+        void negativeRelationViewWithQuantificationTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = new Variable("p1");
+                var p2 = new Variable("p2");
+
+                var predicate = DNF.builder("Count")
+                                .parameters(p1)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(false, friendMustView, p1, p2)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(0, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertEquals(2, predicateResultSet.countResults());
+        }
+
+        @Test
         void negativeWithQuantificationTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
@@ -494,6 +577,47 @@ class QueryTest {
         }
 
         @Test
+        void transitiveRelationViewTest() {
+                var person = new Symbol<>("Person", 1, Boolean.class, false);
+                var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
+                var personView = new KeyOnlyRelationView<>(person);
+                var friendMustView = new FilteredRelationView<>(friend, "must", TruthValue::must);
+
+                var p1 = new Variable("p1");
+                var p2 = new Variable("p2");
+                var predicate = DNF.builder("TransitivePatternCall")
+                                .parameters(p1, p2)
+                                .clause(
+                                                new RelationViewAtom(personView, p1),
+                                                new RelationViewAtom(personView, p2),
+                                                new RelationViewAtom(CallPolarity.TRANSITIVE, friendMustView, p1, p2)
+                                )
+                                .build();
+
+                var store = ModelStore.builder()
+                                .symbols(person, friend)
+                                .with(ViatraModelQuery.ADAPTER)
+                                .queries(predicate)
+                                .build();
+
+                var model = store.createModel();
+                var personInterpretation = model.getInterpretation(person);
+                var friendInterpretation = model.getInterpretation(friend);
+                var queryEngine = model.getAdapter(ModelQuery.ADAPTER);
+                var predicateResultSet = queryEngine.getResultSet(predicate);
+
+                personInterpretation.put(Tuple.of(0), true);
+                personInterpretation.put(Tuple.of(1), true);
+                personInterpretation.put(Tuple.of(2), true);
+
+                friendInterpretation.put(Tuple.of(0, 1), TruthValue.TRUE);
+                friendInterpretation.put(Tuple.of(1, 2), TruthValue.TRUE);
+
+                queryEngine.flushChanges();
+                assertEquals(3, predicateResultSet.countResults());
+        }
+
+        @Test
         void transitivePatternCallTest() {
                 var person = new Symbol<>("Person", 1, Boolean.class, false);
                 var friend = new Symbol<>("friend", 2, TruthValue.class, TruthValue.FALSE);
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java
deleted file mode 100644
index af6a8f5a..00000000
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/AbstractSubstitutionAtom.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package tools.refinery.store.query.atom;
-
-import tools.refinery.store.representation.SymbolLike;
-import tools.refinery.store.query.Variable;
-
-import java.util.List;
-import java.util.Set;
-
-public abstract class AbstractSubstitutionAtom<T extends SymbolLike> implements DNFAtom {
-        private final T target;
-
-        private final List<Variable> substitution;
-
-        protected AbstractSubstitutionAtom(T target, List<Variable> substitution) {
-                if (substitution.size() != target.arity()) {
-                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
-                                        target.arity(), substitution.size()));
-                }
-                this.target = target;
-                this.substitution = substitution;
-        }
-
-        public T getTarget() {
-                return target;
-        }
-
-        public List<Variable> getSubstitution() {
-                return substitution;
-        }
-
-        @Override
-        public void collectAllVariables(Set<Variable> variables) {
-                variables.addAll(substitution);
-        }
-}
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
index 2e855246..6de5cd08 100644
--- 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
@@ -1,21 +1,28 @@
 package tools.refinery.store.query.atom;
 
-import tools.refinery.store.representation.SymbolLike;
 import tools.refinery.store.query.Variable;
+import tools.refinery.store.representation.SymbolLike;
 
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
-public abstract class CallAtom<T extends SymbolLike> extends AbstractSubstitutionAtom<T> {
+public abstract class CallAtom<T extends SymbolLike> implements DNFAtom {
         private final CallPolarity polarity;
+        private final T target;
+        private final List<Variable> substitution;
 
         protected CallAtom(CallPolarity polarity, T target, List<Variable> substitution) {
-                super(target, substitution);
+                if (substitution.size() != target.arity()) {
+                        throw new IllegalArgumentException("%s needs %d arguments, but got %s".formatted(target.name(),
+                                        target.arity(), substitution.size()));
+                }
                 if (polarity.isTransitive() && target.arity() != 2) {
                         throw new IllegalArgumentException("Transitive closures can only take binary relations");
                 }
                 this.polarity = polarity;
+                this.target = target;
+                this.substitution = substitution;
         }
 
         protected CallAtom(CallPolarity polarity, T target, Variable... substitution) {
@@ -42,10 +49,18 @@ public abstract class CallAtom<T extends SymbolLike> extends AbstractSubstitutio
                 return polarity;
         }
 
+        public T getTarget() {
+                return target;
+        }
+
+        public List<Variable> getSubstitution() {
+                return substitution;
+        }
+
         @Override
         public void collectAllVariables(Set<Variable> variables) {
                 if (polarity.isPositive()) {
-                        super.collectAllVariables(variables);
+                        variables.addAll(substitution);
                 }
         }
 
@@ -53,14 +68,13 @@ public abstract class CallAtom<T extends SymbolLike> extends AbstractSubstitutio
         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(polarity, that.polarity)
-                                && Objects.equals(getTarget(), that.getTarget())
-                                && Objects.equals(getSubstitution(), that.getSubstitution());
+                CallAtom<?> callAtom = (CallAtom<?>) o;
+                return polarity == callAtom.polarity && Objects.equals(target, callAtom.target) && Objects.equals(substitution
+                                , callAtom.substitution);
         }
 
         @Override
         public int hashCode() {
-                return Objects.hash(polarity, getTarget(), getSubstitution());
+                return Objects.hash(polarity, target, substitution);
         }
 }
diff --git a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
index cf836541..a2b176c4 100644
--- a/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
+++ b/subprojects/store/src/main/java/tools/refinery/store/query/atom/RelationViewAtom.java
@@ -4,28 +4,29 @@ import tools.refinery.store.query.Variable;
 import tools.refinery.store.query.view.AnyRelationView;
 
 import java.util.List;
-import java.util.Objects;
 
-public final class RelationViewAtom extends AbstractSubstitutionAtom<AnyRelationView> {
-        public RelationViewAtom(AnyRelationView target, List<Variable> substitution) {
-                super(target, substitution);
+public final class RelationViewAtom extends CallAtom<AnyRelationView> {
+        public RelationViewAtom(CallPolarity polarity, AnyRelationView target, List<Variable> substitution) {
+                super(polarity, target, substitution);
         }
 
-        public RelationViewAtom(AnyRelationView target, Variable... substitution) {
-                this(target, List.of(substitution));
+        public RelationViewAtom(CallPolarity polarity, AnyRelationView target, Variable... substitution) {
+                super(polarity, target, substitution);
         }
 
-        @Override
-        public boolean equals(Object o) {
-                if (this == o) return true;
-                if (o == null || getClass() != o.getClass()) return false;
-                RelationViewAtom relationViewAtom = (RelationViewAtom) o;
-                return Objects.equals(getTarget(), relationViewAtom.getTarget())
-                                && Objects.equals(getSubstitution(), relationViewAtom.getSubstitution());
+        public RelationViewAtom(boolean positive, AnyRelationView target, List<Variable> substitution) {
+                super(positive, target, substitution);
         }
 
-        @Override
-        public int hashCode() {
-                return Objects.hash(getTarget(), getSubstitution());
+        public RelationViewAtom(boolean positive, AnyRelationView target, Variable... substitution) {
+                super(positive, target, substitution);
+        }
+
+        public RelationViewAtom(AnyRelationView target, List<Variable> substitution) {
+                super(target, substitution);
+        }
+
+        public RelationViewAtom(AnyRelationView target, Variable... substitution) {
+                super(target, substitution);
         }
 }