feat: negative and transitive RelationViewAtom

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

3 files changed, 170 insertions, 9 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);