refactor: merge VIATRA subprojects

Since we remove EMF dependencies, there is no point to maintaining a base index
separate from the rest of the runtime.

247 files changed, 23714 insertions, 1 deletions

diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java
index ebae57a7..58285845 100644
--- a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/api/ViatraQueryEngine.java
@@ -9,7 +9,6 @@
 
 package tools.refinery.viatra.runtime.api;
 
-import org.eclipse.emf.common.notify.Notifier;
 import tools.refinery.viatra.runtime.api.scope.IBaseIndex;
 import tools.refinery.viatra.runtime.api.scope.QueryScope;
 import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingAlg.java
new file mode 100644
index 00000000..d0367cde
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingAlg.java
@@ -0,0 +1,226 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.counting;
+
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.DFSPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.IGraphPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.ITcRelation;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalWrapper;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcObserver;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+/**
+ * This class is the optimized implementation of the Counting algorithm.
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V>
+ *            the type parameter of the nodes in the graph data source
+ */
+public class CountingAlg<V> implements IGraphObserver<V>, ITcDataSource<V> {
+
+    private CountingTcRelation<V> tc = null;
+    private IBiDirectionalGraphDataSource<V> gds = null;
+    private List<ITcObserver<V>> observers;
+
+    /**
+     * Constructs a new Counting algorithm and initializes the transitive closure relation with the given graph data
+     * source. Attach itself on the graph data source as an observer.
+     * 
+     * @param gds
+     *            the graph data source instance
+     */
+    public CountingAlg(IGraphDataSource<V> gds) {
+
+        if (gds instanceof IBiDirectionalGraphDataSource<?>) {
+            this.gds = (IBiDirectionalGraphDataSource<V>) gds;
+        } else {
+            this.gds = new IBiDirectionalWrapper<V>(gds);
+        }
+
+        observers = CollectionsFactory.<ITcObserver<V>>createObserverList();
+        tc = new CountingTcRelation<V>(true);
+
+        initTc();
+        gds.attachObserver(this);
+    }
+
+    /**
+     * Initializes the transitive closure relation.
+     */
+    private void initTc() {
+        this.setTcRelation(CountingTcRelation.createFrom(gds));
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        if (!source.equals(target)) {
+            deriveTc(source, target, true);
+        }
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        if (!source.equals(target)) {
+            deriveTc(source, target, false);
+        }
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        this.tc.deleteTupleEnd(n);
+    }
+
+    /**
+     * Derives the transitive closure relation when an edge is inserted or deleted.
+     * 
+     * @param source
+     *            the source of the edge
+     * @param target
+     *            the target of the edge
+     * @param dCount
+     *            the value is -1 if an edge was deleted and +1 if an edge was inserted
+     */
+    private void deriveTc(V source, V target, boolean isInsertion) {
+
+        // if (dCount == 1 && isReachable(target, source)) {
+        // System.out.println("The graph contains cycle with (" + source + ","+ target + ") edge!");
+        // }
+
+        CountingTcRelation<V> dtc = new CountingTcRelation<V>(false);
+        Set<V> tupEnds = null;
+
+        // 1. d(tc(x,y)) :- d(l(x,y))
+        if (tc.updateTuple(source, target, isInsertion)) {
+            dtc.updateTuple(source, target, true /* deltas implicitly have the same sign as isInsertion*/);
+            notifyTcObservers(source, target, isInsertion);
+        }
+
+        // 2. d(tc(x,y)) :- d(l(x,z)) & tc(z,y)
+        tupEnds = tc.getTupleEnds(target);
+        if (tupEnds != null) {
+            for (V tupEnd : tupEnds) {
+                if (!tupEnd.equals(source)) {
+                    if (tc.updateTuple(source, tupEnd, isInsertion)) {
+                        dtc.updateTuple(source, tupEnd, true /* deltas implicitly have the same sign as isInsertion*/);
+                        notifyTcObservers(source, tupEnd, isInsertion);
+                    }
+                }
+            }
+        }
+
+        // 3. d(tc(x,y)) :- lv(x,z) & d(tc(z,y))
+        CountingTcRelation<V> newTuples = dtc;
+        CountingTcRelation<V> tmp = null;
+        dtc = new CountingTcRelation<V>(false);
+        
+        IMemoryView<V> nodes = null;
+
+        while (!newTuples.isEmpty()) {
+
+            tmp = dtc;
+            dtc = newTuples;
+            newTuples = tmp;
+            newTuples.clear();
+
+            for (V tS : dtc.getTupleStarts()) {
+                nodes = gds.getSourceNodes(tS);
+                for (V nS : nodes.distinctValues()) {
+                    int count = nodes.getCount(nS);
+                    for (int i = 0; i < count; i++) {
+                        tupEnds = dtc.getTupleEnds(tS);
+                        if (tupEnds != null) {
+                            for (V tT : tupEnds) {
+                                if (!nS.equals(tT)) {
+                                    if (tc.updateTuple(nS, tT, isInsertion)) {
+                                        newTuples.updateTuple(nS, tT, true /* deltas implicitly have the same sign as isInsertion*/);
+                                        notifyTcObservers(nS, tT, isInsertion);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // System.out.println(tc);
+    }
+
+    public ITcRelation<V> getTcRelation() {
+        return this.tc;
+    }
+
+    public void setTcRelation(CountingTcRelation<V> tc) {
+        this.tc = tc;
+    }
+
+    @Override
+    public boolean isReachable(V source, V target) {
+        return tc.containsTuple(source, target);
+    }
+
+    @Override
+    public void attachObserver(ITcObserver<V> to) {
+        this.observers.add(to);
+
+    }
+
+    @Override
+    public void detachObserver(ITcObserver<V> to) {
+        this.observers.remove(to);
+    }
+
+    @Override
+    public Set<V> getAllReachableTargets(V source) {
+        return tc.getTupleEnds(source);
+    }
+
+    @Override
+    public Set<V> getAllReachableSources(V target) {
+        return tc.getTupleStarts(target);
+    }
+
+    private void notifyTcObservers(V source, V target, boolean isInsertion) {
+        if (isInsertion) {
+            for (ITcObserver<V> o : observers) {
+                o.tupleInserted(source, target);
+            }
+        } else {
+            for (ITcObserver<V> o : observers) {
+                o.tupleDeleted(source, target);
+            }
+        }
+    }
+
+    @Override
+    public void dispose() {
+        tc.clear();
+        this.gds.detachObserver(this);
+    }
+
+    @Override
+    public IGraphPathFinder<V> getPathFinder() {
+        return new DFSPathFinder<V>(gds, this);
+    }
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingTcRelation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingTcRelation.java
new file mode 100644
index 00000000..44abbc3d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/counting/CountingTcRelation.java
@@ -0,0 +1,259 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.counting;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.topsort.TopologicalSorting;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.ITcRelation;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup.ChangeGranularity;
+
+/**
+ * Transitive closure relation implementation for the Counting algorithm.
+ *
+ * @author Tamas Szabo
+ *
+ * @param <V>
+ */
+public class CountingTcRelation<V> implements ITcRelation<V> {
+
+    private IMultiLookup<V, V> tuplesForward = null;
+    private IMultiLookup<V, V> tuplesBackward = null;
+
+    protected CountingTcRelation(boolean backwardIndexing) {
+        tuplesForward = CollectionsFactory.createMultiLookup(Object.class, MemoryType.MULTISETS, Object.class);
+        if (backwardIndexing)
+            tuplesBackward = CollectionsFactory.createMultiLookup(Object.class, MemoryType.MULTISETS, Object.class);
+    }
+
+    protected boolean isEmpty() {
+        return 0 == this.tuplesForward.countKeys();
+    }
+
+    protected void clear() {
+        this.tuplesForward.clear();
+
+        if (tuplesBackward != null) {
+            this.tuplesBackward.clear();
+        }
+    }
+
+    protected void union(CountingTcRelation<V> rA) {
+        IMultiLookup<V, V> rForward = rA.tuplesForward;
+        for (V source : rForward.distinctKeys()) {
+            IMemoryView<V> targetBag = rForward.lookup(source);
+            for (V target : targetBag.distinctValues()) {
+                this.addTuple(source, target, targetBag.getCount(target));
+            }
+        }
+    }
+
+    public int getCount(V source, V target) {
+        IMemoryView<V> bucket = tuplesForward.lookup(source);
+        return bucket == null ? 0 : bucket.getCount(target);
+    }
+
+    /**
+     * Returns true if the tc relation did not contain previously such a tuple that is defined by (source,target), false
+     * otherwise (in this case count is incremented with the given count parameter).
+     *
+     * @param source
+     *            the source of the tuple
+     * @param target
+     *            the target of the tuple
+     * @param count
+     *            the count of the tuple, must be positive
+     * @return true if the relation did not contain previously the tuple
+     */
+    public boolean addTuple(V source, V target, int count) {
+        if (tuplesBackward != null) {
+            tuplesBackward.addPairPositiveMultiplicity(target, source, count);
+        }
+
+        ChangeGranularity change =
+                tuplesForward.addPairPositiveMultiplicity(source, target, count);
+
+        return change != ChangeGranularity.DUPLICATE;
+    }
+
+    /**
+     * Derivation count of the tuple  (source,target) is incremented or decremented.
+     * Returns true iff updated to / from zero derivation count.
+     * @since 1.7
+     */
+    public boolean updateTuple(V source, V target, boolean isInsertion) {
+        if (isInsertion) {
+            if (tuplesBackward != null) {
+                tuplesBackward.addPair(target, source);
+            }
+            ChangeGranularity change =
+                    tuplesForward.addPair(source, target);
+            return change != ChangeGranularity.DUPLICATE;
+        } else {
+            if (tuplesBackward != null) {
+                tuplesBackward.removePair(target, source);
+            }
+            ChangeGranularity change =
+                    tuplesForward.removePair(source, target);
+            return change != ChangeGranularity.DUPLICATE;
+        }
+    }
+
+    public void deleteTupleEnd(V deleted) {
+        Set<V> sourcesToDelete = CollectionsFactory.createSet();
+        Set<V> targetsToDelete = CollectionsFactory.createSet();
+
+        for (V target : tuplesForward.lookupOrEmpty(deleted).distinctValues()) {
+            targetsToDelete.add(target);
+        }
+        if (tuplesBackward != null) {
+            for (V source : tuplesBackward.lookupOrEmpty(deleted).distinctValues()) {
+                sourcesToDelete.add(source);
+            }
+        } else {
+            for (V sourceCandidate : tuplesForward.distinctKeys()) {
+                if (tuplesForward.lookupOrEmpty(sourceCandidate).containsNonZero(deleted))
+                    sourcesToDelete.add(sourceCandidate);
+            }
+        }
+
+        for (V source : sourcesToDelete) {
+            int count = tuplesForward.lookupOrEmpty(source).getCount(deleted);
+            for (int i=0; i< count; ++i) tuplesForward.removePair(source, deleted);
+        }
+        for (V target : targetsToDelete) {
+            int count = tuplesForward.lookupOrEmpty(deleted).getCount(target);
+            for (int i=0; i< count; ++i) tuplesForward.removePair(deleted, target);
+        }
+
+        if (tuplesBackward != null) {
+            for (V source : sourcesToDelete) {
+                int count = tuplesBackward.lookupOrEmpty(deleted).getCount(source);
+                for (int i=0; i< count; ++i) tuplesBackward.removePair(deleted, source);
+            }
+            for (V target : targetsToDelete) {
+                int count = tuplesBackward.lookupOrEmpty(target).getCount(deleted);
+                for (int i=0; i< count; ++i) tuplesBackward.removePair(target, deleted);
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("TcRelation = ");
+
+        for (V source : tuplesForward.distinctKeys()) {
+            IMemoryView<V> targets = tuplesForward.lookup(source);
+            for (V target : targets.distinctValues()) {
+                sb.append("{(" + source + "," + target + ")," + targets.getCount(target) + "} ");
+            }
+        }
+
+        return sb.toString();
+    }
+
+    @Override
+    public Set<V> getTupleEnds(V source) {
+        IMemoryView<V> tupEnds = tuplesForward.lookup(source);
+        if (tupEnds == null)
+            return null;
+        return tupEnds.distinctValues();
+    }
+
+    /**
+     * Returns the set of nodes from which the target node is reachable, if already computed.
+     *
+     * @param target
+     *            the target node
+     * @return the set of source nodes
+     * @throws UnsupportedOperationException if backwards index not computed
+     */
+    public Set<V> getTupleStarts(V target) {
+        if (tuplesBackward != null) {
+            IMemoryView<V> tupStarts = tuplesBackward.lookup(target);
+            if (tupStarts == null)
+                return null;
+            return tupStarts.distinctValues();
+        } else {
+            throw new UnsupportedOperationException("built without backward indexing");
+        }
+    }
+
+    @Override
+    public Set<V> getTupleStarts() {
+        Set<V> nodes = CollectionsFactory.createSet();
+        for (V s : tuplesForward.distinctKeys()) {
+            nodes.add(s);
+        }
+        return nodes;
+    }
+
+    /**
+     * Returns true if a (source, target) node is present in the transitive closure relation, false otherwise.
+     *
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @return true if tuple is present, false otherwise
+     */
+    public boolean containsTuple(V source, V target) {
+        return tuplesForward.lookupOrEmpty(source).containsNonZero(target);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj == null || this.getClass() != obj.getClass()) {
+            return false;
+        } else {
+            CountingTcRelation<V> aTR = (CountingTcRelation<V>) obj;
+
+            return tuplesForward.equals(aTR.tuplesForward);
+        }
+    }
+
+    @Override
+    public int hashCode() {
+        return tuplesForward.hashCode();
+    }
+
+    public static <V> CountingTcRelation<V> createFrom(IBiDirectionalGraphDataSource<V> gds) {
+        List<V> topologicalSorting = TopologicalSorting.compute(gds);
+        CountingTcRelation<V> tc = new CountingTcRelation<V>(true);
+        Collections.reverse(topologicalSorting);
+        for (V n : topologicalSorting) {
+            IMemoryView<V> sourceNodes = gds.getSourceNodes(n);
+            Set<V> tupEnds = tc.getTupleEnds(n);
+            for (V s : sourceNodes.distinctValues()) {
+                int count = sourceNodes.getCount(s);
+                for (int i = 0; i < count; i++) {
+                    tc.updateTuple(s, n, true);
+                    if (tupEnds != null) {
+                        for (V t : tupEnds) {
+                            tc.updateTuple(s, t, true);
+                        }
+                    }
+                }
+            }
+        }
+
+        return tc;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedAlg.java
new file mode 100644
index 00000000..b92d08bf
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedAlg.java
@@ -0,0 +1,308 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.dred;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.DFSPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.IGraphPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.Tuple;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.dfs.DFSAlg;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcObserver;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+/**
+ * This class is the optimized implementation of the DRED algorithm.
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V>
+ *            the type parameter of the nodes in the graph data source
+ */
+public class DRedAlg<V> implements IGraphObserver<V>, ITcDataSource<V> {
+
+    private IGraphDataSource<V> graphDataSource = null;
+    private DRedTcRelation<V> tc = null;
+    private DRedTcRelation<V> dtc = null;
+    private List<ITcObserver<V>> observers;
+
+    /**
+     * Constructs a new DRED algorithm and initializes the transitive closure relation with the given graph data source.
+     * Attach itself on the graph data source as an observer.
+     * 
+     * @param gds
+     *            the graph data source instance
+     */
+    public DRedAlg(IGraphDataSource<V> gds) {
+        this.observers = new ArrayList<ITcObserver<V>>();
+        this.graphDataSource = gds;
+        this.tc = new DRedTcRelation<V>();
+        this.dtc = new DRedTcRelation<V>();
+        initTc();
+        graphDataSource.attachObserver(this);
+    }
+
+    /**
+     * Constructs a new DRED algorithm and initializes the transitive closure relation with the given relation. Attach
+     * itself on the graph data source as an observer.
+     * 
+     * @param gds
+     *            the graph data source instance
+     * @param tc
+     *            the transitive closure instance
+     */
+    public DRedAlg(IGraphDataSource<V> gds, DRedTcRelation<V> tc) {
+        this.graphDataSource = gds;
+        this.tc = tc;
+        this.dtc = new DRedTcRelation<V>();
+        graphDataSource.attachObserver(this);
+    }
+
+    /**
+     * Initializes the transitive closure relation.
+     */
+    private void initTc() {
+        DFSAlg<V> dfsa = new DFSAlg<V>(this.graphDataSource);
+        this.setTcRelation(dfsa.getTcRelation());
+        this.graphDataSource.detachObserver(dfsa);
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        if (!source.equals(target)) {
+            Set<V> tupStarts = null;
+            Set<V> tupEnds = null;
+            Set<Tuple<V>> tuples = new HashSet<Tuple<V>>();
+
+            if (!source.equals(target) && tc.addTuple(source, target)) {
+                tuples.add(new Tuple<V>(source, target));
+            }
+
+            // 2. d+(tc(x,y)) :- d+(tc(x,z)) & lv(z,y) Descartes product
+            tupStarts = tc.getTupleStarts(source);
+            tupEnds = tc.getTupleEnds(target);
+
+            for (V s : tupStarts) {
+                for (V t : tupEnds) {
+                    if (!s.equals(t) && tc.addTuple(s, t)) {
+                        tuples.add(new Tuple<V>(s, t));
+                    }
+                }
+            }
+
+            // (s, source) -> (source, target)
+            // tupStarts = tc.getTupleStarts(source);
+            for (V s : tupStarts) {
+                if (!s.equals(target) && tc.addTuple(s, target)) {
+                    tuples.add(new Tuple<V>(s, target));
+                }
+            }
+
+            // (source, target) -> (target, t)
+            // tupEnds = tc.getTupleEnds(target);
+            for (V t : tupEnds) {
+                if (!source.equals(t) && tc.addTuple(source, t)) {
+                    tuples.add(new Tuple<V>(source, t));
+                }
+            }
+
+            notifyTcObservers(tuples, 1);
+        }
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        if (!source.equals(target)) {
+
+            // Computing overestimate, Descartes product of A and B sets, where
+            // A: those nodes from which source is reachable
+            // B: those nodes which is reachable from target
+
+            Map<Tuple<V>, Integer> tuples = new HashMap<Tuple<V>, Integer>();
+            Set<V> sources = tc.getTupleStarts(source);
+            Set<V> targets = tc.getTupleEnds(target);
+
+            tc.removeTuple(source, target);
+            tuples.put(new Tuple<V>(source, target), -1);
+
+            for (V s : sources) {
+                for (V t : targets) {
+                    if (!s.equals(t)) {
+                        tc.removeTuple(s, t);
+                        tuples.put(new Tuple<V>(s, t), -1);
+                    }
+                }
+            }
+
+            for (V s : sources) {
+                if (!s.equals(target)) {
+                    tc.removeTuple(s, target);
+                    tuples.put(new Tuple<V>(s, target), -1);
+                }
+            }
+
+            for (V t : targets) {
+                if (!source.equals(t)) {
+                    tc.removeTuple(source, t);
+                    tuples.put(new Tuple<V>(source, t), -1);
+                }
+            }
+
+            // System.out.println("overestimate: "+dtc);
+
+            // Modify overestimate with those tuples that have alternative derivations
+            // 1. q+(tc(x,y)) :- lv(x,y)
+            for (V s : graphDataSource.getAllNodes()) {
+                IMemoryView<V> targetNodes = graphDataSource.getTargetNodes(s);
+                for (Entry<V, Integer> entry : targetNodes.entriesWithMultiplicities()) {
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        V t = entry.getKey();
+                        if (!s.equals(t)) {
+                            tc.addTuple(s, t);
+                            Tuple<V> tuple = new Tuple<V>(s, t);
+                            Integer count = tuples.get(tuple);
+                            if (count != null && count == -1) {
+                                tuples.remove(tuple);
+                            }
+                        }
+                        
+                    }
+                }
+            }
+
+            // 2. q+(tc(x,y)) :- tcv(x,z) & lv(z,y)
+            DRedTcRelation<V> newTups = new DRedTcRelation<V>();
+            dtc.clear();
+            dtc.union(tc);
+
+            while (!dtc.isEmpty()) {
+
+                newTups.clear();
+                newTups.union(dtc);
+                dtc.clear();
+
+                for (V s : newTups.getTupleStarts()) {
+                    for (V t : newTups.getTupleEnds(s)) {
+                        IMemoryView<V> targetNodes = graphDataSource.getTargetNodes(t);
+                        if (targetNodes != null) {
+                            for (Entry<V, Integer> entry : targetNodes.entriesWithMultiplicities()) {
+                                for (int i = 0; i < entry.getValue(); i++) {
+                                    V tn = entry.getKey();
+                                    if (!s.equals(tn) && tc.addTuple(s, tn)) {
+                                        dtc.addTuple(s, tn);
+                                        tuples.remove(new Tuple<V>(s, tn));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            notifyTcObservers(tuples.keySet(), -1);
+        }
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+        // Node inserted does not result new tc tuple.
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        // FIXME node deletion may involve the deletion of incoming and outgoing edges too
+        Set<V> set = tc.getTupleEnds(n);
+        Set<V> modSet = null;
+
+        // n -> target
+        modSet = new HashSet<V>(set);
+
+        for (V tn : modSet) {
+            this.tc.removeTuple(n, tn);
+        }
+
+        // source -> n
+        set = tc.getTupleStarts(n);
+
+        modSet = new HashSet<V>(set);
+
+        for (V sn : modSet) {
+            this.tc.removeTuple(sn, n);
+        }
+    }
+
+    public DRedTcRelation<V> getTcRelation() {
+        return this.tc;
+    }
+
+    public void setTcRelation(DRedTcRelation<V> tc) {
+        this.tc = tc;
+    }
+
+    @Override
+    public boolean isReachable(V source, V target) {
+        return tc.containsTuple(source, target);
+    }
+
+    @Override
+    public void attachObserver(ITcObserver<V> to) {
+        this.observers.add(to);
+    }
+
+    @Override
+    public void detachObserver(ITcObserver<V> to) {
+        this.observers.remove(to);
+    }
+
+    @Override
+    public Set<V> getAllReachableTargets(V source) {
+        return tc.getTupleEnds(source);
+    }
+
+    @Override
+    public Set<V> getAllReachableSources(V target) {
+        return tc.getTupleStarts(target);
+    }
+
+    protected void notifyTcObservers(Set<Tuple<V>> tuples, int dir) {
+        for (ITcObserver<V> o : observers) {
+            for (Tuple<V> t : tuples) {
+                if (!t.getSource().equals(t.getTarget())) {
+                    if (dir == 1) {
+                        o.tupleInserted(t.getSource(), t.getTarget());
+                    }
+                    if (dir == -1) {
+                        o.tupleDeleted(t.getSource(), t.getTarget());
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void dispose() {
+        tc = null;
+        dtc = null;
+    }
+
+    @Override
+    public IGraphPathFinder<V> getPathFinder() {
+        return new DFSPathFinder<V>(graphDataSource, this);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedTcRelation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedTcRelation.java
new file mode 100644
index 00000000..8543b79c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/dred/DRedTcRelation.java
@@ -0,0 +1,223 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.dred;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.ITcRelation;
+
+public class DRedTcRelation<V> implements ITcRelation<V> {
+
+    // tc(a,b) means that b is transitively reachable from a
+    private Map<V, Set<V>> tuplesForward;
+
+    // data structure to efficiently get those nodes from which a given node is reachable
+    // symmetric to tuplesForward
+    private Map<V, Set<V>> tuplesBackward;
+
+    public DRedTcRelation() {
+        this.tuplesForward = new HashMap<V, Set<V>>();
+        this.tuplesBackward = new HashMap<V, Set<V>>();
+    }
+
+    public void clear() {
+        this.tuplesForward.clear();
+        this.tuplesBackward.clear();
+    }
+
+    public boolean isEmpty() {
+        return tuplesForward.isEmpty();
+    }
+
+    public void removeTuple(V source, V target) {
+
+        // removing tuple from 'forward' tc relation
+        Set<V> sSet = tuplesForward.get(source);
+        if (sSet != null) {
+            sSet.remove(target);
+            if (sSet.size() == 0)
+                tuplesForward.remove(source);
+        }
+
+        // removing tuple from 'backward' tc relation
+        Set<V> tSet = tuplesBackward.get(target);
+        if (tSet != null) {
+            tSet.remove(source);
+            if (tSet.size() == 0)
+                tuplesBackward.remove(target);
+        }
+    }
+
+    /**
+     * Returns true if the tc relation did not contain previously such a tuple that is defined by (source,target), false
+     * otherwise.
+     * 
+     * @param source
+     *            the source of the tuple
+     * @param target
+     *            the target of the tuple
+     * @return true if the relation did not contain previously the tuple
+     */
+    public boolean addTuple(V source, V target) {
+
+        // symmetric modification, it is sufficient to check the return value in one collection
+        // adding tuple to 'forward' tc relation
+        Set<V> sSet = tuplesForward.get(source);
+        if (sSet == null) {
+            Set<V> newSet = new HashSet<V>();
+            newSet.add(target);
+            tuplesForward.put(source, newSet);
+        } else {
+            sSet.add(target);
+        }
+
+        // adding tuple to 'backward' tc relation
+        Set<V> tSet = tuplesBackward.get(target);
+        if (tSet == null) {
+            Set<V> newSet = new HashSet<V>();
+            newSet.add(source);
+            tuplesBackward.put(target, newSet);
+            return true;
+        } else {
+            boolean ret = tSet.add(source);
+            return ret;
+        }
+
+    }
+
+    /**
+     * Union operation of two tc realtions.
+     * 
+     * @param rA
+     *            the other tc relation
+     */
+    public void union(DRedTcRelation<V> rA) {
+        for (V source : rA.tuplesForward.keySet()) {
+            for (V target : rA.tuplesForward.get(source)) {
+                this.addTuple(source, target);
+            }
+        }
+    }
+
+    /**
+     * Computes the difference of this tc relation and the given rA parameter.
+     * 
+     * @param rA
+     *            the subtrahend relation
+     */
+    public void difference(DRedTcRelation<V> rA) {
+        for (V source : rA.tuplesForward.keySet()) {
+            for (V target : rA.tuplesForward.get(source)) {
+                this.removeTuple(source, target);
+            }
+        }
+    }
+
+    @Override
+    public Set<V> getTupleEnds(V source) {
+        Set<V> t = tuplesForward.get(source);
+        return (t == null) ? new HashSet<V>() : new HashSet<V>(t);
+    }
+
+    /**
+     * Returns the set of nodes from which the target node is reachable.
+     * 
+     * @param target
+     *            the target node
+     * @return the set of source nodes
+     */
+    public Set<V> getTupleStarts(V target) {
+        Set<V> t = tuplesBackward.get(target);
+        return (t == null) ? new HashSet<V>() : new HashSet<V>(t);
+    }
+
+    @Override
+    public Set<V> getTupleStarts() {
+        Set<V> t = tuplesForward.keySet();
+        return new HashSet<V>(t);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("TcRelation = ");
+
+        for (Entry<V, Set<V>> entry : this.tuplesForward.entrySet()) {
+            V source = entry.getKey();
+            for (V target : entry.getValue()) {
+                sb.append("(" + source + "," + target + ") ");
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Returns true if a (source, target) node is present in the transitive closure relation, false otherwise.
+     * 
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @return true if tuple is present, false otherwise
+     */
+    public boolean containsTuple(V source, V target) {
+        if (tuplesForward.containsKey(source)) {
+            if (tuplesForward.get(source).contains(target))
+                return true;
+        }
+        return false;
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if ((obj == null) || (obj.getClass() != this.getClass())) {
+            return false;
+        }
+
+        DRedTcRelation<V> aTR = (DRedTcRelation<V>) obj;
+
+        for (Entry<V, Set<V>> entry : aTR.tuplesForward.entrySet()) {
+            V source = entry.getKey();
+            for (V target : entry.getValue()) {
+                if (!this.containsTuple(source, target))
+                    return false;
+            }
+        }
+
+        for (Entry<V, Set<V>> entry : this.tuplesForward.entrySet()) {
+            V source = entry.getKey();
+            for (V target : entry.getValue()) {
+                if (!aTR.containsTuple(source, target))
+                    return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int hash = 7;
+        hash = 31 * hash + tuplesForward.hashCode();
+        hash = 31 * hash + tuplesBackward.hashCode();
+        return hash;
+    }
+
+    public Map<V, Set<V>> getTuplesForward() {
+        return tuplesForward;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/fw/FloydWarshallAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/fw/FloydWarshallAlg.java
new file mode 100644
index 00000000..8b8908b1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/fw/FloydWarshallAlg.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.fw;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.base.itc.alg.dred.DRedTcRelation;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalWrapper;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+public class FloydWarshallAlg<V> implements IGraphObserver<V> {
+
+    private DRedTcRelation<V> tc = null;
+    private IBiDirectionalGraphDataSource<V> gds = null;
+
+    public FloydWarshallAlg(IGraphDataSource<V> gds) {
+        if (gds instanceof IBiDirectionalGraphDataSource<?>) {
+            this.gds = (IBiDirectionalGraphDataSource<V>) gds;
+        } else {
+            this.gds = new IBiDirectionalWrapper<V>(gds);
+        }
+
+        this.tc = new DRedTcRelation<V>();
+        gds.attachObserver(this);
+        generateTc();
+    }
+
+    private void generateTc() {
+
+        tc.clear();
+
+        int n = gds.getAllNodes().size();
+        Map<V, Integer> mapForw = new HashMap<V, Integer>();
+        Map<Integer, V> mapBackw = new HashMap<Integer, V>();
+        int[][] P = new int[n][n];
+
+        int i, j, k;
+
+        // initialize adjacent matrix
+        for (i = 0; i < n; i++) {
+            for (j = 0; j < n; j++) {
+                P[i][j] = 0;
+            }
+        }
+
+        i = 0;
+        for (V node : gds.getAllNodes()) {
+            mapForw.put(node, i);
+            mapBackw.put(i, node);
+            i++;
+        }
+
+        for (V source : gds.getAllNodes()) {
+            IMemoryView<V> targets = gds.getTargetNodes(source);
+            for (V target : targets.distinctValues()) {
+                P[mapForw.get(source)][mapForw.get(target)] = 1;
+            }
+        }
+
+        for (k = 0; k < n; k++) {
+            for (i = 0; i < n; i++) {
+                for (j = 0; j < n; j++) {
+                    P[i][j] = P[i][j] | (P[i][k] & P[k][j]);
+                }
+            }
+        }
+
+        for (i = 0; i < n; i++) {
+            for (j = 0; j < n; j++) {
+                if (P[i][j] == 1 && i != j)
+                    tc.addTuple(mapBackw.get(i), mapBackw.get(j));
+            }
+        }
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        generateTc();
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        generateTc();
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+        generateTc();
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        generateTc();
+    }
+
+    public DRedTcRelation<V> getTcRelation() {
+        return this.tc;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/CountingListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/CountingListener.java
new file mode 100644
index 00000000..fdf64f77
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/CountingListener.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.alg.incscc;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcObserver;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+/**
+ * @author Tamas Szabo
+ * 
+ */
+public class CountingListener<V> implements ITcObserver<V> {
+
+    private IncSCCAlg<V> alg;
+
+    public CountingListener(IncSCCAlg<V> alg) {
+        this.alg = alg;
+    }
+
+    @Override
+    public void tupleInserted(V source, V target) {
+        alg.notifyTcObservers(alg.sccs.getPartition(source), alg.sccs.getPartition(target), Direction.INSERT);
+    }
+
+    @Override
+    public void tupleDeleted(V source, V target) {
+        alg.notifyTcObservers(alg.sccs.getPartition(source), alg.sccs.getPartition(target), Direction.DELETE);
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/IncSCCAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/IncSCCAlg.java
new file mode 100644
index 00000000..5d720e75
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/incscc/IncSCCAlg.java
@@ -0,0 +1,645 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.incscc;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.counting.CountingAlg;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.bfs.BFS;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.scc.SCC;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.scc.SCCResult;
+import tools.refinery.viatra.runtime.base.itc.alg.util.CollectionHelper;
+import tools.refinery.viatra.runtime.base.itc.alg.dred.DRedTcRelation;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.DFSPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.GraphHelper;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.IGraphPathFinder;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.Tuple;
+import tools.refinery.viatra.runtime.base.itc.graphimpl.Graph;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalWrapper;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcObserver;
+import tools.refinery.viatra.runtime.matchers.algorithms.UnionFind;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+/**
+ * Incremental SCC maintenance + counting algorithm.
+ *
+ * @author Tamas Szabo
+ *
+ * @param <V>
+ *            the type parameter of the nodes in the graph data source
+ */
+public class IncSCCAlg<V> implements IGraphObserver<V>, ITcDataSource<V> {
+
+    public UnionFind<V> sccs;
+    public IBiDirectionalGraphDataSource<V> gds;
+    private CountingAlg<V> counting;
+    private Graph<V> reducedGraph;
+    private IBiDirectionalGraphDataSource<V> reducedGraphIndexer;
+    private List<ITcObserver<V>> observers;
+    private CountingListener<V> countingListener;
+
+    public IncSCCAlg(IGraphDataSource<V> graphDataSource) {
+
+        if (graphDataSource instanceof IBiDirectionalGraphDataSource<?>) {
+            gds = (IBiDirectionalGraphDataSource<V>) graphDataSource;
+        } else {
+            gds = new IBiDirectionalWrapper<V>(graphDataSource);
+        }
+        observers = CollectionsFactory.createObserverList();
+        sccs = new UnionFind<V>();
+        reducedGraph = new Graph<V>();
+        reducedGraphIndexer = new IBiDirectionalWrapper<V>(reducedGraph);
+        countingListener = new CountingListener<V>(this);
+        initalizeInternalDataStructures();
+        gds.attachObserver(this);
+    }
+
+    private void initalizeInternalDataStructures() {
+        SCCResult<V> _sccres = SCC.computeSCC(gds);
+        Set<Set<V>> _sccs = _sccres.getSccs();
+
+        for (Set<V> _set : _sccs) {
+            sccs.makeSet(_set);
+        }
+
+        // Initalization of the reduced graph
+        for (V n : sccs.getPartitionHeads()) {
+            reducedGraph.insertNode(n);
+        }
+
+        for (V source : gds.getAllNodes()) {
+            final IMemoryView<V> targetNodes = gds.getTargetNodes(source);
+            for (Entry<V, Integer> entry : targetNodes.entriesWithMultiplicities()) {
+                for (int i = 0; i < entry.getValue(); i++) {
+                    V target = entry.getKey();
+                    V sourceRoot = sccs.find(source);
+                    V targetRoot = sccs.find(target);
+
+                    if (!sourceRoot.equals(targetRoot)) {
+                        reducedGraph.insertEdge(sourceRoot, targetRoot);
+                    }
+                }
+            }
+        }
+
+        counting = new CountingAlg<V>(reducedGraph);
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        V sourceRoot = sccs.find(source);
+        V targetRoot = sccs.find(target);
+
+        // Different SCC
+        if (!sourceRoot.equals(targetRoot)) {
+
+            // source is reachable from target?
+            if (counting.isReachable(targetRoot, sourceRoot)) {
+
+                Set<V> predecessorRoots = counting.getAllReachableSources(sourceRoot);
+                Set<V> successorRoots = counting.getAllReachableTargets(targetRoot);
+
+                // 1. intersection of source and target roots, these will be in the merged SCC
+                Set<V> isectRoots = CollectionHelper.intersection(predecessorRoots, successorRoots);
+                isectRoots.add(sourceRoot);
+                isectRoots.add(targetRoot);
+
+                // notifications must be issued before Union-Find modifications
+                if (observers.size() > 0) {
+                    Set<V> sourceSCCs = createSetNullTolerant(predecessorRoots);
+                    sourceSCCs.add(sourceRoot);
+                    Set<V> targetSCCs = createSetNullTolerant(successorRoots);
+                    targetSCCs.add(targetRoot);
+
+                    // tracing back to actual nodes
+                    for (V sourceSCC : sourceSCCs) {
+                        targetLoop: for (V targetSCC : targetSCCs) {
+                            if (counting.isReachable(sourceSCC, targetSCC)) continue targetLoop;
+
+                            boolean needsNotification =
+                                // Case 1. sourceSCC and targetSCC are the same and it is a one sized scc.
+                                // Issue notifications only if there is no self-loop present at the moment
+                                (sourceSCC.equals(targetSCC) && sccs.getPartition(sourceSCC).size() == 1 && GraphHelper
+                                        .getEdgeCount(sccs.getPartition(sourceSCC).iterator().next(), gds) == 0)
+                                ||
+                                // Case 2. sourceSCC and targetSCC are different sccs.
+                                (!sourceSCC.equals(targetSCC));
+                            // if self loop is already present omit the notification
+                            if (needsNotification) {
+                                notifyTcObservers(sccs.getPartition(sourceSCC), sccs.getPartition(targetSCC),
+                                        Direction.INSERT);
+                            }
+                        }
+                    }
+                }
+
+                // 2. delete edges, nodes
+                List<V> sourceSCCs = new ArrayList<V>();
+                List<V> targetSCCs = new ArrayList<V>();
+
+                for (V r : isectRoots) {
+                    List<V> sourceSCCsOfSCC = getSourceSCCsOfSCC(r);
+                    List<V> targetSCCsOfSCC = getTargetSCCsOfSCC(r);
+
+                    for (V sourceSCC : sourceSCCsOfSCC) {
+                        if (!sourceSCC.equals(r)) {
+                            reducedGraph.deleteEdgeIfExists(sourceSCC, r);
+                        }
+                    }
+
+                    for (V targetSCC : targetSCCsOfSCC) {
+                        if (!isectRoots.contains(targetSCC) && !r.equals(targetSCC)) {
+                            reducedGraph.deleteEdgeIfExists(r, targetSCC);
+                        }
+                    }
+
+                    sourceSCCs.addAll(sourceSCCsOfSCC);
+                    targetSCCs.addAll(targetSCCsOfSCC);
+                }
+
+                for (V r : isectRoots) {
+                    reducedGraph.deleteNode(r);
+                }
+
+                // 3. union
+                Iterator<V> iterator = isectRoots.iterator();
+                V newRoot = iterator.next();
+                while (iterator.hasNext()) {
+                    newRoot = sccs.union(newRoot, iterator.next());
+                }
+
+                // 4. add new node
+                reducedGraph.insertNode(newRoot);
+
+                // 5. add edges
+                Set<V> containedNodes = sccs.getPartition(newRoot);
+
+                for (V sourceSCC : sourceSCCs) {
+                    if (!containedNodes.contains(sourceSCC) && !sourceSCC.equals(newRoot)) {
+                        reducedGraph.insertEdge(sourceSCC, newRoot);
+                    }
+                }
+                for (V targetSCC : targetSCCs) {
+                    if (!containedNodes.contains(targetSCC) && !targetSCC.equals(newRoot)) {
+                        reducedGraph.insertEdge(newRoot, targetSCC);
+                    }
+                }
+            } else {
+                if (observers.size() > 0 && GraphHelper.getEdgeCount(source, target, gds) == 1) {
+                    counting.attachObserver(countingListener);
+                }
+                reducedGraph.insertEdge(sourceRoot, targetRoot);
+                counting.detachObserver(countingListener);
+            }
+        } else {
+            // Notifications about self-loops
+            if (observers.size() > 0 && sccs.getPartition(sourceRoot).size() == 1
+                    && GraphHelper.getEdgeCount(source, target, gds) == 1) {
+                notifyTcObservers(source, source, Direction.INSERT);
+            }
+        }
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        V sourceRoot = sccs.find(source);
+        V targetRoot = sccs.find(target);
+
+        if (!sourceRoot.equals(targetRoot)) {
+            if (observers.size() > 0 && GraphHelper.getEdgeCount(source, target, gds) == 0) {
+                counting.attachObserver(countingListener);
+            }
+            reducedGraph.deleteEdgeIfExists(sourceRoot, targetRoot);
+            counting.detachObserver(countingListener);
+        } else {
+            // get the graph for the scc whose root is sourceRoot
+            Graph<V> g = GraphHelper.getSubGraph(sccs.getPartition(sourceRoot), gds);
+
+            // if source is not reachable from target anymore
+            if (!BFS.isReachable(source, target, g)) {
+                // create copies of the current state before destructive manipulation
+                Map<V, Integer> reachableSources = CollectionsFactory.createMap();
+                for (Entry<V, Integer> entry : reducedGraphIndexer.getSourceNodes(sourceRoot).entriesWithMultiplicities()) {
+                    reachableSources.put(entry.getKey(), entry.getValue());
+                }
+                Map<V, Integer> reachableTargets = CollectionsFactory.createMap();
+                for (Entry<V, Integer> entry : reducedGraphIndexer.getTargetNodes(sourceRoot).entriesWithMultiplicities()) {
+                    reachableTargets.put(entry.getKey(), entry.getValue());
+                }
+
+                SCCResult<V> _newSccs = SCC.computeSCC(g);
+
+                // delete scc node (and with its edges too)
+                for (Entry<V, Integer> entry : reachableSources.entrySet()) {
+                    V s = entry.getKey();
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        reducedGraph.deleteEdgeIfExists(s, sourceRoot);
+                    }
+                }
+
+                for (Entry<V, Integer> entry : reachableTargets.entrySet()) {
+                    V t = entry.getKey();
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        reducedGraph.deleteEdgeIfExists(sourceRoot, t);
+                    }
+                }
+
+                sccs.deleteSet(sourceRoot);
+                reducedGraph.deleteNode(sourceRoot);
+
+                Set<Set<V>> newSCCs = _newSccs.getSccs();
+                Set<V> newSCCRoots = CollectionsFactory.createSet();
+
+                // add new nodes and edges to the reduced graph
+                for (Set<V> newSCC : newSCCs) {
+                    V newRoot = sccs.makeSet(newSCC);
+                    reducedGraph.insertNode(newRoot);
+                    newSCCRoots.add(newRoot);
+                }
+                for (V newSCCRoot : newSCCRoots) {
+                    List<V> sourceSCCsOfSCC = getSourceSCCsOfSCC(newSCCRoot);
+                    List<V> targetSCCsOfSCC = getTargetSCCsOfSCC(newSCCRoot);
+
+                    for (V sourceSCC : sourceSCCsOfSCC) {
+                        if (!sourceSCC.equals(newSCCRoot)) {
+                            reducedGraph.insertEdge(sccs.find(sourceSCC), newSCCRoot);
+                        }
+                    }
+                    for (V targetSCC : targetSCCsOfSCC) {
+                        if (!newSCCRoots.contains(targetSCC) && !targetSCC.equals(newSCCRoot))
+                            reducedGraph.insertEdge(newSCCRoot, targetSCC);
+                    }
+                }
+
+                // Must be after the union-find modifications
+                if (observers.size() > 0) {
+                    V newSourceRoot = sccs.find(source);
+                    V newTargetRoot = sccs.find(target);
+
+                    Set<V> sourceSCCs = createSetNullTolerant(counting.getAllReachableSources(newSourceRoot));
+                    sourceSCCs.add(newSourceRoot);
+
+                    Set<V> targetSCCs = createSetNullTolerant(counting.getAllReachableTargets(newTargetRoot));
+                    targetSCCs.add(newTargetRoot);
+
+                    for (V sourceSCC : sourceSCCs) {
+                        targetLoop: for (V targetSCC : targetSCCs) {
+                            if (counting.isReachable(sourceSCC, targetSCC)) continue targetLoop;
+
+                            boolean needsNotification =
+                                // Case 1. sourceSCC and targetSCC are the same and it is a one sized scc.
+                                // Issue notifications only if there is no self-loop present at the moment
+                                (sourceSCC.equals(targetSCC) && sccs.getPartition(sourceSCC).size() == 1 && GraphHelper
+                                        .getEdgeCount(sccs.getPartition(sourceSCC).iterator().next(), gds) == 0)
+                                ||
+                                // Case 2. sourceSCC and targetSCC are different sccs.
+                                (!sourceSCC.equals(targetSCC));
+                            // if self loop is already present omit the notification
+                            if (needsNotification) {
+                                notifyTcObservers(sccs.getPartition(sourceSCC), sccs.getPartition(targetSCC),
+                                        Direction.DELETE);
+                            }
+                        }
+                    }
+                }
+            } else {
+                // only handle self-loop notifications - sourceRoot equals to targetRoot
+                if (observers.size() > 0 && sccs.getPartition(sourceRoot).size() == 1
+                        && GraphHelper.getEdgeCount(source, target, gds) == 0) {
+                    notifyTcObservers(source, source, Direction.DELETE);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+        sccs.makeSet(n);
+        reducedGraph.insertNode(n);
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        IMemoryView<V> sources = gds.getSourceNodes(n);
+        IMemoryView<V> targets = gds.getTargetNodes(n);
+
+        for (Entry<V, Integer> entry : sources.entriesWithMultiplicities()) {
+            for (int i = 0; i < entry.getValue(); i++) {
+                V source = entry.getKey();
+                edgeDeleted(source, n);
+            }
+        }
+
+        for (Entry<V, Integer> entry : targets.entriesWithMultiplicities()) {
+            for (int i = 0; i < entry.getValue(); i++) {
+                V target = entry.getKey();
+                edgeDeleted(n, target);
+            }
+        }
+
+        sccs.deleteSet(n);
+    }
+
+    @Override
+    public void attachObserver(ITcObserver<V> to) {
+        observers.add(to);
+    }
+
+    @Override
+    public void detachObserver(ITcObserver<V> to) {
+        observers.remove(to);
+    }
+
+    @Override
+    public Set<V> getAllReachableTargets(V source) {
+        V sourceRoot = sccs.find(source);
+        Set<V> containedNodes = sccs.getPartition(sourceRoot);
+        Set<V> targets = CollectionsFactory.createSet();
+
+        if (containedNodes.size() > 1 || GraphHelper.getEdgeCount(source, gds) == 1) {
+            targets.addAll(containedNodes);
+        }
+
+        Set<V> rootSet = counting.getAllReachableTargets(sourceRoot);
+        if (rootSet != null) {
+            for (V _root : rootSet) {
+                targets.addAll(sccs.getPartition(_root));
+            }
+        }
+
+        return targets;
+    }
+
+    @Override
+    public Set<V> getAllReachableSources(V target) {
+        V targetRoot = sccs.find(target);
+        Set<V> containedNodes = sccs.getPartition(targetRoot);
+        Set<V> sources = CollectionsFactory.createSet();
+
+        if (containedNodes.size() > 1 || GraphHelper.getEdgeCount(target, gds) == 1) {
+            sources.addAll(containedNodes);
+        }
+
+        Set<V> rootSet = counting.getAllReachableSources(targetRoot);
+        if (rootSet != null) {
+            for (V _root : rootSet) {
+                sources.addAll(sccs.getPartition(_root));
+            }
+        }
+        return sources;
+    }
+
+    @Override
+    public boolean isReachable(V source, V target) {
+        V sourceRoot = sccs.find(source);
+        V targetRoot = sccs.find(target);
+
+        if (sourceRoot.equals(targetRoot))
+            return true;
+        else
+            return counting.isReachable(sourceRoot, targetRoot);
+    }
+
+    public List<V> getReachabilityPath(V source, V target) {
+        if (!isReachable(source, target)) {
+            return null;
+        } else {
+            Set<V> sccsInSubGraph = CollectionHelper.intersection(counting.getAllReachableTargets(source),
+                    counting.getAllReachableSources(target));
+            sccsInSubGraph.add(sccs.find(source));
+            sccsInSubGraph.add(sccs.find(target));
+            Set<V> nodesInSubGraph = CollectionsFactory.createSet();
+
+            for (V sccRoot : sccsInSubGraph) {
+                nodesInSubGraph.addAll(sccs.getPartition(sccRoot));
+            }
+
+            return GraphHelper.constructPath(source, target, nodesInSubGraph, gds);
+        }
+    }
+
+    // for JUnit
+    public boolean checkTcRelation(DRedTcRelation<V> tc) {
+
+        for (V s : tc.getTupleStarts()) {
+            for (V t : tc.getTupleEnds(s)) {
+                if (!isReachable(s, t))
+                    return false;
+            }
+        }
+
+        for (V root : counting.getTcRelation().getTupleStarts()) {
+            for (V end : counting.getTcRelation().getTupleEnds(root)) {
+                for (V s : sccs.getPartition(root)) {
+                    for (V t : sccs.getPartition(end)) {
+                        if (!tc.containsTuple(s, t))
+                            return false;
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Return the SCCs from which the SCC represented by the root node is reachable. Note that an SCC can be present
+     * multiple times in the returned list (multiple edges between the two SCCs).
+     *
+     * @param root
+     * @return the list of reachable target SCCs
+     */
+    private List<V> getSourceSCCsOfSCC(V root) {
+        List<V> sourceSCCs = new ArrayList<V>();
+
+        for (V containedNode : this.sccs.getPartition(root)) {
+            IMemoryView<V> sourceNodes = this.gds.getSourceNodes(containedNode);
+            for (V source : sourceNodes.distinctValues()) {
+                sourceSCCs.add(this.sccs.find(source));
+            }
+        }
+
+        return sourceSCCs;
+    }
+
+    /**
+     * Returns true if the SCC represented by the given root node has incoming edges in the reduced graph,
+     * false otherwise (if this SCC is a source in the reduced graph).
+     *
+     * @param root the root node of an SCC
+     * @return true if it has incoming edges, false otherwise
+     * @since 1.6
+     */
+    public boolean hasIncomingEdges(final V root) {
+        for (final V containedNode : this.sccs.getPartition(root)) {
+            final IMemoryView<V> sourceNodes = this.gds.getSourceNodes(containedNode);
+            for (final V source : sourceNodes.distinctValues()) {
+                final V otherRoot = this.sccs.find(source);
+                if (!Objects.equals(root, otherRoot)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Return the SCCs which are reachable from the SCC represented by the root node. Note that an SCC can be present
+     * multiple times in the returned list (multiple edges between the two SCCs).
+     *
+     * @param root
+     * @return the list of reachable target SCCs
+     */
+    private List<V> getTargetSCCsOfSCC(V root) {
+        List<V> targetSCCs = new ArrayList<V>();
+
+        for (V containedNode : this.sccs.getPartition(root)) {
+            IMemoryView<V> targetNodes = this.gds.getTargetNodes(containedNode);
+            for (V target : targetNodes.distinctValues()) {
+                targetSCCs.add(this.sccs.find(target));
+            }
+        }
+
+        return targetSCCs;
+    }
+
+    /**
+     * Returns true if the SCC represented by the given root node has outgoing edges in the reduced graph,
+     * false otherwise (if this SCC is a sink in the reduced graph).
+     *
+     * @param root the root node of an SCC
+     * @return true if it has outgoing edges, false otherwise
+     * @since 1.6
+     */
+    public boolean hasOutgoingEdges(V root) {
+        for (final V containedNode : this.sccs.getPartition(root)) {
+            final IMemoryView<V> targetNodes = this.gds.getTargetNodes(containedNode);
+            for (final V target : targetNodes.distinctValues()) {
+                final V otherRoot = this.sccs.find(target);
+                if (!Objects.equals(root, otherRoot)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public void dispose() {
+        gds.detachObserver(this);
+        counting.dispose();
+    }
+
+    /**
+     * Call this method to notify the observers of the transitive closure relation. The tuples used in the notification
+     * will be the Descartes product of the two sets given.
+     *
+     * @param sources
+     *            the source nodes
+     * @param targets
+     *            the target nodes
+     * @param direction
+     */
+    protected void notifyTcObservers(Set<V> sources, Set<V> targets, Direction direction) {
+        for (V s : sources) {
+            for (V t : targets) {
+                notifyTcObservers(s, t, direction);
+            }
+        }
+    }
+
+    private void notifyTcObservers(V source, V target, Direction direction) {
+        for (ITcObserver<V> observer : observers) {
+            if (direction == Direction.INSERT) {
+                observer.tupleInserted(source, target);
+            }
+            if (direction == Direction.DELETE) {
+                observer.tupleDeleted(source, target);
+            }
+        }
+    }
+
+    /**
+     * Returns the node that is selected as the representative of the SCC containing the argument.
+     * @since 1.6
+     */
+    public V getRepresentative(V node) {
+        return sccs.find(node);
+    }
+
+    public Set<Tuple<V>> getTcRelation() {
+        Set<Tuple<V>> resultSet = new HashSet<Tuple<V>>();
+
+        for (V sourceRoot : sccs.getPartitionHeads()) {
+            Set<V> sources = sccs.getPartition(sourceRoot);
+            if (sources.size() > 1 || GraphHelper.getEdgeCount(sources.iterator().next(), gds) == 1) {
+                for (V source : sources) {
+                    for (V target : sources) {
+                        resultSet.add(new Tuple<V>(source, target));
+                    }
+                }
+            }
+
+            Set<V> reachableTargets = counting.getAllReachableTargets(sourceRoot);
+            if (reachableTargets != null) {
+                for (V targetRoot : reachableTargets) {
+                    for (V source : sources) {
+                        for (V target : sccs.getPartition(targetRoot)) {
+                            resultSet.add(new Tuple<V>(source, target));
+                        }
+                    }
+                }
+            }
+        }
+
+        return resultSet;
+    }
+
+    public boolean isIsolated(V node) {
+        IMemoryView<V> targets = gds.getTargetNodes(node);
+        IMemoryView<V> sources = gds.getSourceNodes(node);
+        return targets.isEmpty() && sources.isEmpty();
+    }
+
+    @Override
+    public IGraphPathFinder<V> getPathFinder() {
+        return new DFSPathFinder<V>(gds, this);
+    }
+
+    /**
+     * The graph of SCCs; each SCC is represented by its representative node (see {@link #getRepresentative(Object)})
+     * @since 1.6
+     */
+    public Graph<V> getReducedGraph() {
+        return reducedGraph;
+    }
+
+    private static <V> Set<V> createSetNullTolerant(Set<V> initial) {
+        if (initial != null)
+            return CollectionsFactory.createSet(initial);
+        else
+            return CollectionsFactory.createSet();
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/DFSPathFinder.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/DFSPathFinder.java
new file mode 100644
index 00000000..51017b1a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/DFSPathFinder.java
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Abel Hegedus and IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+/**
+ * A depth-first search implementation of the {@link IGraphPathFinder}.
+ * 
+ * TODO use ITC to filter nodes that must be traversed, instead of checks
+ * 
+ * @author Abel Hegedus
+ * 
+ * @param <V>
+ *            the node type of the graph
+ */
+public class DFSPathFinder<V> implements IGraphPathFinder<V> {
+
+    private IGraphDataSource<V> graph;
+    private ITcDataSource<V> itc;
+
+    public DFSPathFinder(IGraphDataSource<V> graph, ITcDataSource<V> itc) {
+        this.graph = graph;
+        this.itc = itc;
+    }
+
+    @Override
+    public Iterable<Deque<V>> getAllPaths(V sourceNode, V targetNode) {
+        Set<V> endNodes = new HashSet<V>();
+        endNodes.add(targetNode);
+        return getAllPathsToTargets(sourceNode, endNodes);
+    }
+
+    @Override
+    public Iterable<Deque<V>> getAllPathsToTargets(V sourceNode, Set<V> targetNodes) {
+        List<Deque<V>> paths = new ArrayList<Deque<V>>();
+        Deque<V> visited = new LinkedList<V>();
+        Set<V> reachableTargets = new HashSet<V>();
+        for (V targetNode : targetNodes) {
+            if (itc.isReachable(sourceNode, targetNode)) {
+                reachableTargets.add(targetNode);
+            }
+        }
+        if (!reachableTargets.isEmpty()) {
+            return paths;
+        }
+        visited.add(sourceNode);
+        return getPaths(paths, visited, reachableTargets);
+    }
+
+    protected Iterable<Deque<V>> getPaths(List<Deque<V>> paths, Deque<V> visited, Set<V> targetNodes) {
+        IMemoryView<V> nodes = graph.getTargetNodes(visited.getLast());
+        // examine adjacent nodes
+        for (V node : nodes.distinctValues()) {
+            if (visited.contains(node)) {
+                continue;
+            }
+            if (targetNodes.contains(node)) {
+                visited.add(node);
+                // clone visited LinkedList
+                Deque<V> visitedClone = new LinkedList<V>(visited);
+                paths.add(visitedClone);
+                visited.removeLast();
+                break;
+            }
+        }
+
+        // in breadth-first, recursion needs to come after visiting connected nodes
+        for (V node : nodes.distinctValues()) {
+            if (visited.contains(node) || targetNodes.contains(node)) {
+                continue;
+            }
+            boolean canReachTarget = false;
+            for (V target : targetNodes) {
+                if (itc.isReachable(node, target)) {
+                    canReachTarget = true;
+                    break;
+                }
+            }
+            if (canReachTarget) {
+                visited.addLast(node);
+                getPaths(paths, visited, targetNodes);
+                visited.removeLast();
+            }
+        }
+
+        return paths;
+    }
+
+    public String printPaths(List<Deque<V>> paths) {
+        StringBuilder sb = new StringBuilder();
+        for (Deque<V> visited : paths) {
+            sb.append("Path: ");
+            for (V node : visited) {
+                sb.append(node);
+                sb.append(" --> ");
+            }
+            sb.append("\n");
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public Deque<V> getPath(V sourceNode, V targetNode) {
+        // TODO optimize
+        Iterable<Deque<V>> allPaths = getAllPaths(sourceNode, targetNode);
+        Iterator<Deque<V>> pathIterator = allPaths.iterator();
+        return pathIterator.hasNext() ? pathIterator.next() : new LinkedList<V>();
+    }
+
+    @Override
+    public Iterable<Deque<V>> getShortestPaths(V sourceNode, V targetNode) {
+        // TODO optimize
+        Iterable<Deque<V>> allPaths = getAllPaths(sourceNode, targetNode);
+        List<Deque<V>> shortestPaths = new ArrayList<Deque<V>>();
+        int shortestPathLength = -1;
+        for (Deque<V> path : allPaths) {
+            int pathLength = path.size();
+            if (shortestPathLength == -1 || pathLength < shortestPathLength) {
+                shortestPaths.clear();
+                shortestPathLength = pathLength;
+            }
+            if (pathLength == shortestPathLength) {
+                shortestPaths.add(path);
+            }
+        }
+        return shortestPaths;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Edge.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Edge.java
new file mode 100644
index 00000000..cf68d36a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Edge.java
@@ -0,0 +1,38 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+public class Edge<V> {
+    private V source;
+    private V target;
+
+    public Edge(V source, V target) {
+        super();
+        this.source = source;
+        this.target = target;
+    }
+
+    public V getSource() {
+        return source;
+    }
+
+    public void setSource(V source) {
+        this.source = source;
+    }
+
+    public V getTarget() {
+        return target;
+    }
+
+    public void setTarget(V target) {
+        this.target = target;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/GraphHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/GraphHelper.java
new file mode 100644
index 00000000..194e979b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/GraphHelper.java
@@ -0,0 +1,173 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.graphimpl.Graph;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+/**
+ * Utility class for graph related operations.
+ * 
+ * @author Tamas Szabo
+ */
+public class GraphHelper {
+
+    private GraphHelper() {/*Utility class constructor*/}
+    
+    /**
+     * Returns the subgraph from the given {@link IBiDirectionalGraphDataSource} which contains the given set of nodes.
+     * 
+     * @param nodesInSubGraph
+     *            the nodes that are present in the subgraph
+     * @param graphDataSource
+     *            the graph data source for the original graph
+     * @return the subgraph associated to the given nodes
+     */
+    public static <V> Graph<V> getSubGraph(Collection<V> nodesInSubGraph,
+            IBiDirectionalGraphDataSource<V> graphDataSource) {
+        Graph<V> g = new Graph<V>();
+        if (nodesInSubGraph != null) {
+            for (V node : nodesInSubGraph) {
+                g.insertNode(node);
+            }
+
+            for (V node : nodesInSubGraph) {
+                IMemoryView<V> sources = graphDataSource.getSourceNodes(node);
+                for (Entry<V, Integer> entry : sources.entriesWithMultiplicities()) {
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        V s = entry.getKey();
+                        if (nodesInSubGraph.contains(s)) {
+                            g.insertEdge(s, node);
+                        }
+                    }
+                }
+            }
+        }
+
+        return g;
+    }
+
+    /**
+     * Constructs a path between source and target in the given graph. Both the {@link IGraphDataSource} and the set of
+     * nodes are used, this way it is possible to construct a path in a given subgraph.
+     * 
+     * The returned {@link List} contains the nodes along the path (this means that there is an edge in the graph
+     * between two consecutive nodes). A self loop (one edge) is indicated with the source node being present two times
+     * in the returned {@link List}.
+     * 
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @param nodesInGraph
+     *            the nodes that are present in the subgraph
+     * @param graphDataSource
+     *            the graph data source
+     * @return the path between the two nodes
+     */
+    public static <V> List<V> constructPath(V source, V target, Set<V> nodesInGraph,
+            IGraphDataSource<V> graphDataSource) {
+        Set<V> visitedNodes = new HashSet<V>();
+        List<V> path = new ArrayList<V>();
+
+        visitedNodes.add(source);
+        path.add(source);
+        V act = source;
+
+        // if source and target are the same node
+        if (source.equals(target) && graphDataSource.getTargetNodes(source).containsNonZero(target)) {
+            // the node will be present in the path two times
+            path.add(source);
+            return path;
+        } else {
+            while (act != null) {
+                V nextNode = getNextNodeToVisit(act, graphDataSource, nodesInGraph, visitedNodes);
+                if (nextNode == null && path.size() > 1) {
+                    // needs to backtrack along path
+                    // remove the last element in the path because we can't go
+                    // anywhere from there
+                    path.remove(path.size() - 1);
+                    while (nextNode == null && path.size() > 0) {
+                        V lastPathElement = path.get(path.size() - 1);
+                        nextNode = getNextNodeToVisit(lastPathElement, graphDataSource, nodesInGraph, visitedNodes);
+                        if (nextNode == null) {
+                            path.remove(path.size() - 1);
+                        }
+                    }
+                }
+
+                if (nextNode != null) {
+                    visitedNodes.add(nextNode);
+                    path.add(nextNode);
+                    if (nextNode.equals(target)) {
+                        return path;
+                    }
+                }
+                act = nextNode;
+            }
+            return null;
+        }
+    }
+
+    private static <V> V getNextNodeToVisit(V act, IGraphDataSource<V> graphDataSource, Set<V> nodesInSubGraph,
+            Set<V> visitedNodes) {
+        IMemoryView<V> targetNodes = graphDataSource.getTargetNodes(act);
+        for (Entry<V, Integer> entry : targetNodes.entriesWithMultiplicities()) {
+            for (int i = 0; i < entry.getValue(); i++) {
+                V node = entry.getKey();
+                if (nodesInSubGraph.contains(node) && !visitedNodes.contains(node)) {
+                    return node;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns the number of self-loop edges for the given node.
+     * 
+     * @param node
+     *            the node
+     * @param graphDataSource
+     *            the graph data source
+     * @return the number of self-loop edges
+     */
+    public static <V> int getEdgeCount(V node, IGraphDataSource<V> graphDataSource) {
+        return getEdgeCount(node, node, graphDataSource);
+    }
+
+    /**
+     * Returns the number of edges between the given source and target nodes.
+     * 
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @param graphDataSource
+     *            the graph data source
+     * @return the number of parallel edges between the two nodes
+     */
+    public static <V> int getEdgeCount(V source, V target, IGraphDataSource<V> graphDataSource) {
+        Integer count = graphDataSource.getTargetNodes(source).getCount(target);
+        if (count == null) {
+            return 0;
+        } else {
+            return count;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/IGraphPathFinder.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/IGraphPathFinder.java
new file mode 100644
index 00000000..cebb09c8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/IGraphPathFinder.java
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+import java.util.Deque;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+
+/**
+ * The path finder provides methods for retrieving paths in a graph between a source node and one or more target nodes.  
+ * Use {@link ITcDataSource#getPathFinder()} for instantiating.
+ * 
+ * @author Abel Hegedus
+ *
+ * @param <V> the node type of the graph
+ */
+public interface IGraphPathFinder<V> {
+
+    /**
+     * Returns an arbitrary path from the source node to the target node (if such exists). If there is no path
+     * between them, an empty collection is returned.
+     * 
+     * @param sourceNode the source node of the path
+     * @param targetNode the target node of the path
+     * @return the path from the source to the target, or empty collection if target is not reachable from source.
+     */
+    Deque<V> getPath(V sourceNode, V targetNode);
+
+    /**
+     * Returns the collection of shortest paths from the source node to the target node (if such exists). If there is no path
+     * between them, an empty collection is returned.
+     * 
+     * @param sourceNode the source node of the path
+     * @param targetNode the target node of the path
+     * @return the collection of shortest paths from the source to the target, or empty collection if target is not reachable from source.
+     */
+    Iterable<Deque<V>> getShortestPaths(V sourceNode, V targetNode);
+    
+    /**
+     * Returns the collection of paths from the source node to the target node (if such exists). If there is no path
+     * between them, an empty collection is returned.
+     * 
+     * @param sourceNode the source node of the path
+     * @param targetNode the target node of the path
+     * @return the collection of paths from the source to the target, or empty collection if target is not reachable from source.
+     */
+    Iterable<Deque<V>> getAllPaths(V sourceNode, V targetNode);
+
+    /**
+     * Returns the collection of paths from the source node to any of the target nodes (if such exists). If there is no path
+     * between them, an empty collection is returned.
+     * 
+     * @param sourceNode the source node of the path
+     * @param targetNodes the set of target nodes of the paths
+     * @return the collection of paths from the source to any of the targets, or empty collection if neither target is reachable from source.
+     */
+    Iterable<Deque<V>> getAllPathsToTargets(V sourceNode, Set<V> targetNodes);
+
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/ITcRelation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/ITcRelation.java
new file mode 100644
index 00000000..a41ff6c7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/ITcRelation.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+import java.util.Set;
+
+public interface ITcRelation<V> {
+
+    /**
+     * Returns the starting nodes from a transitive closure relation.
+     * 
+     * @return the set of starting nodes
+     */
+    public Set<V> getTupleStarts();
+
+    /**
+     * Returns the set of nodes that are reachable from the given node.
+     * 
+     * @param start
+     *            the starting node
+     * @return the set of reachable nodes
+     */
+    public Set<V> getTupleEnds(V start);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Tuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Tuple.java
new file mode 100644
index 00000000..a2d54a59
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/Tuple.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc;
+
+public class Tuple<V> {
+
+    private V source;
+    private V target;
+
+    public Tuple(V source, V target) {
+        super();
+        this.source = source;
+        this.target = target;
+    }
+
+    public V getSource() {
+        return source;
+    }
+
+    public void setSource(V source) {
+        this.source = source;
+    }
+
+    public V getTarget() {
+        return target;
+    }
+
+    public void setTarget(V target) {
+        this.target = target;
+    }
+
+    @Override
+    public String toString() {
+        return "(" + source.toString() + "," + target.toString() + ")";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (o instanceof Tuple) {
+            Tuple<?> t = (Tuple<?>) o;
+
+            if (t.getSource().equals(this.source) && t.getTarget().equals(this.target)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return source.hashCode() + target.hashCode();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/bfs/BFS.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/bfs/BFS.java
new file mode 100644
index 00000000..798f31d2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/bfs/BFS.java
@@ -0,0 +1,151 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.bfs;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+
+public class BFS<V> {
+
+    private BFS() {/*Utility class constructor*/}
+    
+    /**
+     * Performs a breadth first search on the given graph to determine whether source is reachable from target.
+     * 
+     * @param <V>
+     *            the type parameter of the nodes in the graph
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @param graph
+     *            the graph data source
+     * @return true if source is reachable from target, false otherwise
+     */
+    public static <V> boolean isReachable(V source, V target, IGraphDataSource<V> graph) {
+        List<V> nodeQueue = new ArrayList<V>();
+        Set<V> visited = new HashSet<V>();
+
+        nodeQueue.add(source);
+        visited.add(source);
+
+        boolean ret = _isReachable(target, graph, nodeQueue, visited);
+        return ret;
+    }
+
+    private static <V> boolean _isReachable(V target, IGraphDataSource<V> graph, List<V> nodeQueue, Set<V> visited) {
+
+        while (!nodeQueue.isEmpty()) {
+            V node = nodeQueue.remove(0);
+            for (V t : graph.getTargetNodes(node).distinctValues()){
+                if (t.equals(target)) {
+                    return true;
+                }
+                if (!visited.contains(t)) {
+                    visited.add(t);
+                    nodeQueue.add(t);
+                }
+            }
+        }
+        return false;
+    }
+
+    public static <V> Set<V> reachableSources(IBiDirectionalGraphDataSource<V> graph, V target) {
+        Set<V> retSet = new HashSet<V>();
+        retSet.add(target);
+        List<V> nodeQueue = new ArrayList<V>();
+        nodeQueue.add(target);
+
+        _reachableSources(graph, nodeQueue, retSet);
+
+        return retSet;
+    }
+
+    private static <V> void _reachableSources(IBiDirectionalGraphDataSource<V> graph, List<V> nodeQueue,
+            Set<V> retSet) {
+        while (!nodeQueue.isEmpty()) {
+            V node = nodeQueue.remove(0);
+            for (V _node : graph.getSourceNodes(node).distinctValues()) {
+                if (!retSet.contains(_node)) {
+                    retSet.add(_node);
+                    nodeQueue.add(_node);
+                }
+            }
+        }
+    }
+
+    public static <V> Set<V> reachableTargets(IGraphDataSource<V> graph, V source) {
+        Set<V> retSet = new HashSet<V>();
+        retSet.add(source);
+        List<V> nodeQueue = new ArrayList<V>();
+        nodeQueue.add(source);
+
+        _reachableTargets(graph, nodeQueue, retSet);
+
+        return retSet;
+    }
+
+    private static <V> void _reachableTargets(IGraphDataSource<V> graph, List<V> nodeQueue, Set<V> retSet) {
+        while (!nodeQueue.isEmpty()) {
+            V node = nodeQueue.remove(0);
+
+            for (V _node : graph.getTargetNodes(node).distinctValues()) {
+
+                if (!retSet.contains(_node)) {
+                    retSet.add(_node);
+                    nodeQueue.add(_node);
+                }
+            }
+        }
+    }
+
+    /**
+     * Performs a breadth first search on the given graph and collects all the nodes along the path from source to
+     * target if such path exists.
+     * 
+     * @param <V>
+     *            the type parameter of the nodes in the graph
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @param graph
+     *            the graph data source
+     * @return the set of nodes along the path
+     */
+    public static <V> Set<V> collectNodesAlongPath(V source, V target, IGraphDataSource<V> graph) {
+        Set<V> path = new HashSet<V>();
+        _collectNodesAlongPath(source, target, graph, path);
+        return path;
+    }
+
+    private static <V> boolean _collectNodesAlongPath(V node, V target, IGraphDataSource<V> graph, Set<V> path) {
+
+        boolean res = false;
+
+        // end recursion
+        if (node.equals(target)) {
+            path.add(node);
+            return true;
+        } else {
+            for (V _nodeT : graph.getTargetNodes(node).distinctValues()) {
+                res = (_collectNodesAlongPath(_nodeT, target, graph, path)) || res;
+            }
+            if (res)
+                path.add(node);
+            return res;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/dfs/DFSAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/dfs/DFSAlg.java
new file mode 100644
index 00000000..c8d25c4e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/dfs/DFSAlg.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.dfs;
+
+import java.util.HashMap;
+
+import tools.refinery.viatra.runtime.base.itc.alg.dred.DRedTcRelation;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+
+public class DFSAlg<V> implements IGraphObserver<V> {
+
+    private IGraphDataSource<V> gds;
+    private DRedTcRelation<V> tc;
+    private int[] visited;
+    private HashMap<V, Integer> nodeMap;
+
+    public DFSAlg(IGraphDataSource<V> gds) {
+        this.gds = gds;
+        this.tc = new DRedTcRelation<V>();
+        gds.attachObserver(this);
+        deriveTc();
+    }
+
+    private void deriveTc() {
+        tc.clear();
+
+        this.visited = new int[gds.getAllNodes().size()];
+        nodeMap = new HashMap<V, Integer>();
+
+        int j = 0;
+        for (V n : gds.getAllNodes()) {
+            nodeMap.put(n, j);
+            j++;
+        }
+
+        for (V n : gds.getAllNodes()) {
+            oneDFS(n, n);
+            initVisitedArray();
+        }
+    }
+
+    private void initVisitedArray() {
+        for (int i = 0; i < visited.length; i++)
+            visited[i] = 0;
+    }
+
+    private void oneDFS(V act, V source) {
+
+        if (!act.equals(source)) {
+            tc.addTuple(source, act);
+        }
+
+        visited[nodeMap.get(act)] = 1;
+
+        for (V t : gds.getTargetNodes(act).distinctValues()) {
+            if (visited[nodeMap.get(t)] == 0) {
+                oneDFS(t, source);
+            }
+        }
+    }
+
+    public DRedTcRelation<V> getTcRelation() {
+        return this.tc;
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        deriveTc();
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        deriveTc();
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+        deriveTc();
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        deriveTc();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/PKAlg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/PKAlg.java
new file mode 100644
index 00000000..c99a48ab
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/PKAlg.java
@@ -0,0 +1,179 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.scc;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalWrapper;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+
+public class PKAlg<V> implements IGraphObserver<V> {
+
+    /**
+     * Maps the nodes to their indicies.
+     */
+    private Map<V, Integer> node2index;
+    private Map<Integer, V> index2node;
+    private Map<V, Boolean> node2mark;
+
+    /**
+     * Maps the index of a node to the index in the topsort.
+     */
+    private Map<Integer, Integer> index2topsort;
+    private Map<Integer, Integer> topsort2index;
+
+    /**
+     * Index associated to the inserted nodes (incrementing with every insertion).
+     */
+    private int index;
+
+    /**
+     * Index within the topsort for the target node when edge insertion occurs.
+     */
+    private int lower_bound;
+
+    /**
+     * Index within the topsort for the source node when edge insertion occurs.
+     */
+    private int upper_bound;
+
+    private List<V> RF;
+    private List<V> RB;
+    private IBiDirectionalGraphDataSource<V> gds;
+
+    public PKAlg(IGraphDataSource<V> gds) {
+        if (gds instanceof IBiDirectionalGraphDataSource<?>) {
+            this.gds = (IBiDirectionalGraphDataSource<V>) gds;
+        } else {
+            this.gds = new IBiDirectionalWrapper<V>(gds);
+        }
+
+        node2mark = new HashMap<V, Boolean>();
+        node2index = new HashMap<V, Integer>();
+        index2node = new HashMap<Integer, V>();
+        index2topsort = new HashMap<Integer, Integer>();
+        topsort2index = new HashMap<Integer, Integer>();
+        index = 0;
+
+        gds.attachObserver(this);
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+
+        RF = new ArrayList<V>();
+        RB = new ArrayList<V>();
+
+        lower_bound = index2topsort.get(node2index.get(target));
+        upper_bound = index2topsort.get(node2index.get(source));
+
+        if (lower_bound < upper_bound) {
+            dfsForward(target);
+            dfsBackward(source);
+            reorder();
+        }
+    }
+
+    private List<Integer> getIndicies(List<V> list) {
+        List<Integer> indicies = new ArrayList<Integer>();
+
+        for (V n : list)
+            indicies.add(index2topsort.get(node2index.get(n)));
+
+        return indicies;
+    }
+
+    private void reorder() {
+
+        Collections.reverse(RB);
+
+        // azon csomopontok indexei amelyek sorrendje nem jo
+        List<Integer> L = getIndicies(RF);
+        L.addAll(getIndicies(RB));
+        Collections.sort(L);
+
+        for (int i = 0; i < RB.size(); i++) {
+            index2topsort.put(node2index.get(RB.get(i)), L.get(i));
+            topsort2index.put(L.get(i), node2index.get(RB.get(i)));
+        }
+
+        for (int i = 0; i < RF.size(); i++) {
+            index2topsort.put(node2index.get(RF.get(i)), L.get(i + RB.size()));
+            topsort2index.put(L.get(i + RB.size()), node2index.get(RF.get(i)));
+        }
+    }
+
+    @SuppressWarnings("unused")
+    private List<V> getTopSort() {
+        List<V> topsort = new ArrayList<V>();
+
+        for (int i : topsort2index.values()) {
+            topsort.add(index2node.get(i));
+        }
+
+        return topsort;
+    }
+
+    private void dfsBackward(V node) {
+        node2mark.put(node, true);
+        RB.add(node);
+
+        for (V sn : gds.getSourceNodes(node).distinctValues()) {
+            int top_id = index2topsort.get(node2index.get(sn));
+
+            if (!node2mark.get(sn) && lower_bound < top_id)
+                dfsBackward(sn);
+        }
+    }
+
+    private void dfsForward(V node) {
+        node2mark.put(node, true);
+        RF.add(node);
+
+        for (V tn : gds.getTargetNodes(node).distinctValues()) {
+            int top_id = index2topsort.get(node2index.get(tn));
+
+            if (top_id == upper_bound)
+                System.out.println("!!!Cycle detected!!!");
+            else if (!node2mark.get(tn) && top_id < upper_bound)
+                dfsForward(tn);
+        }
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        // Edge deletion does not affect topsort
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+        node2mark.put(n, false);
+        node2index.put(n, index);
+        index2node.put(index, n);
+        index2topsort.put(index, index);
+        topsort2index.put(index, index);
+        index++;
+    }
+
+    @Override
+    public void nodeDeleted(V n) {
+        node2mark.remove(n);
+        int node_id = node2index.remove(n);
+        index2node.remove(node_id);
+        int top_id = index2topsort.remove(node_id);
+        topsort2index.remove(top_id);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCC.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCC.java
new file mode 100644
index 00000000..8915998b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCC.java
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.scc;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.Stack;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * Efficient algorithms to compute the Strongly Connected Components in a directed graph.
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V>
+ *            the type parameter of the nodes in the graph
+ */
+public class SCC<V> {
+
+    private SCC() {/*Utility class constructor*/}
+    
+    public static long sccId = 0;
+
+    /**
+     * Computes the SCCs for the given graph and returns them as a multiset. (Iterative version of Tarjan's algorithm)
+     * 
+     * @param g
+     *            the directed graph data source
+     * @return the set of SCCs
+     */
+    public static <V> SCCResult<V> computeSCC(IGraphDataSource<V> g) {
+        int index = 0;
+        Set<Set<V>> ret = new HashSet<Set<V>>();
+
+        // stores the lowlink and index information for the given node
+        Map<V, SCCProperty> nodeMap = CollectionsFactory.createMap();
+
+        // stores all target nodes of a given node - the list will be modified
+        Map<V, Set<V>> targetNodeMap = CollectionsFactory.createMap();
+
+        // stores those target nodes for a given node which have not been visited
+        Map<V, Set<V>> notVisitedMap = CollectionsFactory.createMap();
+
+        // stores the nodes during the traversal
+        Stack<V> nodeStack = new Stack<V>();
+
+        // stores the nodes which belong to an scc (there can be many sccs in the stack at the same time)
+        Stack<V> sccStack = new Stack<V>();
+
+        boolean sink = false, finishedTraversal = true;
+
+        // initialize all nodes with 0 index and 0 lowlink
+        Set<V> allNodes = g.getAllNodes();
+        for (V n : allNodes) {
+            nodeMap.put(n, new SCCProperty(0, 0));
+        }
+
+        for (V n : allNodes) {
+            // if the node has not been visited yet
+            if (nodeMap.get(n).getIndex() == 0) {
+                nodeStack.push(n);
+
+                while (!nodeStack.isEmpty()) {
+                    V currentNode = nodeStack.peek();
+                    sink = false;
+                    finishedTraversal = false;
+                    SCCProperty prop = nodeMap.get(currentNode);
+
+                    if (nodeMap.get(currentNode).getIndex() == 0) {
+                        index++;
+                        sccStack.push(currentNode);
+                        prop.setIndex(index);
+                        prop.setLowlink(index);
+
+                        notVisitedMap.put(currentNode, new HashSet<V>());
+
+                        // storing the target nodes of the actual node
+                        if (g.getTargetNodes(currentNode) != null) {
+                            Set<V> targets = g.getTargetNodes(currentNode).distinctValues();
+                            targetNodeMap.put(currentNode, CollectionsFactory.createSet(targets));
+                        }
+                    }
+
+                    if (targetNodeMap.get(currentNode) != null) {
+
+                        // remove node from stack, the exploration of its children has finished
+                        if (targetNodeMap.get(currentNode).size() == 0) {
+                            targetNodeMap.remove(currentNode);
+
+                            nodeStack.pop();
+
+                            for (V targetNode : g.getTargetNodes(currentNode).distinctValues()) {
+                                if (notVisitedMap.get(currentNode).contains(targetNode)) {
+                                    prop.setLowlink(Math.min(prop.getLowlink(), nodeMap.get(targetNode).getLowlink()));
+                                } else if (sccStack.contains(targetNode)) {
+                                    prop.setLowlink(Math.min(prop.getLowlink(), nodeMap.get(targetNode).getIndex()));
+                                }
+                            }
+
+                            finishedTraversal = true;
+                        } else {
+                            V targetNode = targetNodeMap.get(currentNode).iterator().next();
+                            targetNodeMap.get(currentNode).remove(targetNode);
+                            // if the targetNode has not yet been visited push it to the stack
+                            // and mark it in the notVisitedMap
+                            if (nodeMap.get(targetNode).getIndex() == 0) {
+                                notVisitedMap.get(currentNode).add(targetNode);
+                                nodeStack.add(targetNode);
+                            }
+                        }
+                    }
+                    // if currentNode has no target nodes
+                    else {
+                        nodeStack.pop();
+                        sink = true;
+                    }
+
+                    // create scc if node is a sink or an scc has been found
+                    if ((sink || finishedTraversal) && (prop.getLowlink() == prop.getIndex())) {
+                        Set<V> sc = new HashSet<V>();
+                        V targetNode = null;
+
+                        do {
+                            targetNode = sccStack.pop();
+                            sc.add(targetNode);
+                        } while (!targetNode.equals(currentNode));
+
+                        ret.add(sc);
+                    }
+                }
+            }
+        }
+
+        return new SCCResult<V>(ret, g);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCProperty.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCProperty.java
new file mode 100644
index 00000000..b26e3d37
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCProperty.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.scc;
+
+public class SCCProperty {
+    private int index;
+    private int lowlink;
+
+    public SCCProperty(int index, int lowlink) {
+        super();
+        this.index = index;
+        this.lowlink = lowlink;
+    }
+
+    public int getIndex() {
+        return index;
+    }
+
+    public void setIndex(int index) {
+        this.index = index;
+    }
+
+    public int getLowlink() {
+        return lowlink;
+    }
+
+    public void setLowlink(int lowlink) {
+        this.lowlink = lowlink;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCResult.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCResult.java
new file mode 100644
index 00000000..fde59d3b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/scc/SCCResult.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.scc;
+
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+
+public class SCCResult<V> {
+
+    private Set<Set<V>> sccs;
+    private IGraphDataSource<V> gds;
+
+    public SCCResult(Set<Set<V>> sccs, IGraphDataSource<V> gds) {
+        this.sccs = sccs;
+        this.gds = gds;
+    }
+
+    public Set<Set<V>> getSccs() {
+        return sccs;
+    }
+
+    public int getSCCCount() {
+        return sccs.size();
+    }
+
+    public double getAverageNodeCount() {
+        double a = 0;
+
+        for (Set<V> s : sccs) {
+            a += s.size();
+        }
+
+        return a / sccs.size();
+    }
+
+    public double getAverageEdgeCount() {
+        long edgeSum = 0;
+
+        for (Set<V> scc : sccs) {
+            for (V source : scc) {
+                for (Entry<V, Integer> entry : gds.getTargetNodes(source).entriesWithMultiplicities()) {
+                    if (scc.contains(entry.getKey())) {
+                        edgeSum += entry.getValue();
+                    }
+                }
+            }
+        }
+
+        return (double) edgeSum / (double) sccs.size();
+    }
+
+    public int getBiggestSCCSize() {
+        int max = 0;
+
+        for (Set<V> scc : sccs) {
+            if (scc.size() > max)
+                max = scc.size();
+        }
+
+        return max;
+    }
+
+    public long getSumOfSquares() {
+        long sum = 0;
+
+        for (Set<V> scc : sccs) {
+            sum += scc.size() * scc.size();
+        }
+
+        return sum;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/topsort/TopologicalSorting.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/topsort/TopologicalSorting.java
new file mode 100644
index 00000000..dd18e6c8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/misc/topsort/TopologicalSorting.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.alg.misc.topsort;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import java.util.Stack;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+
+/**
+ * @since 1.6
+ */
+public class TopologicalSorting {
+
+    private TopologicalSorting() {/*Utility class constructor*/}
+    
+    private static final class Pair<T> {
+        public T element;
+        public boolean isParent;
+
+        public Pair(final T element, final boolean isParent) {
+            this.element = element;
+            this.isParent = isParent;
+        }
+    }
+
+    /**
+     * Returns a topological ordering for the given graph data source. 
+     * Output format: if there is an a -> b (transitive) reachability, then node <code>a</code> will come before node <code>b</code> in the resulting list.  
+     * 
+     * @param gds the graph data source
+     * @return a topological ordering
+     */
+    public static <T> List<T> compute(final IGraphDataSource<T> gds) {
+        final Set<T> visited = new HashSet<T>();
+        final LinkedList<T> result = new LinkedList<T>();
+        final Stack<Pair<T>> dfsStack = new Stack<Pair<T>>();
+
+        for (final T node : gds.getAllNodes()) {
+            if (!visited.contains(node)) {
+                dfsStack.push(new Pair<T>(node, false));                
+            }
+            
+            while (!dfsStack.isEmpty()) {
+                final Pair<T> head = dfsStack.pop();
+                final T source = head.element;
+                
+                if (head.isParent) {
+                    // we have already seen source, push it to the resulting stack
+                    result.addFirst(source);
+                } else {
+                    // first time we see source, continue with its children
+                    visited.add(source);
+                    dfsStack.push(new Pair<T>(source, true));
+                    
+                    for (final T target : gds.getTargetNodes(source).distinctValues()) {
+                        if (!visited.contains(target)) {
+                            dfsStack.push(new Pair<T>(target, false));
+                        }
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeElectionAlgorithm.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeElectionAlgorithm.java
new file mode 100644
index 00000000..51015404
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeElectionAlgorithm.java
@@ -0,0 +1,140 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.base.itc.alg.representative;
+
+import tools.refinery.viatra.runtime.base.itc.graphimpl.Graph;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class RepresentativeElectionAlgorithm implements IGraphObserver<Object> {
+        protected final Graph<Object> graph;
+        protected final Map<Object, Object> representatives = new HashMap<>();
+        protected final Map<Object, Set<Object>> components = new HashMap<>();
+        private RepresentativeObserver observer;
+
+        protected RepresentativeElectionAlgorithm(Graph<Object> graph) {
+                this.graph = graph;
+                initializeComponents();
+                graph.attachObserver(this);
+        }
+
+        protected abstract void initializeComponents();
+
+        protected void initializeSet(Set<Object> set) {
+                var iterator = set.iterator();
+                if (!iterator.hasNext()) {
+                        // Set is empty.
+                        return;
+                }
+                var representative = iterator.next();
+                for (var node : set) {
+                        var oldRepresentative = representatives.put(node, representative);
+                        if (oldRepresentative != null && !representative.equals(oldRepresentative)) {
+                                throw new IllegalStateException("Node %s is already in a set represented by %s, cannot add it to %s"
+                                                .formatted(node, oldRepresentative, set));
+                        }
+                }
+                components.put(representative, set);
+        }
+
+        protected void merge(Object leftRepresentative, Object rightRepresentative) {
+                if (leftRepresentative.equals(rightRepresentative)) {
+                        return;
+                }
+                var leftSet = getComponent(leftRepresentative);
+                var rightSet = getComponent(rightRepresentative);
+                if (leftSet.size() < rightSet.size()) {
+                        merge(rightRepresentative, rightSet, leftRepresentative, leftSet);
+                } else {
+                        merge(leftRepresentative, leftSet, rightRepresentative, rightSet);
+                }
+        }
+
+        private void merge(Object preservedRepresentative, Set<Object> preservedSet, Object removedRepresentative,
+                                           Set<Object> removedSet) {
+                components.remove(removedRepresentative);
+                for (var node : removedSet) {
+                        representatives.put(node, preservedRepresentative);
+                        preservedSet.add(node);
+                        notifyToObservers(node, removedRepresentative, preservedRepresentative);
+                }
+        }
+
+        protected void assignNewRepresentative(Object oldRepresentative, Set<Object> set) {
+                var iterator = set.iterator();
+                if (!iterator.hasNext()) {
+                        return;
+                }
+                var newRepresentative = iterator.next();
+                components.put(newRepresentative, set);
+                for (var node : set) {
+                        var oldRepresentativeOfNode = representatives.put(node, newRepresentative);
+                        if (!oldRepresentative.equals(oldRepresentativeOfNode)) {
+                                throw new IllegalArgumentException("Node %s was not represented by %s but by %s"
+                                                .formatted(node, oldRepresentative, oldRepresentativeOfNode));
+                        }
+                        notifyToObservers(node, oldRepresentative, newRepresentative);
+                }
+        }
+
+        public void setObserver(RepresentativeObserver observer) {
+                this.observer = observer;
+        }
+
+        public Map<Object, Set<Object>> getComponents() {
+                return components;
+        }
+
+        public Object getRepresentative(Object node) {
+                return representatives.get(node);
+        }
+
+        public Set<Object> getComponent(Object representative) {
+                return components.get(representative);
+        }
+
+        public void dispose() {
+                graph.detachObserver(this);
+        }
+
+        @Override
+        public void nodeInserted(Object n) {
+                var component = new HashSet<>(1);
+                component.add(n);
+                initializeSet(component);
+                notifyToObservers(n, n, Direction.INSERT);
+        }
+
+        @Override
+        public void nodeDeleted(Object n) {
+                var representative = representatives.remove(n);
+                if (!representative.equals(n)) {
+                        throw new IllegalStateException("Trying to delete node with dangling edges");
+                }
+                components.remove(representative);
+                notifyToObservers(n, representative, Direction.DELETE);
+        }
+
+        protected void notifyToObservers(Object node, Object oldRepresentative, Object newRepresentative) {
+                notifyToObservers(node, oldRepresentative, Direction.DELETE);
+                notifyToObservers(node, newRepresentative, Direction.INSERT);
+        }
+
+        protected void notifyToObservers(Object node, Object representative, Direction direction) {
+                if (observer != null) {
+                        observer.tupleChanged(node, representative, direction);
+                }
+        }
+
+        public interface Factory {
+                RepresentativeElectionAlgorithm create(Graph<Object> graph);
+        }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeObserver.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeObserver.java
new file mode 100644
index 00000000..93cce1ea
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/RepresentativeObserver.java
@@ -0,0 +1,12 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.base.itc.alg.representative;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+public interface RepresentativeObserver {
+        void tupleChanged(Object node, Object representative, Direction direction);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/StronglyConnectedComponentAlgorithm.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/StronglyConnectedComponentAlgorithm.java
new file mode 100644
index 00000000..ba42bb13
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/StronglyConnectedComponentAlgorithm.java
@@ -0,0 +1,66 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.base.itc.alg.representative;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.GraphHelper;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.bfs.BFS;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.scc.SCC;
+import tools.refinery.viatra.runtime.base.itc.graphimpl.Graph;
+
+import java.util.Collection;
+import java.util.Set;
+
+public class StronglyConnectedComponentAlgorithm extends RepresentativeElectionAlgorithm {
+        public StronglyConnectedComponentAlgorithm(Graph<Object> graph) {
+                super(graph);
+        }
+
+        @Override
+        protected void initializeComponents() {
+                var computedSCCs = SCC.computeSCC(graph).getSccs();
+                for (var computedSCC : computedSCCs) {
+                        initializeSet(computedSCC);
+                }
+        }
+
+        @Override
+        public void edgeInserted(Object source, Object target) {
+                var sourceRoot = getRepresentative(source);
+                var targetRoot = getRepresentative(target);
+                if (sourceRoot.equals(targetRoot)) {
+                        // New edge does not change strongly connected components.
+                        return;
+                }
+                if (BFS.isReachable(target, source, graph)) {
+                        merge(sourceRoot, targetRoot);
+                }
+        }
+
+        @Override
+        public void edgeDeleted(Object source, Object target) {
+                var sourceRoot = getRepresentative(source);
+                var targetRoot = getRepresentative(target);
+                if (!sourceRoot.equals(targetRoot)) {
+                        // New edge does not change strongly connected components.
+                        return;
+                }
+                var component = GraphHelper.getSubGraph(getComponent(sourceRoot), graph);
+                if (!BFS.isReachable(source, target, component)) {
+                        var newSCCs = SCC.computeSCC(component).getSccs();
+                        split(sourceRoot, newSCCs);
+                }
+        }
+
+        private void split(Object preservedRepresentative, Collection<? extends Set<Object>> sets) {
+                for (var set : sets) {
+                        if (set.contains(preservedRepresentative)) {
+                                components.put(preservedRepresentative, set);
+                        } else {
+                                assignNewRepresentative(preservedRepresentative, set);
+                        }
+                }
+        }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java
new file mode 100644
index 00000000..22159499
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/representative/WeaklyConnectedComponentAlgorithm.java
@@ -0,0 +1,85 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.base.itc.alg.representative;
+
+import tools.refinery.viatra.runtime.base.itc.graphimpl.Graph;
+
+import java.util.ArrayDeque;
+import java.util.HashSet;
+import java.util.Set;
+
+public class WeaklyConnectedComponentAlgorithm extends RepresentativeElectionAlgorithm {
+        public WeaklyConnectedComponentAlgorithm(Graph<Object> graph) {
+                super(graph);
+        }
+
+        @Override
+        protected void initializeComponents() {
+                for (var node : graph.getAllNodes()) {
+                        if (representatives.containsKey(node)) {
+                                continue;
+                        }
+                        var reachable = getReachableNodes(node);
+                        initializeSet(reachable);
+                }
+        }
+
+        @Override
+        public void edgeInserted(Object source, Object target) {
+                var sourceRoot = getRepresentative(source);
+                var targetRoot = getRepresentative(target);
+                merge(sourceRoot, targetRoot);
+        }
+
+        @Override
+        public void edgeDeleted(Object source, Object target) {
+                var sourceRoot = getRepresentative(source);
+                var targetRoot = getRepresentative(target);
+                if (!sourceRoot.equals(targetRoot)) {
+                        throw new IllegalArgumentException("Trying to remove edge not in graph");
+                }
+                var targetReachable = getReachableNodes(target);
+                if (!targetReachable.contains(source)) {
+                        split(sourceRoot, targetReachable);
+                }
+        }
+
+        private void split(Object sourceRepresentative, Set<Object> targetReachable) {
+                var sourceComponent = getComponent(sourceRepresentative);
+                sourceComponent.removeAll(targetReachable);
+                if (targetReachable.contains(sourceRepresentative)) {
+                        components.put(sourceRepresentative, targetReachable);
+                        assignNewRepresentative(sourceRepresentative, sourceComponent);
+                } else {
+                        assignNewRepresentative(sourceRepresentative, targetReachable);
+                }
+        }
+
+        private Set<Object> getReachableNodes(Object source) {
+                var retSet = new HashSet<>();
+                retSet.add(source);
+                var nodeQueue = new ArrayDeque<>();
+                nodeQueue.addLast(source);
+
+                while (!nodeQueue.isEmpty()) {
+                        var node = nodeQueue.removeFirst();
+                        for (var neighbor : graph.getTargetNodes(node).distinctValues()) {
+                                if (!retSet.contains(neighbor)) {
+                                        retSet.add(neighbor);
+                                        nodeQueue.addLast(neighbor);
+                                }
+                        }
+                        for (var neighbor : graph.getSourceNodes(node).distinctValues()) {
+                                if (!retSet.contains(neighbor)) {
+                                        retSet.add(neighbor);
+                                        nodeQueue.addLast(neighbor);
+                                }
+                        }
+                }
+
+                return retSet;
+        }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/util/CollectionHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/util/CollectionHelper.java
new file mode 100644
index 00000000..c9b3cafa
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/alg/util/CollectionHelper.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.alg.util;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * @author Tamas Szabo
+ * 
+ */
+public class CollectionHelper {
+
+    private CollectionHelper() {/*Utility class constructor*/}
+    
+    /**
+     * Returns the intersection of two sets. It calls {@link Set#retainAll(java.util.Collection)} but returns a new set
+     * containing the elements of the intersection.
+     * 
+     * @param set1
+     *            the first set (can be null, interpreted as empty)
+     * @param set2
+     *            the second set (can be null, interpreted as empty)
+     * @return the intersection of the sets
+     * @since 1.7
+     */
+    public static <V> Set<V> intersection(Set<V> set1, Set<V> set2) {
+        if (set1 == null || set2 == null) 
+            return CollectionsFactory.createSet();
+        
+        Set<V> intersection = CollectionsFactory.createSet(set1);
+        intersection.retainAll(set2);
+        return intersection;
+    }
+
+    
+    /**
+     * Returns the difference of two sets (S1\S2). It calls {@link Set#removeAll(java.util.Collection)} but returns a
+     * new set containing the elements of the difference.
+     * 
+     * @param set1
+     *            the first set (can be null, interpreted as empty)
+     * @param set2
+     *            the second set (can be null, interpreted as empty)
+     * @return the difference of the sets
+     * @since 1.7
+     */
+    public static <V> Set<V> difference(Set<V> set1, Set<V> set2) {
+        if (set1 == null)
+            return CollectionsFactory.createSet();
+        
+        Set<V> difference = CollectionsFactory.createSet(set1);
+        if (set2 != null) difference.removeAll(set2);
+        return difference;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/DotGenerator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/DotGenerator.java
new file mode 100644
index 00000000..0e21f323
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/DotGenerator.java
@@ -0,0 +1,160 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.itc.graphimpl;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.scc.SCC;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.scc.SCCResult;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Function;
+
+/**
+ * This class contains utility methods to generate dot representations for {@link Graph} instances.
+ *
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public class DotGenerator {
+
+    private static final String[] colors = new String[] { "yellow", "blue", "red", "green", "gray", "cyan" };
+
+    private DotGenerator() {
+
+    }
+
+    /**
+     * Generates the dot representation for the given graph.
+     *
+     * @param graph
+     *            the graph
+     * @param colorSCCs
+     *            specifies if the strongly connected components with size greater than shall be colored
+     * @param nameFunction
+     *            use this function to provide custom names to nodes, null if the default toString shall be used
+     * @param colorFunction
+     *            use this function to provide custom color to nodes, null if the default white color shall be used
+     * @param edgeFunction
+     *            use this function to provide custom edge labels, null if no edge label shall be printed
+     * @return the dot representation as a string
+     */
+    public static <V> String generateDot(final Graph<V> graph, final boolean colorSCCs,
+            final Function<V, String> nameFunction, final Function<V, String> colorFunction,
+            final Function<V, Function<V, String>> edgeFunction) {
+        final Map<V, String> colorMap = new HashMap<V, String>();
+
+        if (colorSCCs) {
+            final SCCResult<V> result = SCC.computeSCC(graph);
+            final Set<Set<V>> sccs = result.getSccs();
+
+            int i = 0;
+            for (final Set<V> scc : sccs) {
+                if (scc.size() > 1) {
+                    for (final V node : scc) {
+                        final String color = colorMap.get(node);
+                        if (color == null) {
+                            colorMap.put(node, colors[i % colors.length]);
+                        } else {
+                            colorMap.put(node, colorMap.get(node) + ":" + colors[i % colors.length]);
+                        }
+                    }
+                    i++;
+                }
+            }
+
+            // if a node has no color yet, then make it white
+            for (final V node : graph.getAllNodes()) {
+                if (!colorMap.containsKey(node)) {
+                    colorMap.put(node, "white");
+                }
+            }
+        } else {
+            for (final V node : graph.getAllNodes()) {
+                colorMap.put(node, "white");
+            }
+        }
+
+        if (colorFunction != null) {
+            for (final V node : graph.getAllNodes()) {
+                colorMap.put(node, colorFunction.apply(node));
+            }
+        }
+
+        final StringBuilder builder = new StringBuilder();
+        builder.append("digraph g {\n");
+
+        for (final V node : graph.getAllNodes()) {
+            final String nodePresentation = nameFunction == null ? node.toString() : nameFunction.apply(node);
+            builder.append("\"" + nodePresentation + "\"");
+            builder.append("[style=filled,fillcolor=" + colorMap.get(node) + "]");
+            builder.append(";\n");
+        }
+
+        for (final V source : graph.getAllNodes()) {
+            final IMemoryView<V> targets = graph.getTargetNodes(source);
+            if (!targets.isEmpty()) {
+                final String sourcePresentation = nameFunction == null ? source.toString() : nameFunction.apply(source);
+                for (final V target : targets.distinctValues()) {
+                    String edgeLabel = null;
+                    if (edgeFunction != null) {
+                        final Function<V, String> v1 = edgeFunction.apply(source);
+                        if (v1 != null) {
+                            edgeLabel = v1.apply(target);
+                        }
+                    }
+
+                    final String targetPresentation = nameFunction == null ? target.toString()
+                            : nameFunction.apply(target);
+
+                    builder.append("\"" + sourcePresentation + "\" -> \"" + targetPresentation + "\"");
+                    if (edgeLabel != null) {
+                        builder.append("[label=\"" + edgeLabel + "\"]");
+                    }
+                    builder.append(";\n");
+                }
+            }
+        }
+
+        builder.append("}");
+        return builder.toString();
+    }
+
+    /**
+     * Generates the dot representation for the given graph. No special pretty printing customization will be applied.
+     *
+     * @param graph
+     *            the graph
+     * @return the dot representation as a string
+     */
+    public static <V> String generateDot(final Graph<V> graph) {
+        return generateDot(graph, false, null, null, null);
+    }
+
+    /**
+     * Returns a simple name shortener function that can be used in the graphviz visualization to help with readability.
+     * WARNING: if you shorten the name of the {@link Node}s too much, the visualization may become incorrect because
+     * grahpviz will treat different nodes as the same if their shortened names are the same.
+     *
+     * @param maxLength
+     *            the maximum length of the text that is kept from the toString of the objects in the graph
+     * @return the shrunk toString value
+     */
+    public static <V> Function<V, String> getNameShortener(final int maxLength) {
+        return new Function<V, String>() {
+            @Override
+            public String apply(final V obj) {
+                final String value = obj.toString();
+                return value.substring(0, Math.min(value.length(), maxLength));
+            }
+        };
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/Graph.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/Graph.java
new file mode 100644
index 00000000..4267579c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/graphimpl/Graph.java
@@ -0,0 +1,185 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.graphimpl;
+
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.base.itc.igraph.IBiDirectionalGraphDataSource;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class Graph<V> implements IGraphDataSource<V>, IBiDirectionalGraphDataSource<V> {
+
+    // source -> target -> count
+    private IMultiLookup<V, V> outgoingEdges;
+    // target -> source -> count
+    private IMultiLookup<V, V> incomingEdges;
+
+    private Set<V> nodes;
+
+    private List<IGraphObserver<V>> observers;
+
+    public Graph() {
+        outgoingEdges = CollectionsFactory.createMultiLookup(Object.class, MemoryType.MULTISETS, Object.class);
+        incomingEdges = CollectionsFactory.createMultiLookup(Object.class, MemoryType.MULTISETS, Object.class);
+        nodes = CollectionsFactory.createSet();
+        observers = CollectionsFactory.createObserverList();
+    }
+
+    public void insertEdge(V source, V target) {
+        outgoingEdges.addPair(source, target);
+        incomingEdges.addPair(target, source);
+
+        for (IGraphObserver<V> go : observers) {
+            go.edgeInserted(source, target);
+        }
+    }
+
+    /**
+     * No-op if trying to delete edge that does not exist
+     *
+     * @since 2.0
+     * @see #deleteEdgeIfExists(Object, Object)
+     */
+    public void deleteEdgeIfExists(V source, V target) {
+        boolean containedEdge = outgoingEdges.lookupOrEmpty(source).containsNonZero(target);
+        if (containedEdge) {
+            deleteEdgeThatExists(source, target);
+        }
+    }
+
+    /**
+     * @throws IllegalStateException
+     *             if trying to delete edge that does not exist
+     * @since 2.0
+     * @see #deleteEdgeIfExists(Object, Object)
+     */
+    public void deleteEdgeThatExists(V source, V target) {
+        outgoingEdges.removePair(source, target);
+        incomingEdges.removePair(target, source);
+        for (IGraphObserver<V> go : observers) {
+            go.edgeDeleted(source, target);
+        }
+    }
+
+    /**
+     * @deprecated use explicitly {@link #deleteEdgeThatExists(Object, Object)} or
+     *             {@link #deleteEdgeIfExists(Object, Object)} instead. To preserve backwards compatibility, this method
+     *             delegates to the latter.
+     *
+     */
+    @Deprecated
+    public void deleteEdge(V source, V target) {
+        deleteEdgeIfExists(source, target);
+    }
+
+    /**
+     * Insert the given node into the graph.
+     */
+    public void insertNode(V node) {
+        if (nodes.add(node)) {
+            for (IGraphObserver<V> go : observers) {
+                go.nodeInserted(node);
+            }
+        }
+    }
+
+    /**
+     * Deletes the given node AND all of the edges going in and out from the node.
+     */
+    public void deleteNode(V node) {
+        if (nodes.remove(node)) {
+            IMemoryView<V> incomingView = incomingEdges.lookup(node);
+            if (incomingView != null) {
+                Map<V, Integer> incoming = CollectionsFactory.createMap(incomingView.asMap());
+
+                for (Entry<V, Integer> entry : incoming.entrySet()) {
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        deleteEdgeThatExists(entry.getKey(), node);
+                    }
+                }
+            }
+
+            IMemoryView<V> outgoingView = outgoingEdges.lookup(node);
+            if (outgoingView != null) {
+                Map<V, Integer> outgoing = CollectionsFactory.createMap(outgoingView.asMap());
+
+                for (Entry<V, Integer> entry : outgoing.entrySet()) {
+                    for (int i = 0; i < entry.getValue(); i++) {
+                        deleteEdgeThatExists(node, entry.getKey());
+                    }
+                }
+            }
+
+            for (IGraphObserver<V> go : observers) {
+                go.nodeDeleted(node);
+            }
+        }
+    }
+
+    @Override
+    public void attachObserver(IGraphObserver<V> go) {
+        observers.add(go);
+    }
+
+    @Override
+    public void attachAsFirstObserver(IGraphObserver<V> observer) {
+        observers.add(0, observer);
+    }
+
+    @Override
+    public void detachObserver(IGraphObserver<V> go) {
+        observers.remove(go);
+    }
+
+    @Override
+    public Set<V> getAllNodes() {
+        return nodes;
+    }
+
+    @Override
+    public IMemoryView<V> getTargetNodes(V source) {
+        return outgoingEdges.lookupOrEmpty(source);
+    }
+
+    @Override
+    public IMemoryView<V> getSourceNodes(V target) {
+        return incomingEdges.lookupOrEmpty(target);
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("nodes = ");
+        for (V n : getAllNodes()) {
+            sb.append(n.toString());
+            sb.append(" ");
+        }
+        sb.append(" edges = ");
+        for (V source : outgoingEdges.distinctKeys()) {
+            IMemoryView<V> targets = outgoingEdges.lookup(source);
+            for (V target : targets.distinctValues()) {
+                int count = targets.getCount(target);
+                for (int i = 0; i < count; i++) {
+                    sb.append("(" + source + "," + target + ") ");
+                }
+            }
+        }
+        return sb.toString();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalGraphDataSource.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalGraphDataSource.java
new file mode 100644
index 00000000..64659447
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalGraphDataSource.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiset;
+
+/**
+ * A bi-directional graph data source supports all operations that an {@link IGraphDataSource} does, but it 
+ * also makes it possible to query the incoming edges of nodes, not only the outgoing edges. 
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V> the type of the nodes in the graph
+ */
+public interface IBiDirectionalGraphDataSource<V> extends IGraphDataSource<V> {
+
+    /**
+     * Returns the source nodes for the given target node.  
+     * The returned data structure is an {@link IMultiset} because of potential parallel edges in the graph data source.
+     * 
+     * The method must not return null.
+     * 
+     * @param target the target node
+     * @return the multiset of source nodes
+     * @since 2.0
+     */
+    public IMemoryView<V> getSourceNodes(V target);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalWrapper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalWrapper.java
new file mode 100644
index 00000000..becab0eb
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IBiDirectionalWrapper.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+
+/**
+ * This class can be used to wrap an {@link IGraphDataSource} into an {@link IBiDirectionalGraphDataSource}. This class
+ * provides support for the retrieval of source nodes for a given target which is not supported by standard
+ * {@link IGraphDataSource} implementations.
+ * 
+ * @author Tamas Szabo
+ *
+ * @param <V>
+ *            the type parameter of the nodes in the graph data source
+ */
+public class IBiDirectionalWrapper<V> implements IBiDirectionalGraphDataSource<V>, IGraphObserver<V> {
+
+    private IGraphDataSource<V> wrappedDataSource;
+    // target -> source -> count
+    private IMultiLookup<V, V> incomingEdges;
+
+    public IBiDirectionalWrapper(IGraphDataSource<V> gds) {
+        this.wrappedDataSource = gds;
+
+        this.incomingEdges = CollectionsFactory.createMultiLookup(
+                Object.class, MemoryType.MULTISETS, Object.class);
+
+        if (gds.getAllNodes() != null) {
+            for (V source : gds.getAllNodes()) {
+                IMemoryView<V> targets = gds.getTargetNodes(source);
+                for (V target : targets.distinctValues()) {
+                    int count = targets.getCount(target);
+                    for (int i = 0; i < count; i++) {
+                        edgeInserted(source, target);
+                    }
+                }
+            }
+        }
+
+        gds.attachAsFirstObserver(this);
+    }
+
+    @Override
+    public void attachObserver(IGraphObserver<V> observer) {
+        wrappedDataSource.attachObserver(observer);
+    }
+
+    @Override
+    public void attachAsFirstObserver(IGraphObserver<V> observer) {
+        wrappedDataSource.attachAsFirstObserver(observer);
+    }
+
+    @Override
+    public void detachObserver(IGraphObserver<V> observer) {
+        wrappedDataSource.detachObserver(observer);
+    }
+
+    @Override
+    public Set<V> getAllNodes() {
+        return wrappedDataSource.getAllNodes();
+    }
+
+    @Override
+    public IMemoryView<V> getTargetNodes(V source) {
+        return wrappedDataSource.getTargetNodes(source);
+    }
+
+    @Override
+    public IMemoryView<V> getSourceNodes(V target) {
+        return incomingEdges.lookupOrEmpty(target);
+    }
+
+    @Override
+    public void edgeInserted(V source, V target) {
+        incomingEdges.addPair(target, source);
+    }
+
+    @Override
+    public void edgeDeleted(V source, V target) {
+        incomingEdges.removePair(target, source);
+    }
+
+    @Override
+    public void nodeInserted(V n) {
+
+    }
+
+    @Override
+    public void nodeDeleted(V node) {
+
+    }
+
+    @Override
+    public String toString() {
+        return wrappedDataSource.toString();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphDataSource.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphDataSource.java
new file mode 100644
index 00000000..3fa65936
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphDataSource.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiset;
+
+import java.util.Set;
+
+/**
+ * The interface prescribes the set of operations that a graph data source must support.
+ * <p> Note that the old version of the interface is broken at version 1.6;
+ *  MultiSets are now presented as Maps instead of Lists.
+ *
+ * @author Tamas Szabo
+ *
+ * @param <V>
+ *            the type of the nodes in the graph
+ */
+public interface IGraphDataSource<V> {
+
+    /**
+     * Attaches a new graph observer to this graph data source. Observers will be notified in the order they have been registered.
+     *
+     * @param observer the graph observer
+     */
+    public void attachObserver(IGraphObserver<V> observer);
+
+    /**
+     * Attaches a new graph observer to this graph data source as the first one.
+     * In the notification order this observer will be the first one as long as another call to this method happens.
+     *
+     * @param observer the graph observer
+     * @since 1.6
+     */
+    public void attachAsFirstObserver(IGraphObserver<V> observer);
+
+    /**
+     * Detaches an already registered graph observer from this graph data source.
+     *
+     * @param observer the graph observer
+     */
+    public void detachObserver(IGraphObserver<V> observer);
+
+    /**
+     * Returns the complete set of nodes in the graph data source.
+     *
+     * @return the set of all nodes
+     */
+    public Set<V> getAllNodes();
+
+    /**
+     * Returns the target nodes for the given source node.
+     * The returned data structure is an {@link IMultiset} because of potential parallel edges in the graph data source.
+     *
+     * The method must not return null.
+     *
+     * @param source the source node
+     * @return the multiset of target nodes
+     * @since 2.0
+     */
+    public IMemoryView<V> getTargetNodes(V source);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphObserver.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphObserver.java
new file mode 100644
index 00000000..5cb2d9fa
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/IGraphObserver.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+/**
+ * Interface GraphObserver is used to observ the changes in a graph; edge and node insertion/deleteion.
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public interface IGraphObserver<V> {
+
+    /**
+     * Used to notify when an edge is inserted into the graph.
+     * 
+     * @param source
+     *            the source of the edge
+     * @param target
+     *            the target of the edge
+     */
+    public void edgeInserted(V source, V target);
+
+    /**
+     * Used to notify when an edge is deleted from the graph.
+     * 
+     * @param source
+     *            the source of the edge
+     * @param target
+     *            the target of the edge
+     */
+    public void edgeDeleted(V source, V target);
+
+    /**
+     * Used to notify when a node is inserted into the graph.
+     * 
+     * @param n
+     *            the node
+     */
+    public void nodeInserted(V n);
+
+    /**
+     * Used to notify when a node is deleted from the graph.
+     * 
+     * @param n
+     *            the node
+     */
+    public void nodeDeleted(V n);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcDataSource.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcDataSource.java
new file mode 100644
index 00000000..5924b723
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcDataSource.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.base.itc.alg.misc.IGraphPathFinder;
+
+/**
+ * This interface defines those methods that a transitive reachability data source should provide. 
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V>
+ *            the type parameter of the node
+ */
+public interface ITcDataSource<V> {
+
+    /**
+     * Attach a transitive closure relation observer.
+     * 
+     * @param to
+     *            the observer object
+     */
+    public void attachObserver(ITcObserver<V> to);
+
+    /**
+     * Detach a transitive closure relation observer.
+     * 
+     * @param to
+     *            the observer object
+     */
+    public void detachObserver(ITcObserver<V> to);
+
+    /**
+     * Returns all nodes which are reachable from the source node.
+     * 
+     * @param source
+     *            the source node
+     * @return the set of target nodes
+     */
+    public Set<V> getAllReachableTargets(V source);
+
+    /**
+     * Returns all nodes from which the target node is reachable.
+     * 
+     * @param target
+     *            the target node
+     * @return the set of source nodes
+     */
+    public Set<V> getAllReachableSources(V target);
+
+    /**
+     * Returns true if the target node is reachable from the source node.
+     * 
+     * @param source
+     *            the source node
+     * @param target
+     *            the target node
+     * @return true if target is reachable from source, false otherwise
+     */
+    public boolean isReachable(V source, V target);
+    
+    /**
+     * The returned {@link IGraphPathFinder} can be used to retrieve paths between nodes using transitive reachability.
+     * 
+     * @return a path finder for the graph.
+     */
+    public IGraphPathFinder<V> getPathFinder();
+    
+    /**
+     * Call this method to properly dispose the data structures of a transitive closure algorithm.
+     */
+    public void dispose();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcObserver.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcObserver.java
new file mode 100644
index 00000000..fded53f1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/base/itc/igraph/ITcObserver.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.itc.igraph;
+
+/**
+ * Interface ITcObserver is used to observe the changes in a transitive closure relation; tuple insertion/deletion.
+ * 
+ * @author Szabo Tamas
+ * 
+ */
+public interface ITcObserver<V> {
+
+    /**
+     * Used to notify when a tuple is inserted into the transitive closure relation.
+     * 
+     * @param source
+     *            the source of the tuple
+     * @param target
+     *            the target of the tuple
+     */
+    public void tupleInserted(V source, V target);
+
+    /**
+     * Used to notify when a tuple is deleted from the transitive closure relation.
+     * 
+     * @param source
+     *            the source of the tuple
+     * @param target
+     *            the target of the tuple
+     */
+    public void tupleDeleted(V source, V target);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/ViatraQueryRuntimeException.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/ViatraQueryRuntimeException.java
new file mode 100644
index 00000000..83f6f766
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/ViatraQueryRuntimeException.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers;
+
+/**
+ * A common base class for all exceptions thrown by various VIATRA Query Runtime APIs.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ */
+public abstract class ViatraQueryRuntimeException extends RuntimeException {
+
+    private static final long serialVersionUID = -8505253058035069310L;
+
+    public ViatraQueryRuntimeException() {
+        super();
+    }
+
+    public ViatraQueryRuntimeException(String message) {
+        super(message);
+    }
+
+    public ViatraQueryRuntimeException(Throwable cause) {
+        super(cause);
+    }
+
+    public ViatraQueryRuntimeException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ViatraQueryRuntimeException(String message, Throwable cause, boolean enableSuppression,
+            boolean writableStackTrace) {
+        super(message, cause, enableSuppression, writableStackTrace);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/AverageAccumulator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/AverageAccumulator.java
new file mode 100644
index 00000000..2c09ede1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/AverageAccumulator.java
@@ -0,0 +1,24 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+/**
+ * @since 2.0
+ */
+class AverageAccumulator<Domain> {
+    Domain value;
+    long count;
+
+    public AverageAccumulator(Domain value, long count) {
+        super();
+        this.value = value;
+        this.count = count;
+    }
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleAverageOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleAverageOperator.java
new file mode 100644
index 00000000..e8a26afd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleAverageOperator.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.OptionalDouble;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ */
+public class DoubleAverageOperator implements IMultisetAggregationOperator<Double, AverageAccumulator<Double>, Double> {
+
+    public static final DoubleAverageOperator INSTANCE = new DoubleAverageOperator();
+    
+    private DoubleAverageOperator() {
+        // Singleton, do not call.
+    }
+    
+    @Override
+    public String getShortDescription() {
+        return "avg<Integer> incrementally computes the average of java.lang.Integer values";
+    }
+
+    @Override
+    public String getName() {
+        return "avg<Integer>";
+    }
+
+    @Override
+    public AverageAccumulator<Double> createNeutral() {
+        return new AverageAccumulator<Double>(0d, 0l);
+    }
+
+    @Override
+    public boolean isNeutral(AverageAccumulator<Double> result) {
+        return result.count == 0l;
+    }
+
+    @Override
+    public AverageAccumulator<Double> update(AverageAccumulator<Double> oldResult, Double updateValue,
+            boolean isInsertion) {
+        if (isInsertion) {
+            oldResult.value += updateValue;
+            oldResult.count++;
+        } else {
+            oldResult.value -= updateValue;
+            oldResult.count--;
+        }
+        return oldResult;
+    }
+
+    @Override
+    public Double getAggregate(AverageAccumulator<Double> result) {
+        return (result.count == 0)
+                ? null
+                : result.value/result.count;
+    }
+
+    @Override
+    public Double aggregateStream(Stream<Double> stream) {
+        final OptionalDouble averageOpt = stream.mapToDouble(Double::doubleValue).average();
+        return averageOpt.isPresent() ? averageOpt.getAsDouble() : null;
+    }
+    
+    /**
+     * @since 2.4
+     */
+    @Override
+    public AverageAccumulator<Double> clone(AverageAccumulator<Double> original) {
+        return new AverageAccumulator<Double>(original.value, original.count);
+    }
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleSumOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleSumOperator.java
new file mode 100644
index 00000000..744b0cd1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleSumOperator.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AbstractMemorylessAggregationOperator;
+
+/**
+ * Incrementally computes the sum of java.lang.Double values
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public class DoubleSumOperator extends AbstractMemorylessAggregationOperator<Double, Double> {
+    public static final DoubleSumOperator INSTANCE = new DoubleSumOperator();
+    
+    private DoubleSumOperator() {
+        // Singleton, do not call.
+    }
+
+    @Override
+    public String getShortDescription() {
+        return "sum<Double> incrementally computes the sum of java.lang.Double values";
+    }
+    @Override
+    public String getName() {
+        return "sum<Double>";
+    }
+    
+    @Override
+    public Double createNeutral() {
+        return 0d;
+    }
+
+    @Override
+    public boolean isNeutral(Double result) {
+        return createNeutral().equals(result);
+    }
+
+    @Override
+    public Double update(Double oldResult, Double updateValue, boolean isInsertion) {
+        return isInsertion ? 
+                oldResult + updateValue : 
+                oldResult - updateValue;
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Double aggregateStream(Stream<Double> stream) {
+        return stream.mapToDouble(Double::doubleValue).sum();
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/ExtremumOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/ExtremumOperator.java
new file mode 100644
index 00000000..ee4ceeb8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/ExtremumOperator.java
@@ -0,0 +1,135 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.Comparator;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+
+/**
+ * Incrementally computes the minimum or maximum of java.lang.Comparable values, using the default comparison
+ * 
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public class ExtremumOperator<T extends Comparable<T>>
+        implements IMultisetAggregationOperator<T, SortedMap<T, Integer>, T> {
+    
+    public enum Extreme {
+        MIN, MAX;
+        
+        /**
+         * @since 2.0
+         */
+        public <T> T pickFrom(SortedMap<T, Integer> nonEmptyMultiSet) {
+            switch(this) {
+            case MIN: 
+                return nonEmptyMultiSet.firstKey(); 
+            case MAX:
+                return nonEmptyMultiSet.lastKey();
+            default:
+                return null;
+            }
+        }
+    }
+
+    private static final ExtremumOperator MIN_OP = new ExtremumOperator<>(Extreme.MIN);
+    private static final ExtremumOperator MAX_OP = new ExtremumOperator<>(Extreme.MAX);
+
+    public static <T extends Comparable<T>> ExtremumOperator<T> getMin() {
+        return MIN_OP;
+    }
+    public static <T extends Comparable<T>> ExtremumOperator<T> getMax() {
+        return MAX_OP;
+    }
+    
+    Extreme extreme;
+    private ExtremumOperator(Extreme extreme) {
+        super();
+        this.extreme = extreme;
+    }
+
+    @Override
+    public String getShortDescription() {
+        String opName = getName();
+        return String.format(
+                "%s incrementally computes the %simum of java.lang.Comparable values, using the default comparison",
+                opName, opName);
+    }
+
+    @Override
+    public String getName() {
+        return extreme.name().toLowerCase();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public SortedMap<T, Integer> createNeutral() {
+        return new TreeMap<>();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public boolean isNeutral(SortedMap<T, Integer> result) {
+        return result.isEmpty();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public SortedMap<T, Integer> update(SortedMap<T, Integer> oldResult, T updateValue, boolean isInsertion) {
+        oldResult.compute(updateValue, (value, c) -> {
+            int count = (c == null) ? 0 : c;
+            int result = (isInsertion) ? count+1 : count-1;  
+            return (result == 0) ? null : result;
+        });
+        return oldResult;
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public T getAggregate(SortedMap<T, Integer> result) {
+        return result.isEmpty() ? null : 
+            extreme.pickFrom(result);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    @Override
+    public T aggregateStream(Stream<T> stream) {
+        switch (extreme) {
+        case MIN:
+            return stream.min(Comparator.naturalOrder()).orElse(null);
+        case MAX:
+            return stream.max(Comparator.naturalOrder()).orElse(null);
+        default:
+            return null;
+        }
+    }
+    
+    /**
+     * @since 2.4
+     */
+    @Override
+    public SortedMap<T, Integer> clone(SortedMap<T, Integer> original) {
+        return new TreeMap<T, Integer>(original);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerAverageOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerAverageOperator.java
new file mode 100644
index 00000000..bf422476
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerAverageOperator.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.OptionalDouble;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ */
+public class IntegerAverageOperator implements IMultisetAggregationOperator<Integer, AverageAccumulator<Integer>, Double> {
+
+    public static final IntegerAverageOperator INSTANCE = new IntegerAverageOperator();
+    
+    private IntegerAverageOperator() {
+        // Singleton, do not call.
+    }
+    
+    @Override
+    public String getShortDescription() {
+        return "avg<Integer> incrementally computes the average of java.lang.Integer values";
+    }
+
+    @Override
+    public String getName() {
+        return "avg<Integer>";
+    }
+
+    @Override
+    public AverageAccumulator<Integer> createNeutral() {
+        return new AverageAccumulator<Integer>(0, 0l);
+    }
+
+    @Override
+    public boolean isNeutral(AverageAccumulator<Integer> result) {
+        return result.count == 0l;
+    }
+
+    @Override
+    public AverageAccumulator<Integer> update(AverageAccumulator<Integer> oldResult, Integer updateValue,
+            boolean isInsertion) {
+        if (isInsertion) {
+            oldResult.value += updateValue;
+            oldResult.count++;
+        } else {
+            oldResult.value -= updateValue;
+            oldResult.count--;
+        }
+        return oldResult;
+    }
+
+    @Override
+    public Double getAggregate(AverageAccumulator<Integer> result) {
+        return (result.count == 0)
+                ? null
+                : ((double)result.value)/result.count;
+    }
+
+    @Override
+    public Double aggregateStream(Stream<Integer> stream) {
+        final OptionalDouble averageOpt = stream.mapToInt(Integer::intValue).average();
+        return averageOpt.isPresent() ? averageOpt.getAsDouble() : null;
+    }
+    
+    /**
+     * @since 2.4
+     */
+    @Override
+    public AverageAccumulator<Integer> clone(AverageAccumulator<Integer> original) {
+        return new AverageAccumulator<Integer>(original.value, original.count);
+    }
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerSumOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerSumOperator.java
new file mode 100644
index 00000000..18584256
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerSumOperator.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AbstractMemorylessAggregationOperator;
+
+/**
+ * Incrementally computes the sum of java.lang.Integer values
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public class IntegerSumOperator extends AbstractMemorylessAggregationOperator<Integer, Integer> {
+    public static final IntegerSumOperator INSTANCE = new IntegerSumOperator();
+    
+    private IntegerSumOperator() {
+        // Singleton, do not call.
+    }
+
+    @Override
+    public String getShortDescription() {
+        return "sum<Integer> incrementally computes the sum of java.lang.Integer values";
+    }
+    @Override
+    public String getName() {
+        return "sum<Integer>";
+    }
+    
+    @Override
+    public Integer createNeutral() {
+        return 0;
+    }
+
+    @Override
+    public boolean isNeutral(Integer result) {
+        return createNeutral().equals(result);
+    }
+
+    @Override
+    public Integer update(Integer oldResult, Integer updateValue, boolean isInsertion) {
+        return isInsertion ? 
+                oldResult + updateValue : 
+                oldResult - updateValue;
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Integer aggregateStream(Stream<Integer> stream) {
+        return stream.mapToInt(Integer::intValue).sum();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongAverageOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongAverageOperator.java
new file mode 100644
index 00000000..d56c9507
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongAverageOperator.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.OptionalDouble;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IMultisetAggregationOperator;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ */
+public class LongAverageOperator implements IMultisetAggregationOperator<Long, AverageAccumulator<Long>, Double> {
+
+    public static final LongAverageOperator INSTANCE = new LongAverageOperator();
+    
+    private LongAverageOperator() {
+        // Singleton, do not call.
+    }
+    
+    @Override
+    public String getShortDescription() {
+        return "avg<Integer> incrementally computes the average of java.lang.Integer values";
+    }
+
+    @Override
+    public String getName() {
+        return "avg<Integer>";
+    }
+
+    @Override
+    public AverageAccumulator<Long> createNeutral() {
+        return new AverageAccumulator<Long>(0l, 0l);
+    }
+
+    @Override
+    public boolean isNeutral(AverageAccumulator<Long> result) {
+        return result.count == 0l;
+    }
+
+    @Override
+    public AverageAccumulator<Long> update(AverageAccumulator<Long> oldResult, Long updateValue,
+            boolean isInsertion) {
+        if (isInsertion) {
+            oldResult.value += updateValue;
+            oldResult.count++;
+        } else {
+            oldResult.value -= updateValue;
+            oldResult.count--;
+        }
+        return oldResult;
+    }
+
+    @Override
+    public Double getAggregate(AverageAccumulator<Long> result) {
+        return (result.count == 0)
+                ? null
+                : ((double)result.value)/result.count;
+    }
+
+    @Override
+    public Double aggregateStream(Stream<Long> stream) {
+        final OptionalDouble averageOpt = stream.mapToLong(Long::longValue).average();
+        return averageOpt.isPresent() ? averageOpt.getAsDouble() : null;
+    }
+    
+    /**
+     * @since 2.4
+     */
+    @Override
+    public AverageAccumulator<Long> clone(AverageAccumulator<Long> original) {
+        return new AverageAccumulator<Long>(original.value, original.count);
+    }
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongSumOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongSumOperator.java
new file mode 100644
index 00000000..29ded090
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongSumOperator.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AbstractMemorylessAggregationOperator;
+
+/**
+ * Incrementally computes the sum of java.lang.Long values
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public class LongSumOperator extends AbstractMemorylessAggregationOperator<Long, Long> {
+    public static final LongSumOperator INSTANCE = new LongSumOperator();
+    
+    private LongSumOperator() {
+        // Singleton, do not call.
+    }
+
+    @Override
+    public String getShortDescription() {
+        return "sum<Long> incrementally computes the sum of java.lang.Long values";
+    }
+    @Override
+    public String getName() {
+        return "sum<Long>";
+    }
+    
+    @Override
+    public Long createNeutral() {
+        return 0L;
+    }
+
+    @Override
+    public boolean isNeutral(Long result) {
+        return createNeutral().equals(result);
+    }
+
+    @Override
+    public Long update(Long oldResult, Long updateValue, boolean isInsertion) {
+        return isInsertion ? 
+                oldResult + updateValue : 
+                oldResult - updateValue;
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Long aggregateStream(Stream<Long> stream) {
+        return stream.mapToLong(Long::longValue).sum();
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/avg.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/avg.java
new file mode 100644
index 00000000..c25678aa
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/avg.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AggregatorType;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IAggregatorFactory;
+
+/**
+ * This aggregator calculates the average of the values of a selected aggregate parameter of a called pattern. The aggregate
+ * parameter is selected with the '#' symbol; the aggregate parameter must not be used outside the aggregator call. The
+ * other parameters of the call might be bound or unbound; bound parameters limit the matches to consider for the
+ * summation.
+ * 
+ * @since 2.0
+ *
+ */
+@AggregatorType(
+        parameterTypes = {Integer.class, Double.class, Long.class},
+        returnTypes = {Double.class, Double.class, Double.class})
+public final class avg implements IAggregatorFactory {
+
+    @Override
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass) {
+        if (Integer.class.equals(domainClass))
+            return new BoundAggregator(IntegerAverageOperator.INSTANCE, Integer.class, Double.class);
+        if (Double.class.equals(domainClass))
+            return new BoundAggregator(DoubleAverageOperator.INSTANCE, Double.class, Double.class);
+        if (Long.class.equals(domainClass))
+            return new BoundAggregator(LongAverageOperator.INSTANCE, Long.class, Double.class);
+        else throw new IllegalArgumentException();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/count.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/count.java
new file mode 100644
index 00000000..8310a0ce
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/count.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AggregatorType;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IAggregatorFactory;
+
+/**
+ * An aggregator to count the number of matches a pattern has. The return of the aggregator is an non-negative integer
+ * number.
+ * 
+ * @since 1.4
+ *
+ */
+@AggregatorType(parameterTypes = {Void.class}, returnTypes = {Integer.class})
+public final class count implements IAggregatorFactory {
+
+    @Override
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass) {
+        if (Void.class.equals(domainClass))
+            return new BoundAggregator(null, Void.class, Integer.class);
+        else throw new IllegalArgumentException();
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/max.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/max.java
new file mode 100644
index 00000000..e0236223
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/max.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Calendar;
+import java.util.Date;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AggregatorType;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IAggregatorFactory;
+
+/**
+ * This aggregator calculates the maximum value of a selected aggregate parameter of a called pattern. The aggregate
+ * parameter is selected with the '#' symbol; the aggregate parameter must not be used outside the aggregator call. The
+ * other parameters of the call might be bound or unbound; bound parameters limit the matches to consider for the
+ * minimum calculation.
+ * 
+ * @since 1.4
+ * @author Gabor Bergmann
+ */
+@AggregatorType(
+        // TODO T extends Comparable?
+        parameterTypes = {BigDecimal.class, BigInteger.class, Boolean.class, Byte.class, Calendar.class, Character.class, 
+                Date.class, Double.class, Enum.class, Float.class, Integer.class, Long.class, Short.class, String.class},
+        returnTypes = {BigDecimal.class, BigInteger.class, Boolean.class, Byte.class, Calendar.class, Character.class, 
+                Date.class, Double.class, Enum.class, Float.class, Integer.class, Long.class, Short.class, String.class})
+public final class max implements IAggregatorFactory {
+
+    @Override
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass) {
+        if (Comparable.class.isAssignableFrom(domainClass))
+            return new BoundAggregator(ExtremumOperator.getMax(), domainClass, domainClass);
+        else throw new IllegalArgumentException();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/min.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/min.java
new file mode 100644
index 00000000..6408c57b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/min.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.util.Calendar;
+import java.util.Date;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AggregatorType;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IAggregatorFactory;
+
+/**
+ * This aggregator calculates the minimum value of a selected aggregate parameter of a called pattern. The aggregate
+ * parameter is selected with the '#' symbol; the aggregate parameter must not be used outside the aggregator call. The
+ * other parameters of the call might be bound or unbound; bound parameters limit the matches to consider for the
+ * minimum calculation.
+ * 
+ * @since 1.4
+ *
+ */
+@AggregatorType(
+        // TODO T extends Comparable?
+        parameterTypes = {BigDecimal.class, BigInteger.class, Boolean.class, Byte.class, Calendar.class, Character.class, 
+                Date.class, Double.class, Enum.class, Float.class, Integer.class, Long.class, Short.class, String.class},
+        returnTypes = {BigDecimal.class, BigInteger.class, Boolean.class, Byte.class, Calendar.class, Character.class, 
+                Date.class, Double.class, Enum.class, Float.class, Integer.class, Long.class, Short.class, String.class})
+public final class min implements IAggregatorFactory {
+    
+    @Override
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass) {
+        if (Comparable.class.isAssignableFrom(domainClass))
+            return new BoundAggregator(ExtremumOperator.getMin(), domainClass, domainClass);
+        else throw new IllegalArgumentException();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/sum.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/sum.java
new file mode 100644
index 00000000..69ff2e75
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/sum.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.aggregators;
+
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.AggregatorType;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.IAggregatorFactory;
+
+/**
+ * This aggregator calculates the sum of the values of a selected aggregate parameter of a called pattern. The aggregate
+ * parameter is selected with the '#' symbol; the aggregate parameter must not be used outside the aggregator call. The
+ * other parameters of the call might be bound or unbound; bound parameters limit the matches to consider for the
+ * summation.
+ * 
+ * @since 1.4
+ *
+ */
+@AggregatorType(
+        parameterTypes = {Integer.class, Double.class, Long.class},
+        returnTypes = {Integer.class, Double.class, Long.class})
+public final class sum implements IAggregatorFactory {
+
+    @Override
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass) {
+        if (Integer.class.equals(domainClass))
+            return new BoundAggregator(IntegerSumOperator.INSTANCE, Integer.class, Integer.class);
+        if (Double.class.equals(domainClass))
+            return new BoundAggregator(DoubleSumOperator.INSTANCE, Double.class, Double.class);
+        if (Long.class.equals(domainClass))
+            return new BoundAggregator(LongSumOperator.INSTANCE, Long.class, Long.class);
+        else throw new IllegalArgumentException();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/OrderedIterableMerge.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/OrderedIterableMerge.java
new file mode 100644
index 00000000..1917e909
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/OrderedIterableMerge.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.algorithms;
+
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+/**
+ * @author Gabor Bergmann
+ * @since 2.1
+ *
+ */
+public class OrderedIterableMerge {
+    
+    private OrderedIterableMerge() {
+        // Hidden utility class constructor
+    }
+    
+    /**
+     * Lazily merges two iterables, each ordered according to a given comparator. 
+     * Retains order in the result, and also eliminates any duplicates that appear in both arguments.
+     */
+    public static <T> Iterable<T> mergeUniques(Iterable<T> first, Iterable<T> second, Comparator<T> comparator) {
+        return () -> new Iterator<T>() {
+            Iterator<T> firstIterator = first.iterator();
+            Iterator<T> secondIterator = second.iterator();
+            T firstItem;
+            T secondItem;
+            
+            {
+                fetchFirst();
+                fetchSecond();
+            }
+            
+            private T fetchFirst() {
+                T previous = firstItem;
+                if (firstIterator.hasNext()) 
+                    firstItem = firstIterator.next();
+                else 
+                    firstItem = null;
+                return previous;
+            }
+            private T fetchSecond() {
+               T previous = secondItem;
+               if (secondIterator.hasNext()) 
+                    secondItem = secondIterator.next();
+                else 
+                    secondItem = null;
+               return previous;
+            }
+            
+            @Override
+            public boolean hasNext() {
+                return firstItem != null || secondItem != null;
+            }
+            @Override
+            public T next() {
+                if (!hasNext()) throw new NoSuchElementException();
+                if (firstItem != null && secondItem != null) {
+                    if (secondItem == firstItem) { // duplicates
+                        fetchFirst();
+                        return fetchSecond();
+                    } else if (comparator.compare(firstItem, secondItem) < 0) {
+                        return fetchFirst();
+                    } else {
+                        return fetchSecond();
+                    }
+                } else if (firstItem != null) {
+                    return fetchFirst();
+                } else { // secondItem must be non-null
+                    return fetchSecond();
+                }
+            }
+        };
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFind.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFind.java
new file mode 100644
index 00000000..c69f08e5
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFind.java
@@ -0,0 +1,214 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.algorithms;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * Union-find data structure implementation. Note that the implementation relies on the correct implementation of the
+ * equals method of the type parameter's class.
+ * 
+ * @author Tamas Szabo
+ * 
+ * @param <V>
+ *            the type parameter of the element's stored in the union-find data structure
+ */
+public class UnionFind<V> {
+
+    private final Map<V, UnionFindNodeProperty<V>> nodeMap;
+    final Map<V, Set<V>> setMap;
+
+    /**
+     * Instantiate a new union-find data structure.
+     */
+    public UnionFind() {
+        nodeMap = CollectionsFactory.createMap();
+        setMap = CollectionsFactory.createMap();
+    }
+
+    /**
+     * Instantiate a new union-find data structure with the given elements as separate sets.
+     */
+    public UnionFind(Iterable<V> elements) {
+        this();
+        for (V element : elements) {
+            makeSet(element);
+        }
+    }
+
+    /**
+     * Creates a new union set from a collection of elements.
+     * 
+     * @param nodes
+     *            the collection of elements
+     * @return the root element
+     */
+    public V makeSet(Collection<V> nodes) {
+        if (!nodes.isEmpty()) {
+            Iterator<V> iterator = nodes.iterator();
+            V root = makeSet(iterator.next());
+            while (iterator.hasNext()) {
+                root = union(root, iterator.next());
+            }
+            return root;
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * This method creates a single set containing the given node.
+     * 
+     * @param node
+     *            the root node of the set
+     * @return the root element
+     */
+    public V makeSet(V node) {
+        if (!nodeMap.containsKey(node)) {
+            UnionFindNodeProperty<V> prop = new UnionFindNodeProperty<V>(0, node);
+            nodeMap.put(node, prop);
+            Set<V> set = new HashSet<V>();
+            set.add(node);
+            setMap.put(node, set);
+        }
+        return node;
+    }
+
+    /**
+     * Find method with path compression.
+     * 
+     * @param node
+     *            the node to find
+     * @return the root node of the set in which the given node can be found
+     */
+    public V find(V node) {
+        UnionFindNodeProperty<V> prop = nodeMap.get(node);
+
+        if (prop != null) {
+            if (prop.parent.equals(node)) {
+                return node;
+            } else {
+                prop.parent = find(prop.parent);
+                return prop.parent;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Union by rank implementation of the two sets which contain x and y; x and/or y can be a single element from the
+     * universe.
+     * 
+     * @param x
+     *            set or single element of the universe
+     * @param y
+     *            set or single element of the universe
+     * @return the new root of the two sets
+     */
+    public V union(V x, V y) {
+        V xRoot = find(x);
+        V yRoot = find(y);
+
+        if ((xRoot == null) || (yRoot == null)) {
+            return union( (xRoot == null) ? makeSet(x) : xRoot, (yRoot == null) ? makeSet(y) : yRoot);
+        }
+        else if (!xRoot.equals(yRoot)) {
+            UnionFindNodeProperty<V> xRootProp = nodeMap.get(xRoot);
+            UnionFindNodeProperty<V> yRootProp = nodeMap.get(yRoot);
+
+            if (xRootProp.rank < yRootProp.rank) {
+                xRootProp.parent = yRoot;
+                setMap.get(yRoot).addAll(setMap.get(xRoot));
+                setMap.remove(xRoot);
+                return yRoot;
+            } else {// (xRootProp.rank >= yRootProp.rank)
+                yRootProp.parent = xRoot;
+                yRootProp.rank = (xRootProp.rank == yRootProp.rank) ? yRootProp.rank + 1 : yRootProp.rank;
+                setMap.get(xRoot).addAll(setMap.get(yRoot));
+                setMap.remove(yRoot);
+                return xRoot;
+            }
+        } else {
+            return xRoot;
+        }
+    }
+
+    /**
+     * Places the given elements in to the same partition.
+     */
+    public void unite(Set<V> elements) {
+        if (elements.size() > 1) {
+            V current = null;
+            for (V element : elements) {
+                if (current != null) {
+                    if (getPartition(element) != null) {
+                        union(current, element);
+                    }
+                } else {
+                    if (getPartition(element) != null) {
+                        current = element;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Delete the set whose root is the given node.
+     * 
+     * @param root
+     *            the root node
+     */
+    public void deleteSet(V root) {
+        // if (setMap.containsKey(root))
+        for (V n : setMap.get(root)) {
+            nodeMap.remove(n);
+        }
+        setMap.remove(root);
+    }
+
+    /**
+     * Returns if all given elements are in the same partition.
+     */
+    public boolean isSameUnion(Set<V> elements) {
+        for (Set<V> partition : setMap.values()) {
+            if (partition.containsAll(elements)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    
+    /**
+     * Returns the partition in which the given element can be found, or null otherwise.
+     */
+    public Set<V> getPartition(V element) {
+        V root = find(element);
+        return setMap.get(root);
+    }
+
+    /**
+     * Returns all partitions.
+     */
+    public Collection<Set<V>> getPartitions() {
+        return setMap.values();
+    }
+
+    public Set<V> getPartitionHeads() {
+        return setMap.keySet();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFindNodeProperty.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFindNodeProperty.java
new file mode 100644
index 00000000..82852f9c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFindNodeProperty.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.algorithms;
+
+public class UnionFindNodeProperty<V> {
+
+    public int rank;
+    public V parent;
+
+    public UnionFindNodeProperty() {
+        this.rank = 0;
+        this.parent = null;
+    }
+
+    public UnionFindNodeProperty(int rank, V parent) {
+        super();
+        this.rank = rank;
+        this.parent = parent;
+    }
+
+    @Override
+    public String toString() {
+        return "[rank:" + rank + ", parent:" + parent.toString() + "]";
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/CommonQueryHintOptions.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/CommonQueryHintOptions.java
new file mode 100644
index 00000000..317293bf
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/CommonQueryHintOptions.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IRewriterTraceCollector;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.NopTraceCollector;
+
+/**
+ * Query evaluation hints applicable to any engine
+ * @since 1.6
+ *
+ */
+public final class CommonQueryHintOptions {
+    
+    private CommonQueryHintOptions() {
+        // Hiding constructor for utility class
+    }
+    
+    /**
+     * This hint instructs the query backends to record trace information into the given trace collector
+     */
+    public static final QueryHintOption<IRewriterTraceCollector> normalizationTraceCollector = 
+            hintOption("normalizationTraceCollector", NopTraceCollector.INSTANCE);
+    
+    // internal helper for conciseness
+    private static <T> QueryHintOption<T> hintOption(String hintKeyLocalName, T defaultValue) {
+        return new QueryHintOption<>(CommonQueryHintOptions.class, hintKeyLocalName, defaultValue);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ICallDelegationStrategy.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ICallDelegationStrategy.java
new file mode 100644
index 00000000..40853f46
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ICallDelegationStrategy.java
@@ -0,0 +1,89 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryResultProviderAccess;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+
+/**
+ * Function object that specifies how hints (including backend preferences) shall propagate through pattern calls.
+ * 
+ * <p> A few useful default implementations are included as static fields.
+ * 
+ * <p> As of 2.1, only suppported by the local search backend, and only if the pattern call is not flattened.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+@FunctionalInterface
+public interface ICallDelegationStrategy {
+
+    /**
+     * Specifies how hints (including backend preferences) shall propagate through pattern calls.
+     * 
+     * @param call a {@link PConstraint} in a query that calls another query.
+     * @param callerHint  a hint under which the calling pattern is evaluated, 
+     * @param callerBackend the actual backend evaluating the calling pattern.  
+     * @param calleeHintProvider the provider of hints for the called pattern.
+     * @return the hints, including backend selection, 
+     * that the backend responsible for the caller pattern must specify when 
+     * requesting the {@link IQueryResultProvider} for the called pattern via {@link IQueryResultProviderAccess}.
+     */
+    public QueryEvaluationHint transformHints(IQueryReference call, 
+            QueryEvaluationHint callerHint, 
+            IQueryBackend callerBackend,
+            IQueryBackendHintProvider calleeHintProvider);
+    
+    
+    /**
+     * Options known for callee are used to override caller options, except the backend selection. 
+     * Always use the same backend for the callee and the caller, regardless what is specified for the callee pattern. 
+     * @author Gabor Bergmann
+     */
+    public static final ICallDelegationStrategy FULL_BACKEND_ADHESION = (call, callerHint, callerBackend, calleeHintProvider) -> {
+        QueryEvaluationHint calleeHint = 
+                calleeHintProvider.getQueryEvaluationHint(call.getReferredQuery());
+        QueryEvaluationHint result = 
+            callerHint == null ? calleeHint : callerHint.overrideBy(calleeHint);
+            
+        QueryEvaluationHint backendAdhesion = new QueryEvaluationHint(
+                null /* settings-ignorant */, callerBackend.getFactory());
+        result = result.overrideBy(backendAdhesion);
+        return result;
+    };
+    /**
+     * Options known for callee are used to override caller options, including the backend selection. 
+     * If callee does not specify a backend requirement, the backend of the caller is kept.
+     * @author Gabor Bergmann
+     */
+    public static final ICallDelegationStrategy PARTIAL_BACKEND_ADHESION = (call, callerHint, callerBackend, calleeHintProvider) -> {
+        QueryEvaluationHint backendAdhesion = new QueryEvaluationHint(
+                null /* settings-ignorant */, callerBackend.getFactory());
+        
+        QueryEvaluationHint result = 
+                callerHint == null ? backendAdhesion : callerHint.overrideBy(backendAdhesion);
+        
+        QueryEvaluationHint calleeHint = calleeHintProvider.getQueryEvaluationHint(call.getReferredQuery());
+        result = result.overrideBy(calleeHint);
+
+        return result;
+    };
+    /**
+     * Options known for callee are used to override caller options, including the backend selection. 
+     * Always use the backend specified for the callee (or the default if none), regardless of the backend of the caller.
+     * @author Gabor Bergmann
+     */
+    public static final ICallDelegationStrategy NO_BACKEND_ADHESION = (call, callerHint, callerBackend, calleeHintProvider) -> {
+        QueryEvaluationHint calleeHint = calleeHintProvider.getQueryEvaluationHint(call.getReferredQuery());
+        return callerHint == null ? calleeHint : callerHint.overrideBy(calleeHint);
+    };
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IMatcherCapability.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IMatcherCapability.java
new file mode 100644
index 00000000..104b68a8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IMatcherCapability.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+/**
+ * Implementations of this interface can be used to decide whether a matcher created by an arbitrary backend can
+ * potentially be used as a substitute for another matcher.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public interface IMatcherCapability {
+
+    /**
+     * Returns true if matchers of this capability can be used as a substitute for a matcher implementing the given capability
+     */
+    public boolean canBeSubstitute(IMatcherCapability capability);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackend.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackend.java
new file mode 100644
index 00000000..c85f10a4
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackend.java
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Internal interface for a VIATRA query specification. Each query is associated with a pattern. Methods instantiate a matcher
+ * of the pattern with various parameters.
+ *
+ * @author Bergmann Gábor
+ * @since 0.9
+ * @noextend This interface is not intended to be extended by users of the VIATRA framework, and should only be used by the query engine
+ */
+public interface IQueryBackend {
+        
+        /**
+         * @return true iff this backend is incremental, i.e. it caches the results of queries for quick retrieval, 
+         * and can provide update notifications on result set changes.
+         */
+        public boolean isCaching();
+        
+    /**
+     * Returns a result provider for a given query. Repeated calls may return the same instance.
+     * @throws ViatraQueryRuntimeException
+     */
+        public IQueryResultProvider getResultProvider(PQuery query);
+        
+        /**
+     * Returns a result provider for a given query. Repeated calls may return the same instance.
+     * @param optional hints that may override engine and query defaults (as provided by {@link IQueryBackendHintProvider}). Can be null.
+     * @throws ViatraQueryRuntimeException 
+         * @since 1.4
+     */
+    public IQueryResultProvider getResultProvider(PQuery query, QueryEvaluationHint hints);
+        
+    /**
+     * Returns an existing result provider for a given query, if it was previously constructed, returns null otherwise.
+     * Will not construct and initialize new result providers.
+     */
+        public IQueryResultProvider peekExistingResultProvider(PQuery query);
+
+        /**
+         * Propagates all pending updates in this query backend. The implementation of this method is optional, and it 
+         * can be ignored entirely if the backend does not delay updates.   
+         * @since 1.6
+         */
+        public void flushUpdates();
+        
+        /**
+         * Disposes the query backend.
+         */
+        public abstract void dispose();
+        
+        /**
+         * @return the factory that created this backend, if this functionality is supported
+         * @since 2.1
+         */
+        public IQueryBackendFactory getFactory();
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactory.java
new file mode 100644
index 00000000..e264ab3f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactory.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * A Query Backend Factory identifies a query evaluator implementation, and can create an evaluator instance (an {@link IQueryBackend}) tied to a specific VIATRA Query engine upon request. 
+ * 
+ * <p> The factory is used as a lookup key for the backend instance, 
+ *   therefore implementors should either be singletons, or implement equals() / hashCode() accordingly. 
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public interface IQueryBackendFactory {
+    
+    /**
+     * Creates a new {@link IQueryBackend} instance tied to the given context elements. 
+     * 
+     * @return an instance of the class returned by {@link #getBackendClass()} that operates in the given context.
+     * @since 1.5
+     */
+    public IQueryBackend 
+        create(IQueryBackendContext context);
+    
+    
+    /**
+     * The backend instances created by this factory are guaranteed to conform to the returned class.
+     */
+    public Class<? extends IQueryBackend> getBackendClass();
+
+    /**
+     * Calculate the required capabilities, which are needed to execute the given pattern
+     * 
+     * @since 1.4
+     */
+    public IMatcherCapability calculateRequiredCapability(PQuery query, QueryEvaluationHint hint);
+    
+    /**
+     * Returns whether the current backend is caching
+     * @since 2.0
+     */
+    public boolean isCaching();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactoryProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactoryProvider.java
new file mode 100644
index 00000000..8787814e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactoryProvider.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+/**
+ * A provider interface for {@link IQueryBackendFactory} instances.
+ * @since 2.0
+ */
+public interface IQueryBackendFactoryProvider {
+
+    /**
+     * Returns a query backend factory instance. The method should return the same instance in case of repeated calls.
+     */
+    IQueryBackendFactory getFactory();
+    
+    /**
+     * Returns whether the given query backend should be considered as system default. If multiple backends are
+     * registered as system default, it is undefined which one will be chosen.
+     */
+    default boolean isSystemDefaultEngine() {
+        return false;
+    }
+    
+    /**
+     * Returns whether the given query backend should be considered as system default search backend. If multiple
+     * backends are registered as system default, it is undefined which one will be chosen.
+     */
+    default boolean isSystemDefaultSearchBackend() {
+        return false;
+    }
+    
+    
+    /**
+     * Returns whether the given query backend should be considered as system default caching backend. If multiple
+     * backends are registered as system default, it is undefined which one will be chosen.
+     */
+    default boolean isSystemDefaultCachingBackend() {
+        return false;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendHintProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendHintProvider.java
new file mode 100644
index 00000000..9bb76349
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendHintProvider.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Provides query evaluation hints consisting of the Engine default hints and
+ * the hints provided by the pattern itself.
+ * 
+ * @author Bergmann Gabor
+ * @since 0.9
+ * @noimplement This interface is not intended to be implemented by clients, except in the tools.refinery.viatra.runtime plugin.
+ */
+public interface IQueryBackendHintProvider {
+    
+    /**
+     * Suggests query evaluation hints regarding a query. The returned hints reflects the default hints of the 
+     * query engine merged with the hints provided by the pattern itself. These can be overridden via specific
+     * advanced API of the engine.  
+     * 
+     * @since 1.4
+     */
+    QueryEvaluationHint getQueryEvaluationHint(PQuery query);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryResultProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryResultProvider.java
new file mode 100644
index 00000000..cd7d050f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryResultProvider.java
@@ -0,0 +1,202 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.planning.helpers.StatisticsHelper;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+
+/**
+ * An internal interface of the query backend that provides results of a given query. 
+ * @author Bergmann Gabor
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IQueryResultProvider {
+
+    /**
+     * Decides whether there are any matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @since 2.0
+     */
+    public boolean hasMatch(Object[] parameters);
+    
+    /**
+     * Decides whether there are any matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameterSeedMask
+     *            a mask that extracts those parameters of the query (from the entire parameter list) that should be
+     *            bound to a fixed value
+     * @param parameters
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold
+     * @since 2.0
+     */
+    public boolean hasMatch(TupleMask parameterSeedMask, ITuple projectedParameterSeed);
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return the number of pattern matches found.
+     */
+    public int countMatches(Object[] parameters);
+    
+    /**
+     * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameterSeedMask
+     *            a mask that extracts those parameters of the query (from the entire parameter list) that should be
+     *            bound to a fixed value
+     * @param parameters
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold
+     * @return the number of pattern matches found.
+     * @since 1.7
+     */
+    public int countMatches(TupleMask parameterSeedMask, ITuple projectedParameterSeed);
+    
+    /**
+     * Gives an estimate of the number of different groups the matches are projected into by the given mask
+     * (e.g. for an identity mask, this means the full match set size). The estimate must meet the required accuracy.
+     * 
+     * <p> If there is insufficient information to provide an answer up to the required precision, {@link Optional#empty()} may be returned.
+     * In other words, query backends may deny an answer, or do their best to give an estimate without actually determining the match set of the query. 
+     * However, caching backends are expected to simply return the indexed (projection) size, initialized on-demand if necessary.
+     * 
+     * <p> PRE: {@link TupleMask#isNonrepeating()} must hold for the group mask.
+     * 
+     * @return if available, an estimate of the cardinality of the projection of the match set, with the desired accuracy.
+     * 
+     * @since 2.1
+     */
+    public Optional<Long> estimateCardinality(TupleMask groupMask, Accuracy requiredAccuracy);
+    
+    /**
+     * Gives an estimate of the average size of different groups the matches are projected into by the given mask
+     * (e.g. for an identity mask, this means 1, while for an empty mask, the result is match set size). 
+     * The estimate must meet the required accuracy.
+     * 
+     * <p> If there is insufficient information to provide an answer up to the required precision, {@link Optional#empty()} may be returned.
+     * In other words, query backends may deny an answer, or do their best to give an estimate without actually determining the match set of the query. 
+     * However, caching backends are expected to simply return the exact value from the index, initialized on-demand if necessary.
+     * 
+     * <p> For an empty match set, zero is acceptable as an exact answer.
+     * 
+     * <p> PRE: {@link TupleMask#isNonrepeating()} must hold for the group mask.
+     * 
+     * @return if available, an estimate of the average size of each projection group of the match set, with the desired accuracy.
+     * 
+     * @since 2.1
+     */
+    public default Optional<Double> estimateAverageBucketSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        return StatisticsHelper.estimateAverageBucketSize(groupMask, requiredAccuracy, this::estimateCardinality);
+    }
+   
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return a match represented in the internal {@link Tuple} representation.
+     * @since 2.0
+     */
+    public Optional<Tuple> getOneArbitraryMatch(Object[] parameters);
+    
+    /**
+     * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+     * Neither determinism nor randomness of selection is guaranteed.
+     * 
+     * @param parameterSeedMask
+     *            a mask that extracts those parameters of the query (from the entire parameter list) that should be
+     *            bound to a fixed value
+     * @param parameters
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold
+     * @return a match represented in the internal {@link Tuple} representation.
+     * @since 2.0
+     */
+    public Optional<Tuple> getOneArbitraryMatch(TupleMask parameterSeedMask, ITuple parameters); 
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameters
+     *            array where each non-null element binds the corresponding pattern parameter to a fixed value.
+     * @pre size of input array must be equal to the number of parameters.
+     * @return matches represented in the internal {@link Tuple} representation.
+     * @since 2.0
+     */
+    public Stream<Tuple> getAllMatches(Object[] parameters);
+    
+    /**
+     * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+     *
+     * @param parameterSeedMask
+     *            a mask that extracts those parameters of the query (from the entire parameter list) that should be
+     *            bound to a fixed value
+     * @param parameters
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold
+     * @return matches represented in the internal {@link Tuple} representation.
+     * @since 2.0
+     */
+    public Stream<Tuple> getAllMatches(TupleMask parameterSeedMask, ITuple parameters); 
+    
+    /**
+     * The underlying query evaluator backend.
+     */
+    public IQueryBackend getQueryBackend();
+    
+    /**
+     * Internal method that registers low-level callbacks for match appearance and disappearance.
+     * 
+     * <p>
+     * <b>Caution: </b> This is a low-level callback that is invoked when the pattern matcher is not necessarily in a
+     * consistent state yet. Importantly, no model modification permitted during the callback.
+     * 
+     * <p>
+     * The callback can be unregistered via invoking {@link #removeUpdateListener(Object)} with the same tag.
+     * 
+     * @param listener
+     *            the listener that will be notified of each new match that appears or disappears, starting from now.
+     * @param listenerTag
+     *            a tag by which to identify the listener for later removal by {@link #removeUpdateListener(Object)}. 
+     * @param fireNow
+     *            if true, the insertion update allback will be immediately invoked on all current matches as a one-time effect. 
+     *            
+     * @throws UnsupportedOperationException if this is a non-incremental backend 
+     *  (i.e. {@link IQueryBackend#isCaching()} on {@link #getQueryBackend()} returns false)
+     */ 
+    public void addUpdateListener(final IUpdateable listener, final Object listenerTag, boolean fireNow);
+    
+    /**
+     * Removes an existing listener previously registered with the given tag.
+     *            
+     * @throws UnsupportedOperationException if this is a non-incremental backend 
+     *  (i.e. {@link IQueryBackend#isCaching()} on {@link #getQueryBackend()} returns false)
+     */
+    public void removeUpdateListener(final Object listenerTag);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IUpdateable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IUpdateable.java
new file mode 100644
index 00000000..baf7144a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IUpdateable.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Internal interface for the query backend to singal an update to a query result.
+ * @author Bergmann Gabor
+ * @since 0.9
+ *
+ */
+public interface IUpdateable {
+    
+    /**
+     * This callback method must be free of exceptions, even {@link RuntimeException}s (though not {@link Error}s).
+     * @param updateElement the tuple that is changed
+     * @param isInsertion true if the tuple appeared in the result set, false if disappeared from the result set
+     */
+    public void update(Tuple updateElement, boolean isInsertion);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryEvaluationHint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryEvaluationHint.java
new file mode 100644
index 00000000..eab92128
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryEvaluationHint.java
@@ -0,0 +1,241 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Provides VIATRA Query with additional hints on how a query should be evaluated. The same hint can be provided to multiple queries. 
+ * 
+ * <p> This class is immutable. Overriding options will create a new instance.
+ * 
+ * <p>
+ * Here be dragons: for advanced users only.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class QueryEvaluationHint {
+    
+    /**
+     * @since 2.0
+     *
+     */
+    public enum BackendRequirement {
+        /**
+         * The current hint does not specify any backend requirement
+         */
+        UNSPECIFIED,
+        /**
+         * The current hint specifies that the default search backend of the engine should be used
+         */
+        DEFAULT_SEARCH,
+        /**
+         * The current hint specifies that the default caching backend of the engine should be used
+         */
+        DEFAULT_CACHING,
+        /**
+         * The current hint specifies that a specific backend is to be used
+         */
+        SPECIFIC
+    }
+    
+    final IQueryBackendFactory queryBackendFactory; 
+    final Map<QueryHintOption<?>, Object> backendHintSettings;
+    final BackendRequirement requirement;
+
+    /**
+     * Specifies the suggested query backend requirements, and value settings for additional backend-specific options.
+     * 
+     * <p>
+     * The backend requirement type must not be {@link BackendRequirement#SPECIFIC} - for that case, use the constructor
+     * {@link #QueryEvaluationHint(Map, IQueryBackendFactory)}.
+     * 
+     * @param backendHintSettings
+     *            if non-null, each entry in the map overrides backend-specific options regarding query evaluation
+     *            (null-valued map entries permitted to erase hints); passing null means default options associated with
+     *            the query
+     * @param backendRequirementType
+     *            defines the kind of backend requirement
+     * @since 2.0
+     */
+    public QueryEvaluationHint(Map<QueryHintOption<?>, Object> backendHintSettings, BackendRequirement backendRequirementType) {
+        super();
+        Preconditions.checkArgument(backendRequirementType != null, "Specific requirement needs to be set");
+        Preconditions.checkArgument(backendRequirementType != BackendRequirement.SPECIFIC, "Specific backend requirement needs providing a corresponding backend type");
+        this.queryBackendFactory = null;
+        this.requirement = backendRequirementType; 
+        this.backendHintSettings = (backendHintSettings == null) 
+                ? Collections.<QueryHintOption<?>, Object> emptyMap()
+                : new HashMap<>(backendHintSettings);
+    }
+    
+    /**
+     * Specifies the suggested query backend, and value settings for additional backend-specific options. The first
+     * parameter can be null; if the second parameter is null, it is expected that the other constructor is called
+     * instead with a {@link BackendRequirement#UNSPECIFIED} parameter.
+     * 
+     * @param backendHintSettings
+     *            if non-null, each entry in the map overrides backend-specific options regarding query evaluation
+     *            (null-valued map entries permitted to erase hints); passing null means default options associated with
+     *            the query
+     * @param queryBackendFactory
+     *            overrides the query evaluator algorithm; passing null retains the default algorithm associated with
+     *            the query
+     * @since 1.5
+     */
+    public QueryEvaluationHint(
+            Map<QueryHintOption<?>, Object> backendHintSettings, 
+            IQueryBackendFactory queryBackendFactory) {
+        super();
+        this.queryBackendFactory = queryBackendFactory;
+        this.requirement = (queryBackendFactory == null) ? BackendRequirement.UNSPECIFIED : BackendRequirement.SPECIFIC; 
+        this.backendHintSettings = (backendHintSettings == null) 
+                ? Collections.<QueryHintOption<?>, Object> emptyMap()
+                : new HashMap<>(backendHintSettings);
+    }
+    
+    /**
+     * Returns the backend requirement described by this hint. If a specific backend is required, that can be queried by {@link #getQueryBackendFactory()}.
+     * @since 2.0
+     */
+    public BackendRequirement getQueryBackendRequirementType() {
+        return requirement;
+    }
+    
+    /**
+     * A suggestion for choosing the query evaluator algorithm.
+     * 
+     * <p>
+     * Returns null iff {@link #getQueryBackendRequirementType()} does not return {@link BackendRequirement#SPECIFIC};
+     * in such cases a corresponding default backend is selected inside the engine
+     */
+    public IQueryBackendFactory getQueryBackendFactory() {
+        return queryBackendFactory;
+    }
+    
+    /**
+     * Each entry in the immutable map overrides backend-specific options regarding query evaluation. 
+     * 
+     * <p>The map is non-null, even if empty. 
+     * Null-valued map entries are also permitted to erase hints via {@link #overrideBy(QueryEvaluationHint)}. 
+     * 
+     * @since 1.5
+     */
+    public Map<QueryHintOption<?>, Object> getBackendHintSettings() {
+        return backendHintSettings;
+    }
+
+
+    /**
+     * Override values in this hint and return a consolidated instance.
+     * 
+     * @since 1.4
+     */
+    public QueryEvaluationHint overrideBy(QueryEvaluationHint overridingHint){
+        if (overridingHint == null)
+            return this;
+        
+        BackendRequirement overriddenRequirement = this.getQueryBackendRequirementType();
+        if (overridingHint.getQueryBackendRequirementType() != BackendRequirement.UNSPECIFIED) {
+            overriddenRequirement = overridingHint.getQueryBackendRequirementType();
+        }
+        Map<QueryHintOption<?>, Object> hints = new HashMap<>(this.getBackendHintSettings());
+        if (overridingHint.getBackendHintSettings() != null) {
+            hints.putAll(overridingHint.getBackendHintSettings());
+        }
+        if (overriddenRequirement == BackendRequirement.SPECIFIC) {
+            IQueryBackendFactory factory = this.getQueryBackendFactory();
+            if (overridingHint.getQueryBackendFactory() != null) {
+                factory = overridingHint.getQueryBackendFactory();
+            }
+            return new QueryEvaluationHint(hints, factory);
+        } else {
+            return new QueryEvaluationHint(hints, overriddenRequirement);
+        }
+    }
+    
+    /**
+     * Returns whether the given hint option is overridden.
+     * @since 1.5
+     */
+    public boolean isOptionOverridden(QueryHintOption<?> option) {
+        return getBackendHintSettings().containsKey(option);
+    }
+    
+    /**
+     * Returns the value of the given hint option from the given hint collection, or null if not defined.
+     * @since 1.5
+     */
+    @SuppressWarnings("unchecked")
+    public <HintValue> HintValue getValueOrNull(QueryHintOption<HintValue> option) {
+        return (HintValue) getBackendHintSettings().get(option);
+    }
+    
+    /**
+     * Returns the value of the given hint option from the given hint collection, or the default value if not defined.
+     * Intended to be called by backends to find out the definitive value that should be considered.
+     * @since 1.5
+     */
+    public <HintValue> HintValue getValueOrDefault(QueryHintOption<HintValue> option) {
+        return option.getValueOrDefault(this);
+    }
+    
+    @Override
+    public int hashCode() {
+        return Objects.hash(backendHintSettings, queryBackendFactory, requirement);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        QueryEvaluationHint other = (QueryEvaluationHint) obj;
+        return Objects.equals(backendHintSettings, other.backendHintSettings)
+               &&
+               Objects.equals(queryBackendFactory, other.queryBackendFactory)
+               &&
+               Objects.equals(requirement, other.requirement)
+        ;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        
+        if (getQueryBackendFactory() != null)
+            sb.append("backend: ").append(getQueryBackendFactory().getBackendClass().getSimpleName());
+        if (! backendHintSettings.isEmpty()) {
+            sb.append("hints: ");
+            if(backendHintSettings instanceof AbstractMap){
+                sb.append(backendHintSettings.toString());
+            } else {
+                // we have to iterate on the contents
+                
+                String joinedHintMap = backendHintSettings.entrySet().stream()
+                        .map(setting -> setting.getKey() + "=" + setting.getValue()).collect(Collectors.joining(", "));
+                sb.append('{').append(joinedHintMap).append('}');
+            }            
+        }
+        
+        final String result = sb.toString();
+        return result.isEmpty() ? "defaults" : result;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryHintOption.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryHintOption.java
new file mode 100644
index 00000000..2c6bb4de
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryHintOption.java
@@ -0,0 +1,122 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Each instance of this class corresponds to a given hint option.
+ * 
+ * It is recommended to expose options to clients (and query backends) as public static fields.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.5
+ */
+public class QueryHintOption<HintValue> {
+
+    private String optionQualifiedName;
+    private HintValue defaultValue;
+
+    /**
+     * Instantiates an option object with the given name and default value.
+     */
+    public QueryHintOption(String optionQualifiedName, HintValue defaultValue) {
+        this.optionQualifiedName = optionQualifiedName;
+        this.defaultValue = defaultValue;
+    }
+    
+    /**
+     * This is the recommended constructor for hint options defined as static fields within an enclosing class. 
+     * Combines the qualified name of the hint from the (qualified) name of the enclosing class and a local name (unique within that class).  
+     */
+    public <T extends HintValue> QueryHintOption(Class<?> optionNamespace, String optionLocalName, T defaultValue) {
+        this(String.format("%s@%s", optionLocalName, optionNamespace.getName()), defaultValue);
+    }
+
+    /**
+     * Returns the qualified name, a unique string identifier of the option.
+     */
+    public String getQualifiedName() {
+        return optionQualifiedName;
+    }
+
+    /**
+     * Returns the default value of this hint option, which is to be used by query backends in the case no overriding value is assigned.
+     */
+    public HintValue getDefaultValue() {
+        return defaultValue;
+    }
+
+    /**
+     * Returns the value of this hint option from the given hint collection, or the default value if not defined.
+     * Intended to be called by backends to find out the definitive value that should be considered.
+     */
+    @SuppressWarnings("unchecked")
+    public HintValue getValueOrDefault(QueryEvaluationHint hints) {
+        Object value = hints.getValueOrNull(this);
+        if (value == null)
+            return getDefaultValue();
+        else {
+            return (HintValue) value;
+        }
+    }
+
+    
+    /**
+     * Returns the value of this hint option from the given hint collection, or null if not defined.
+     */
+    public HintValue getValueOrNull(QueryEvaluationHint hints) {
+        return hints.getValueOrNull(this);
+    }
+    
+    /**
+     * Returns whether this hint option is defined in the given hint collection.
+     */
+    public boolean isOverriddenIn(QueryEvaluationHint hints) {
+        return hints.isOptionOverridden(this);
+    }
+       
+    /**
+     * Puts a value of this hint option into an option-to-value map.
+     * 
+     * <p> This method is offered in lieu of a builder API. 
+     * Use this method on any number of hint options in order to populate an option-value map.
+     * Then instantiate the immutable {@link QueryEvaluationHint} using the map.
+     * 
+     * @see #insertValueIfNondefault(Map, Object)
+     * @return the hint value that was previously present in the map under this hint option, carrying over the semantics of {@link Map#put(Object, Object)}.  
+     */
+    @SuppressWarnings("unchecked")
+    public HintValue insertOverridingValue(Map<QueryHintOption<?>, Object> hints, HintValue overridingValue) {
+        return (HintValue) hints.put(this, overridingValue);
+    }
+
+    /**
+     * Puts a value of this hint option into an option-to-value map, if the given value differs from the default value of the option.
+     * If the default value is provided instead, then the map is not updated.
+     * 
+     * <p> This method is offered in lieu of a builder API. 
+     * Use this method on any number of hint options in order to populate an option-value map.
+     * Then instantiate the immutable {@link QueryEvaluationHint} using the map.
+     * 
+     * @see #insertOverridingValue(Map, Object)
+     * @since 2.0
+     */
+    public void insertValueIfNondefault(Map<QueryHintOption<?>, Object> hints, HintValue overridingValue) {
+        if (!Objects.equals(defaultValue, overridingValue))
+            hints.put(this, overridingValue);
+    }
+    
+    @Override
+    public String toString() {
+        return optionQualifiedName;
+    }
+        
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ResultProviderRequestor.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ResultProviderRequestor.java
new file mode 100644
index 00000000..6ec6d53e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ResultProviderRequestor.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.backend;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryResultProviderAccess;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+
+/**
+ * Uniform way of requesting result providers for pattern calls within queries.
+ * Intended users are query backends, for calling other backends to deliver results of dependee queries.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public class ResultProviderRequestor {
+    IQueryBackend callerBackend;
+    IQueryResultProviderAccess resultProviderAccess;
+    IQueryBackendHintProvider hintProvider;
+    ICallDelegationStrategy delegationStrategy;
+    QueryEvaluationHint callerHint;
+    QueryEvaluationHint universalOverride;
+    
+    
+    /**
+     * @param callerBackend the actual backend evaluating the calling pattern.  
+     * @param resultProviderAccess
+     * @param hintProvider
+     * @param delegationStrategy
+     * @param callerHint  a hint under which the calling pattern is evaluated, 
+     * @param universalOverride if non-null, overrides the hint with extra options <i>after</i> the {@link ICallDelegationStrategy}
+     */
+    public ResultProviderRequestor(IQueryBackend callerBackend, IQueryResultProviderAccess resultProviderAccess,
+            IQueryBackendHintProvider hintProvider, ICallDelegationStrategy delegationStrategy,
+            QueryEvaluationHint callerHint, QueryEvaluationHint universalOverride) {
+        super();
+        this.callerBackend = callerBackend;
+        this.resultProviderAccess = resultProviderAccess;
+        this.hintProvider = hintProvider;
+        this.delegationStrategy = delegationStrategy;
+        this.callerHint = callerHint;
+        this.universalOverride = universalOverride;
+    }
+
+
+
+
+    /**
+     * 
+     * @param call a {@link PConstraint} in a query that calls another query.
+     * @param spotOverride if non-null, overrides the hint with extra options <i>after</i> the {@link ICallDelegationStrategy} 
+     * and the universal override specified in the constructor
+     * @return the obtained result provider
+     */
+    public IQueryResultProvider requestResultProvider(IQueryReference call, QueryEvaluationHint spotOverride) {
+        QueryEvaluationHint hints = 
+                delegationStrategy.transformHints(call, callerHint, callerBackend, hintProvider);
+        
+        if (universalOverride != null)
+            hints = hints.overrideBy(universalOverride);
+        
+        if (spotOverride != null)
+            hints = hints.overrideBy(spotOverride);
+        
+        return resultProviderAccess.getResultProvider(call.getReferredQuery(), hints);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryMetaContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryMetaContext.java
new file mode 100644
index 00000000..99611758
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryMetaContext.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Common abstract class for implementers of {@link IQueryMetaContext}
+ * 
+ * @author Grill Balázs
+ * @since 1.3
+ *
+ */
+public abstract class AbstractQueryMetaContext implements IQueryMetaContext {
+    
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Map<InputKeyImplication, Set<InputKeyImplication>> getConditionalImplications(IInputKey implyingKey) {
+        return new HashMap<>();
+    }
+
+    /**
+     * @since 1.6
+     */
+    @Override
+    public boolean canLeadOutOfScope(IInputKey key) {
+        return key.getArity() > 1;
+    }
+    
+    /**
+     * @since 1.6
+     */
+    @Override
+    public Comparator<IInputKey> getSuggestedEliminationOrdering() {
+        return (o1, o2) -> 0;
+    }
+    
+    /**
+     * @since 1.6
+     */
+    @Override
+    public Collection<InputKeyImplication> getWeakenedAlternatives(IInputKey implyingKey) {
+        return Collections.emptySet();
+    }    
+
+    @Override
+    public boolean isPosetKey(IInputKey key) {
+        return false;
+    }
+
+    @Override
+    public IPosetComparator getPosetComparator(Iterable<IInputKey> key) {
+        return null;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryRuntimeContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryRuntimeContext.java
new file mode 100644
index 00000000..c797eff9
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryRuntimeContext.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+/**
+ * This class is intended to be extended by implementors. The main purpose of this abstract implementation to protect
+ * implementors from future changes in the interface.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public abstract class AbstractQueryRuntimeContext implements IQueryRuntimeContext {
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IInputKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IInputKey.java
new file mode 100644
index 00000000..4dbcca88
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IInputKey.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+/**
+ * An input key identifies an input (extensional) relation, such as the instance set of a given node or edge type, or the direct containment relation.
+ * 
+ * <p> The input key, at the very minimum, is associated with an arity (number of columns), a user-friendly name, and a string identifier (for distributive purposes). 
+ * 
+ * <p> The input key itself must be an immutable data object that properly overrides equals() and hashCode(). 
+ * It must be instantiable without using the query context object, so that query specifications may construct the appropriate PQueries. 
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public interface IInputKey {
+
+    /**
+     * A user-friendly name that can be shown on screen for debug purposes, included in exceptions, etc.
+     */
+    public String getPrettyPrintableName();
+    /**
+     * An internal string identifier that can be used to uniquely identify to input key (relevant for distributed applications).
+     */
+    public String getStringID();
+    
+    /**
+     * The width of tuples in this relation.
+     */
+    public int getArity();
+    
+    /**
+     * Returns true iff instance tuples of the key can be enumerated.
+     * <p> If false, the runtime can only test tuple membership in the extensional relation identified by the key, but not enumerate member tuples in general.
+     */
+    boolean isEnumerable();
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IPosetComparator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IPosetComparator.java
new file mode 100644
index 00000000..e2d5bcee
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IPosetComparator.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Implementations of this interface aid the query engine with the ordering of poset elements. This information is
+ * particularly important in the delete and re-derive evaluation mode because they let the engine identify monotone
+ * change pairs.
+ * 
+ * @author Tamas Szabo
+ * @since 1.6
+ */
+public interface IPosetComparator {
+
+    /**
+     * Returns true if the 'left' tuple of poset elements is smaller or equal than the 'right' tuple of poset elements according to
+     * the partial order that this poset comparator employs. 
+     * 
+     * @param left
+     *            the left tuple of poset elements
+     * @param right
+     *            the right tuple of poset elements
+     * @return true if left is smaller or equal to right, false otherwise
+     */
+    public boolean isLessOrEqual(final Tuple left, final Tuple right);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryBackendContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryBackendContext.java
new file mode 100644
index 00000000..04f00aaa
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryBackendContext.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.backend.IMatcherCapability;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendHintProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * This interface is a collector which holds every API that is provided by the engine to control
+ * the operation of the backends.
+ *
+ * @since 1.5
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IQueryBackendContext {
+
+    Logger getLogger();
+    
+    IQueryRuntimeContext getRuntimeContext();
+    
+    IQueryCacheContext getQueryCacheContext();
+    
+    IQueryBackendHintProvider getHintProvider();
+    
+    IQueryResultProviderAccess getResultProviderAccess();
+    
+    QueryAnalyzer getQueryAnalyzer();
+    
+    /**
+     * @since 2.0
+     */
+    IMatcherCapability getRequiredMatcherCapability(PQuery query, QueryEvaluationHint overrideHints);
+    
+    /**
+     * @since 1.6
+     */
+    boolean areUpdatesDelayed();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryCacheContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryCacheContext.java
new file mode 100644
index 00000000..617207f6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryCacheContext.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Provides information on already cached queries to query evaluator backends at runtime.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public interface IQueryCacheContext {
+    
+    /**
+     * Checks if there already is a caching result provider for the given query.
+     * <p> Returns false if called while the caching result provider of the given query is being constructed in the first place. 
+     */
+    public boolean isResultCached(PQuery query);
+    
+    /**
+     * Returns a caching result provider for the given query; it must be constructed if it does not exist yet.
+     * <p> <b>Caution:</b> behavior undefined if called while the caching result provider of the given query is being constructed. 
+     *   Beware of infinite loops. 
+     * <p> <b>Postcondition:</b> {@link IQueryBackend#isCaching()} returns true for the {@link #getQueryBackend()} of the returned provider
+     * 
+     * @throws ViatraQueryRuntimeException
+     */
+    public IQueryResultProvider getCachingResultProvider(PQuery query);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryMetaContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryMetaContext.java
new file mode 100644
index 00000000..4c22a3cb
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryMetaContext.java
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Provides metamodel information (relationship of input keys) to query evaluator backends at runtime and at query planning time.
+ * 
+ * @noimplement Implementors should extend {@link AbstractQueryMetaContext} instead of directly implementing this interface.
+ * @author Bergmann Gabor
+ */
+public interface IQueryMetaContext {
+        
+        /**
+         * Returns true iff instance tuples of the given key can be enumerated.
+         * <p> If false, the runtime can only test tuple membership in the extensional relation identified by the key, but not enumerate member tuples in general.
+         * <p> Equivalent to {@link IInputKey#isEnumerable()}.
+         */
+        boolean isEnumerable(IInputKey key);
+        
+        /**
+         * Returns true iff the set of instance tuples of the given key is immutable.
+         * <p> If false, the runtime provides notifications upon change.
+         */
+        boolean isStateless(IInputKey key);
+    
+    /**
+     * Returns a set of implications (weakened alternatives),
+     *  with a suggestion for the query planner that satisfying them first may help in satisfying the implying key.
+     * <p> Note that for the obvious reasons, enumerable keys can only be implied by enumerable keys.
+     * <p> Must follow directly or transitively from implications of {@link #getImplications(IInputKey)}.
+     * @since 1.6
+     */
+    Collection<InputKeyImplication> getWeakenedAlternatives(IInputKey implyingKey);
+        
+        /**
+         * Returns known direct implications, e.g. edge supertypes, edge opposites, node type constraints, etc.
+     * <p> Note that for the obvious reasons, enumerable keys can only be implied by enumerable keys.
+         */
+        Collection<InputKeyImplication> getImplications(IInputKey implyingKey);
+    
+    /**
+     * Returns known "double dispatch" implications, where the given implying key implies other input keys under certain additional conditions (themselves input keys).
+     * For example, a "type x, unscoped" input key may imply the "type x, in scope" input key under the condition of the input key "x is in scope"
+     * 
+     * <p> Note that for the obvious reasons, enumerable keys can only be implied by enumerable keys (either as the implying key or as the additional condition).
+     * <p> Note that symmetry is not required, i.e. the additional conditions do not have to list the same conditional implication.
+     * @return multi-map, where the keys are additional conditions and the values are input key implications jointly implied by the condition and the given implying key.
+     * @since 2.0
+     */
+    Map<InputKeyImplication, Set<InputKeyImplication>> getConditionalImplications(IInputKey implyingKey);
+        
+        /**
+         * Returns functional dependencies of the input key expressed in terms of column indices.
+         * 
+         * <p> Each entry of the map is a functional dependency rule, where the entry key specifies source columns and the entry value specifies target columns. 
+         */
+        Map<Set<Integer>, Set<Integer>> getFunctionalDependencies(IInputKey key);
+        
+        /**
+         * For query normalizing, this is the order suggested for trying to eliminate input keys.
+         * @since 1.6
+         */
+        Comparator<IInputKey> getSuggestedEliminationOrdering();
+        
+        /**
+         * Tells whether the given {@link IInputKey} is an edge and may lead out of scope.
+         * 
+         * @since 1.6
+         */
+        boolean canLeadOutOfScope(IInputKey key);
+
+        /**
+         * Returns true if the given {@link IInputKey} represents a poset type.    
+         * @since 1.6
+         */
+        boolean isPosetKey(IInputKey key);
+        
+        /**
+         * Returns an {@link IPosetComparator} for the given set of {@link IInputKey}s. 
+         * 
+         * @param keys an iterable collection of input keys
+         * @return the poset comparator
+         * @since 1.6
+         */
+        IPosetComparator getPosetComparator(Iterable<IInputKey> keys);
+        
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryResultProviderAccess.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryResultProviderAccess.java
new file mode 100644
index 00000000..7fecd01a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryResultProviderAccess.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import tools.refinery.viatra.runtime.matchers.backend.IQueryResultProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * This interface exposes API to request {@link IQueryResultProvider} for {@link PQuery} instances.
+ * 
+ * @author Grill Balázs
+ * @since 1.5
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IQueryResultProviderAccess {
+
+    /**
+     * Get a result provider for the given {@link PQuery}, which conforms the capabilities requested by the
+     * given {@link QueryEvaluationHint} object.
+     * @throws ViatraQueryRuntimeException 
+     */
+    public IQueryResultProvider getResultProvider(PQuery query, QueryEvaluationHint overrideHints);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContext.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContext.java
new file mode 100644
index 00000000..c2e90614
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContext.java
@@ -0,0 +1,281 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Optional;
+import java.util.concurrent.Callable;
+
+import tools.refinery.viatra.runtime.matchers.planning.helpers.StatisticsHelper;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+
+/**
+ * Provides instance model information (relations corresponding to input keys) to query evaluator backends at runtime.
+ * Implementors shall extend {@link AbstractQueryRuntimeContext} instead directly this interface.
+ * 
+ * @author Bergmann Gabor
+ * @noimplement This interface is not intended to be implemented by clients. Extend {@link AbstractQueryRuntimeContext} instead.
+ */
+public interface IQueryRuntimeContext {
+    /** 
+     * Provides metamodel-specific info independent of the runtime instance model.
+     */
+    public IQueryMetaContext getMetaContext();
+    
+    
+    /**
+     * The given callable will be executed, and all model traversals will be delayed until the execution is done. If
+     * there are any outstanding information to be read from the model, a single coalesced model traversal will
+     * initialize the caches and deliver the notifications.
+     * 
+     * <p> Calls may be nested. A single coalesced traversal will happen at the end of the outermost call.
+     * 
+     * <p> <b>Caution: </b> results returned by the runtime context may be incomplete during the coalescing period, to be corrected by notifications sent during the final coalesced traversal. 
+     * For example, if a certain input key is not cached yet, an empty relation may be reported during <code>callable.call()</code>; the cache will be constructed after the call terminates and notifications will deliver the entire content of the relation.  
+     * Non-incremental query backends should therefore never enumerate input keys while coalesced (verify using {@link #isCoalescing()}).
+     * 
+     * @param callable
+     */
+    public abstract <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException;    
+    /**
+     * @return true iff currently within a coalescing section (i.e. within the callable of a call to {@link #coalesceTraversals(Callable)}).
+     */
+    public boolean isCoalescing();
+    
+    /**
+     * Returns true if index is available for the given key providing the given service.
+     * @throws IllegalArgumentException if key is not enumerable or an unknown type, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @since 1.4
+     */
+    public boolean isIndexed(IInputKey key, IndexingService service);
+    
+    /**
+     * If the given (enumerable) input key is not yet indexed, the model will be traversed 
+     * (after the end of the outermost coalescing block, see {@link IQueryRuntimeContext#coalesceTraversals(Callable)}) 
+     * so that the index can be built. It is possible that the base indexer will select a higher indexing level merging
+     * multiple indexing requests to an appropriate level.
+     * 
+     * <p><b>Postcondition:</b> After invoking this method, {@link #getIndexed(IInputKey, IndexingService)} for the same key
+     * and service will be guaranteed to return the requested or a highing indexing level as soon as {@link #isCoalescing()} first returns false.
+     * 
+     * <p><b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException if key is not enumerable or an unknown type, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @since 1.4
+     */
+    public void ensureIndexed(IInputKey key, IndexingService service);
+    
+    /**
+     * Returns the number of tuples in the extensional relation identified by the input key seeded with the given mask and tuple.
+     * 
+     * @param key an input key 
+     * @param seedMask
+     *            a mask that extracts those parameters of the input key (from the entire parameter list) that should be
+     *            bound to a fixed value;  must not be null. <strong>Note</strong>: any given index must occur at most once in seedMask.
+     * @param seed
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold. Must not be null.
+     *  
+     * @return the number of tuples in the model for the given key and seed
+     * 
+     * <p><b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException if key is not enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @since 1.7
+     */
+    public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed);
+    
+    
+    /**
+     * Gives an estimate of the number of different groups the tuples of the given relation are projected into by the given mask
+     * (e.g. for an identity mask, this means the full relation size). The estimate must meet the required accuracy.
+     * 
+     * <p> Must accept any input key, even non-enumerables or those not recognized by this runtime context. 
+     * If there is insufficient information to provide an answer up to the required precision, {@link Optional#empty()} is returned.  
+     * 
+     * <p> PRE: {@link TupleMask#isNonrepeating()} must hold for the group mask.
+     * 
+     * @return if available, an estimate of the cardinality of the projection of the given extensional relation, with the desired accuracy.
+     * 
+     * @since 2.1
+     */
+    public Optional<Long> estimateCardinality(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy);
+    
+    
+    /**
+     * Gives an estimate of the average size of different groups the tuples of the given relation are projected into by the given mask
+     * (e.g. for an identity mask, this means 1, while for an empty mask, the result is the full relation size). 
+     * The estimate must meet the required accuracy.
+     * 
+     * <p> Must accept any input key, even non-enumerables or those not recognized by this runtime context. 
+     * If there is insufficient information to provide an answer up to the required precision, {@link Optional#empty()} may be returned.
+     * 
+     * <p> For an empty relation, zero is acceptable as an exact answer.
+     * 
+     * <p> PRE: {@link TupleMask#isNonrepeating()} must hold for the group mask.
+     * 
+     * @return if available, an estimate of the average size of each projection group of the given extensional relation, with the desired accuracy.
+     * 
+     * @since 2.1
+     */
+    public default Optional<Double> estimateAverageBucketSize(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
+        if (key.isEnumerable()) {
+            return StatisticsHelper.estimateAverageBucketSize(groupMask, requiredAccuracy, 
+                (mask, accuracy) -> this.estimateCardinality(key, mask, accuracy));
+        } else return groupMask.isIdentity() ? Optional.of(1.0) : Optional.empty();
+    }
+    
+    
+    /**
+     * Returns the tuples in the extensional relation identified by the input key, optionally seeded with the given tuple.
+     * 
+     * @param key an input key
+     * @param seedMask
+     *            a mask that extracts those parameters of the input key (from the entire parameter list) that should be
+     *            bound to a fixed value;  must not be null. <strong>Note</strong>: any given index must occur at most once in seedMask.
+     * @param seed
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold. Must not be null. 
+     * @return the tuples in the model for the given key and seed
+     * 
+     * <p><b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException if key is not enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @since 1.7
+     */
+    public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed);
+    
+    /**
+     * Simpler form of {@link #enumerateTuples(IInputKey, TupleMask, Tuple)} in the case where all values of the tuples
+     * are bound by the seed except for one.
+     * 
+     * <p>
+     * Selects the tuples in the extensional relation identified by the input key, optionally seeded with the given
+     * tuple, and then returns the single value from each tuple which is not bound by the ssed mask.
+     * 
+     * @param key
+     *            an input key
+     * @param seedMask
+     *            a mask that extracts those parameters of the input key (from the entire parameter list) that should be
+     *            bound to a fixed value; must not be null. <strong>Note</strong>: any given index must occur at most
+     *            once in seedMask, and seedMask must include all parameters in any arbitrary order except one.
+     * @param seed
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold. Must not be null.
+     * @return the objects in the model for the given key and seed
+     * 
+     *         <p>
+     *         <b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException
+     *             if key is not enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @since 1.7
+     */
+    public Iterable<? extends Object> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed);
+    
+    /**
+     * Simpler form of {@link #enumerateTuples(IInputKey, TupleMask, Tuple)} in the case where all values of the tuples
+     * are bound by the seed.
+     * 
+     * <p>
+     * Returns whether the given tuple is in the extensional relation identified by the input key.
+     * 
+     * <p>
+     * Note: this call works for non-enumerable input keys as well.
+     * 
+     * @param key
+     *            an input key
+     * @param seed
+     *            the tuple of fixed values restricting the match set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered match tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(match)) should hold. Must not be null.
+     * @return true iff there is at least a single tuple contained in the relation that corresponds to the seed tuple
+     * @since 2.0
+     */
+    public boolean containsTuple(IInputKey key, ITuple seed);
+
+    
+    /**
+     * Subscribes for updates in the extensional relation identified by the input key, optionally seeded with the given tuple.
+     * <p> This should be called after invoking 
+     * 
+     * @param key an input key
+     * @param seed can be null or a tuple with matching arity; 
+     *  if non-null, only those updates in the model are notified about 
+     *  that match the seed at positions where the seed is non-null. 
+     * @param listener will be notified of future changes
+     * 
+     * <p><b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException if key is not enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     */
+    public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener);
+    
+    /**
+     * Unsubscribes from updates in the extensional relation identified by the input key, optionally seeded with the given tuple.
+     * 
+     * @param key an input key
+     * @param seed can be null or a tuple with matching arity; 
+     *  if non-null, only those updates in the model are notified about 
+     *  that match the seed at positions where the seed is non-null. 
+     * @param listener will no longer be notified of future changes
+     * 
+     * <p><b>Precondition:</b> the given key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     * @throws IllegalArgumentException if key is not enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+     */
+    public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener);
+    /*
+     TODO: uniqueness
+     */
+    
+    /**
+     * Wraps the external element into the internal representation that is to be used by the query backend 
+     * <p> model element -> internal object.
+     * <p> null must be mapped to null.
+     */
+    public Object wrapElement(Object externalElement);
+
+    /**
+     * Unwraps the internal representation of the element into its original form  
+     * <p> internal object -> model element
+     * <p> null must be mapped to null.
+     */
+    public Object unwrapElement(Object internalElement);
+
+    /**
+     * Unwraps the tuple of elements into the internal representation that is to be used by the query backend
+     * <p> model elements -> internal objects
+     * <p> null must be mapped to null.
+    */
+    public Tuple wrapTuple(Tuple externalElements);
+
+    /**
+     * Unwraps the tuple of internal representations of elements into their original forms
+     * <p> internal objects -> model elements
+     * <p> null must be mapped to null.
+    */
+    public Tuple unwrapTuple(Tuple internalElements);
+
+    /**
+     * Starts wildcard indexing for the given service. After this call, no registration is required for this {@link IndexingService}.
+     * a previously set wildcard level cannot be lowered, only extended.
+     * @since 1.4
+     */
+    public void ensureWildcardIndexing(IndexingService service);
+    
+    /**
+     * Execute the given runnable after traversal. It is guaranteed that the runnable is executed as soon as
+     * the indexing is finished. The callback is executed only once, then is removed from the callback queue.
+     * @param traversalCallback
+     * @throws InvocationTargetException 
+     * @since 1.4
+     */
+    public void executeAfterTraversal(Runnable runnable) throws InvocationTargetException;
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContextListener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContextListener.java
new file mode 100644
index 00000000..7be27d56
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContextListener.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Listens for changes in the runtime context.
+ * @author Bergmann Gabor
+ *
+ */
+public interface IQueryRuntimeContextListener {
+    
+    /**
+     * The given tuple was inserted into or removed from the input relation indicated by the given key.
+     * @param key the key identifying the input relation that was updated
+     * @param updateTuple the tuple that was inserted or removed
+     * @param isInsertion true if it was an insertion, false otherwise.
+     */
+    public void update(IInputKey key, Tuple updateTuple, boolean isInsertion);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IndexingService.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IndexingService.java
new file mode 100644
index 00000000..8210765d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/IndexingService.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+/**
+ * These are the different services which can be provided by an {@link IQueryRuntimeContext} implementation.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public enum IndexingService {
+
+    /**
+     * Cardinality information is available. Makes possible to calculate 
+     * unseeded calls of {@link IQueryRuntimeContext#countTuples(IInputKey, tools.refinery.viatra.runtime.matchers.tuple.Tuple)}
+     */
+    STATISTICS,
+    
+    /**
+     * The indexer can provide notifications about changes in the model.
+     */
+    NOTIFICATIONS,
+    
+    /**
+     * Enables enumeration of instances and reverse-navigation.
+     */
+    INSTANCES
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/InputKeyImplication.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/InputKeyImplication.java
new file mode 100644
index 00000000..2a403810
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/InputKeyImplication.java
@@ -0,0 +1,103 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Data object representing the implication of an input key, in use cases including edge supertypes, edge opposites, node type constraints, etc.
+ * 
+ * <p> Each instance tuple of the <i>implying input key</i> (if given) implies the presence of an instance tuple of the <i>implied input key</i> consisting of elements of the original tuple at given positions.
+ * When the input key is null, it is not an input constraint but some other source that implies input keys.
+ * 
+ * <p> The implication is an immutable data object.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public final class InputKeyImplication {
+    private IInputKey implyingKey;
+    private IInputKey impliedKey;
+    private List<Integer> impliedIndices;
+
+    /**
+     * Optional. Instance tuples of this input key imply an instance tuple of another key. 
+     * Sometimes it is not an input key that implies other input keys, so this attribute can be null.
+     */
+    public IInputKey getImplyingKey() {
+        return implyingKey;
+    }
+    /**
+     * An instance tuple of this input key is implied by another key.
+     */
+    public IInputKey getImpliedKey() {
+        return impliedKey;
+    }
+    /**
+     * The implied instance tuple consists of the values in the implying tuple at these indices.
+     */
+    public List<Integer> getImpliedIndices() {
+        return impliedIndices;
+    }
+    /**
+     * @param implyingKey instance tuples of this input key imply an instance tuple of the other key.
+     * @param impliedKey instance tuple of this input key is implied by the other key.
+     * @param implyingIndices the implied instance tuple consists of the values in the implying tuple at these indices.
+     */
+    public InputKeyImplication(IInputKey implyingKey, IInputKey impliedKey,
+            List<Integer> implyingIndices) {
+        super();
+        this.implyingKey = implyingKey;
+        this.impliedKey = impliedKey;
+        this.impliedIndices = Collections.unmodifiableList(new ArrayList<>(implyingIndices));
+    }
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result
+                + ((impliedIndices == null) ? 0 : impliedIndices.hashCode());
+        result = prime * result
+                + ((impliedKey == null) ? 0 : impliedKey.hashCode());
+        result = prime * result
+                + ((implyingKey == null) ? 0 : implyingKey.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof InputKeyImplication))
+            return false;
+        InputKeyImplication other = (InputKeyImplication) obj;
+        if (impliedIndices == null) {
+            if (other.impliedIndices != null)
+                return false;
+        } else if (!impliedIndices.equals(other.impliedIndices))
+            return false;
+        if (impliedKey == null) {
+            if (other.impliedKey != null)
+                return false;
+        } else if (!impliedKey.equals(other.impliedKey))
+            return false;
+        if (implyingKey == null) {
+            if (other.implyingKey != null)
+                return false;
+        } else if (!implyingKey.equals(other.implyingKey))
+            return false;
+        return true;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/BaseInputKeyWrapper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/BaseInputKeyWrapper.java
new file mode 100644
index 00000000..f9b05e5b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/BaseInputKeyWrapper.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context.common;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+
+
+/**
+ * An input key that is identified by a single wrapped object and the class of the wrapper. 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class BaseInputKeyWrapper<Wrapped> implements IInputKey {
+    protected Wrapped wrappedKey;
+
+    public BaseInputKeyWrapper(Wrapped wrappedKey) {
+        super();
+        this.wrappedKey = wrappedKey;
+    }
+
+    public Wrapped getWrappedKey() {
+        return wrappedKey;
+    }
+    
+    
+    @Override
+    public int hashCode() {
+        return ((wrappedKey == null) ? 0 : wrappedKey.hashCode());
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(this.getClass().equals(obj.getClass())))
+            return false;
+        BaseInputKeyWrapper other = (BaseInputKeyWrapper) obj;
+        if (wrappedKey == null) {
+            if (other.wrappedKey != null)
+                return false;
+        } else if (!wrappedKey.equals(other.wrappedKey))
+            return false;
+        return true;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/JavaTransitiveInstancesKey.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/JavaTransitiveInstancesKey.java
new file mode 100644
index 00000000..eb972c2d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/JavaTransitiveInstancesKey.java
@@ -0,0 +1,165 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context.common;
+
+
+
+/**
+ * Instance tuples are of form (x), where object x is an instance of the given Java class or its subclasses.
+ * <p> Fine print 1: classes with the same name are considered equivalent. 
+ * Can be instantiated with class name, even if the class itself is not loaded yet; but if the class is available, passing it in the constructor is beneficial to avoid classloading troubles.  
+ * <p> Fine print 2: primitive types (char, etc.) are transparently treated as their wrapper class (Character, etc.). 
+ * <p> Non-enumerable type, can only be checked.
+ * <p> Stateless type (objects can't change their type)
+ * @author Bergmann Gabor
+ *
+*/
+public class JavaTransitiveInstancesKey extends BaseInputKeyWrapper<String> {
+    
+    /**
+     * The actual Class whose (transitive) instances this relation contains. Can be null at compile time, if only the name is available.
+     * Can be a primitive.  
+     */
+    private Class<?> cachedOriginalInstanceClass;
+    
+    /**
+     * Same as {@link #cachedOriginalInstanceClass}, but primitive classes are replaced with their wrapper classes (e.g. int --> java.lang.Integer).
+     */
+    private Class<?> cachedWrapperInstanceClass;
+
+    /**
+     * Preferred constructor.
+     */
+    public JavaTransitiveInstancesKey(Class<?> instanceClass) {
+        this(primitiveTypeToWrapperClass(instanceClass).getName());
+        this.cachedOriginalInstanceClass = instanceClass;
+    }
+    
+    /**
+     * Call this constructor only in contexts where the class itself is not available for loading, e.g. it has not yet been compiled.
+     */
+    public JavaTransitiveInstancesKey(String className) {
+        super(className);
+    }
+    
+
+    /**
+     * Returns null if class cannot be loaded.
+     */
+    private Class<?> getOriginalInstanceClass() {
+        if (cachedOriginalInstanceClass == null) {
+            try {
+                resolveClassInternal();
+            } catch (ClassNotFoundException e) {
+                // class not yet available at this point
+            }
+        }
+        return cachedOriginalInstanceClass;
+    }
+
+
+    /**
+     * @return non-null instance class
+     * @throws ClassNotFoundException 
+     */
+    private Class<?> forceGetOriginalInstanceClass() throws ClassNotFoundException {
+        if (cachedOriginalInstanceClass == null) {
+            resolveClassInternal();
+        }
+        return cachedOriginalInstanceClass;
+    }
+    
+    /**
+     * @return non-null instance class, wrapped if primitive class
+     * @throws ClassNotFoundException 
+     */
+    public Class<?> forceGetWrapperInstanceClass() throws ClassNotFoundException {
+        forceGetOriginalInstanceClass();
+        return getWrapperInstanceClass();
+    }
+    /**
+     * @return non-null instance class, wrapped if primitive class
+     * @throws ClassNotFoundException 
+     */
+    public Class<?> forceGetInstanceClass() throws ClassNotFoundException {
+        return forceGetWrapperInstanceClass();
+    }
+    
+    /**
+     * @return instance class, wrapped if primitive class, null if class cannot be loaded
+     */
+    public Class<?> getWrapperInstanceClass()  {
+        if (cachedWrapperInstanceClass == null) {
+            cachedWrapperInstanceClass = primitiveTypeToWrapperClass(getOriginalInstanceClass());
+        }
+        return cachedWrapperInstanceClass;
+    }
+    /**
+     * @return instance class, wrapped if primitive class, null if class cannot be loaded
+     */
+    public Class<?> getInstanceClass()  {
+        return getWrapperInstanceClass();
+    }
+    
+    private void resolveClassInternal() throws ClassNotFoundException {
+        cachedOriginalInstanceClass = Class.forName(wrappedKey);
+    }
+    
+    @Override
+    public String getPrettyPrintableName() {
+        getWrapperInstanceClass();
+        return cachedWrapperInstanceClass == null ? wrappedKey == null ? "<null>" : wrappedKey : cachedWrapperInstanceClass.getName();
+    }
+
+    @Override
+    public String getStringID() {
+        return "javaClass#"+ getPrettyPrintableName();
+    }
+
+    @Override
+    public int getArity() {
+        return 1;
+    }
+    
+    @Override
+    public boolean isEnumerable() {
+        return false;
+    }
+    
+    @Override
+    public String toString() {
+        return this.getPrettyPrintableName();
+    }
+
+    private static Class<?> primitiveTypeToWrapperClass(Class<?> instanceClass) {
+        if (instanceClass != null && instanceClass.isPrimitive()) {
+            if (Void.TYPE.equals(instanceClass))
+                return Void.class;
+            if (Boolean.TYPE.equals(instanceClass))
+                return Boolean.class;
+            if (Character.TYPE.equals(instanceClass))
+                return Character.class;
+            if (Byte.TYPE.equals(instanceClass))
+                return Byte.class;
+            if (Short.TYPE.equals(instanceClass))
+                return Short.class;
+            if (Integer.TYPE.equals(instanceClass))
+                return Integer.class;
+            if (Long.TYPE.equals(instanceClass))
+                return Long.class;
+            if (Float.TYPE.equals(instanceClass))
+                return Float.class;
+            if (Double.TYPE.equals(instanceClass))
+                return Double.class;
+        }
+        return instanceClass;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/surrogate/SurrogateQueryRegistry.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/surrogate/SurrogateQueryRegistry.java
new file mode 100644
index 00000000..bb24ec8c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/context/surrogate/SurrogateQueryRegistry.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Abel Hegedus, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.context.surrogate;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.IProvider;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import tools.refinery.viatra.runtime.matchers.util.SingletonInstanceProvider;
+
+/**
+ * @author Abel Hegedus
+ *
+ */
+public class SurrogateQueryRegistry {
+    
+    private Map<IInputKey, IProvider<PQuery>> registeredSurrogateQueryMap = new HashMap<>();
+    private Map<IInputKey, IProvider<PQuery>> dynamicSurrogateQueryMap = new HashMap<>();
+    
+    /**
+     * Hidden constructor
+     */
+    private SurrogateQueryRegistry() {
+    }
+
+    private static final SurrogateQueryRegistry INSTANCE = new SurrogateQueryRegistry();
+    
+    public static SurrogateQueryRegistry instance() {
+        return INSTANCE;
+    }
+    
+    /**
+     * 
+     * @param feature
+     * @param surrogateQuery
+     * @return the previous surrogate query associated with feature, or null if there was no such query FQN registered
+     * @throws IllegalArgumentException if feature or surrogateQuery is null 
+     */
+    public IProvider<PQuery> registerSurrogateQueryForFeature(IInputKey feature, PQuery surrogateQuery) {
+        Preconditions.checkArgument(surrogateQuery != null, "Surrogate query must not be null!");
+        return registerSurrogateQueryForFeature(feature, new SingletonInstanceProvider<PQuery>(surrogateQuery));
+    }
+
+    /**
+     * 
+     * @param feature
+     * @param surrogateQuery
+     * @return the previous surrogate query associated with feature, or null
+     *         if there was no such query registered
+     * @throws IllegalArgumentException
+     *             if feature or surrogateQuery is null
+     */
+    public IProvider<PQuery> registerSurrogateQueryForFeature(IInputKey feature, IProvider<PQuery> surrogateQueryProvider) {
+        Preconditions.checkArgument(feature != null, "Feature must not be null!");
+        Preconditions.checkArgument(surrogateQueryProvider != null, "Surrogate query must not be null!");
+        return registeredSurrogateQueryMap.put(feature, surrogateQueryProvider);
+    }
+    
+    public IProvider<PQuery> addDynamicSurrogateQueryForFeature(IInputKey feature, PQuery surrogateQuery) {
+        Preconditions.checkArgument(surrogateQuery != null, "Surrogate query FQN must not be null!");
+        return addDynamicSurrogateQueryForFeature(feature, new SingletonInstanceProvider<PQuery>(surrogateQuery));
+    }
+    
+    public IProvider<PQuery> addDynamicSurrogateQueryForFeature(IInputKey feature, IProvider<PQuery> surrogateQuery) {
+        Preconditions.checkArgument(feature != null, "Feature must not be null!");
+        Preconditions.checkArgument(surrogateQuery != null, "Surrogate query FQN must not be null!");
+        return dynamicSurrogateQueryMap.put(feature, surrogateQuery);
+    }
+
+    public IProvider<PQuery> removeDynamicSurrogateQueryForFeature(IInputKey feature) {
+        Preconditions.checkArgument(feature != null, "Feature must not be null!");
+        return dynamicSurrogateQueryMap.remove(feature);
+    }
+    
+    /**
+     * 
+     * @param feature that may have surrogate query defined, null not allowed
+     * @return true if the feature has a surrogate query defined
+     * @throws IllegalArgumentException if feature is null
+     */
+    public boolean hasSurrogateQueryFQN(IInputKey feature) {
+        Preconditions.checkArgument(feature != null, "Feature must not be null!");
+        boolean surrogateExists = dynamicSurrogateQueryMap.containsKey(feature);
+        if(!surrogateExists){
+            surrogateExists = registeredSurrogateQueryMap.containsKey(feature);
+        }
+        return surrogateExists;
+    }
+    
+    /**
+     * 
+     * @param feature for which the surrogate query FQN should be returned
+     * @return the surrogate query FQN defined for the feature
+     * @throws IllegalArgumentException if feature is null
+     * @throws NoSuchElementException if the feature has no surrogate query defined, use {@link #hasSurrogateQueryFQN} to check
+     */
+    public PQuery getSurrogateQuery(IInputKey feature) {
+        Preconditions.checkArgument(feature != null, "Feature must not be null!");
+        IProvider<PQuery> surrogate = dynamicSurrogateQueryMap.get(feature);
+        if(surrogate == null) {
+            surrogate = registeredSurrogateQueryMap.get(feature);
+        }
+        if(surrogate != null) {
+            return surrogate.get();
+        } else {
+            throw new NoSuchElementException(String.format("Feature %s has no surrogate query defined! Use #hasSurrogateQueryFQN to check existence.", feature));
+        }
+    }
+
+    /**
+     * @return an unmodifiable set of features with registered surrogate queries
+     */
+    public Set<IInputKey> getRegisteredSurrogateQueries() {
+        return Collections.unmodifiableSet(getRegisteredSurrogateQueriesInternal());
+    }
+    
+    private Set<IInputKey> getRegisteredSurrogateQueriesInternal() {
+        return registeredSurrogateQueryMap.keySet();
+    }
+    
+    /**
+     * @return an unmodifiable set of features with dynamically added surrogate queries
+     */
+    public Set<IInputKey> getDynamicSurrogateQueries() {
+        return Collections.unmodifiableSet(getDynamicSurrogateQueriesInternal());
+    }
+    
+    private Set<IInputKey> getDynamicSurrogateQueriesInternal() {
+        return dynamicSurrogateQueryMap.keySet();       
+    }
+    
+    /**
+     * @return an unmodifiable set that contains all features with surrogate queries.
+     */
+    public Set<IInputKey> getAllSurrogateQueries() {
+        Set<IInputKey> results = new HashSet<>(getRegisteredSurrogateQueriesInternal());
+        results.addAll(getDynamicSurrogateQueriesInternal());
+        return results;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/AbstractTrivialMaskedMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/AbstractTrivialMaskedMemory.java
new file mode 100644
index 00000000..66587f77
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/AbstractTrivialMaskedMemory.java
@@ -0,0 +1,58 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.matchers.util.IMemory;
+
+/**
+ * Common parts of nullary and identity specializations.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+abstract class AbstractTrivialMaskedMemory<Timestamp extends Comparable<Timestamp>> extends MaskedTupleMemory<Timestamp> {
+
+    protected IMemory<Tuple> tuples;
+
+    protected AbstractTrivialMaskedMemory(TupleMask mask, MemoryType bucketType, Object owner) {
+        super(mask, owner);
+        tuples = CollectionsFactory.createMemory(Object.class, bucketType);
+    }
+    
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(ITuple signature) {
+        throw new UnsupportedOperationException("Timeless memories do not support timestamp-based lookup!");
+    }
+
+    @Override
+    public void clear() {
+        tuples.clear();
+    }
+
+    @Override
+    public int getTotalSize() {
+        return tuples.size();
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return tuples.iterator();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/DefaultMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/DefaultMaskedTupleMemory.java
new file mode 100644
index 00000000..92081409
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/DefaultMaskedTupleMemory.java
@@ -0,0 +1,127 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup.ChangeGranularity;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ *         Default implementation that covers all cases.
+ * 
+ * @since 2.0
+ */
+public final class DefaultMaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        extends MaskedTupleMemory<Timestamp> {
+    /**
+     * Maps a signature tuple to the bucket of tuples with the given signature.
+     * 
+     * @since 2.0
+     */
+    protected IMultiLookup<Tuple, Tuple> signatureToTuples;
+
+    /**
+     * @param mask
+     *            The mask used to index the matchings
+     * @param owner
+     *            the object "owning" this memory
+     * @param bucketType
+     *            the kind of tuple collection maintained for each indexer bucket
+     * @since 2.0
+     */
+    public DefaultMaskedTupleMemory(TupleMask mask, MemoryType bucketType, Object owner) {
+        super(mask, owner);
+        signatureToTuples = CollectionsFactory.<Tuple, Tuple> createMultiLookup(Object.class, bucketType, Object.class);
+    }
+
+    @Override
+    public boolean add(Tuple tuple) {
+        Tuple signature = mask.transform(tuple);
+        return add(tuple, signature);
+    }
+
+    @Override
+    public boolean add(Tuple tuple, Tuple signature) {
+        try {
+            return signatureToTuples.addPair(signature, tuple) == ChangeGranularity.KEY;
+        } catch (IllegalStateException ex) { // ignore worthless internal exception details
+            throw raiseDuplicateInsertion(tuple);
+        }
+
+    }
+
+    @Override
+    public boolean remove(Tuple tuple) {
+        Tuple signature = mask.transform(tuple);
+        return remove(tuple, signature);
+    }
+
+    @Override
+    public boolean remove(Tuple tuple, Tuple signature) {
+        try {
+            return signatureToTuples.removePair(signature, tuple) == ChangeGranularity.KEY;
+        } catch (IllegalStateException ex) { // ignore worthless internal exception details
+            throw raiseDuplicateDeletion(tuple);
+        }
+    }
+    
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(ITuple signature) {
+        throw new UnsupportedOperationException("Timeless memories do not support timestamp-based lookup!");
+    }
+
+    @Override
+    public Collection<Tuple> get(ITuple signature) {
+        IMemoryView<Tuple> bucket = signatureToTuples.lookupUnsafe(signature);
+        return bucket == null ? null : bucket.distinctValues();
+    }
+
+    @Override
+    public void clear() {
+        signatureToTuples.clear();
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return signatureToTuples.distinctKeys();
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return signatureToTuples.distinctValues().iterator();
+    }
+
+    @Override
+    public int getTotalSize() {
+        int i = 0;
+        for (Tuple key : signatureToTuples.distinctKeys()) {
+            i += signatureToTuples.lookup(key).size();
+        }
+        return i;
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return signatureToTuples.countKeys();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/IdentityMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/IdentityMaskedTupleMemory.java
new file mode 100644
index 00000000..dc59daf5
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/IdentityMaskedTupleMemory.java
@@ -0,0 +1,77 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Collection;
+import java.util.Collections;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+
+/**
+ * Specialized for identity mask; tuples are stored as a simple set/multiset memory.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public final class IdentityMaskedTupleMemory<Timestamp extends Comparable<Timestamp>> extends AbstractTrivialMaskedMemory<Timestamp> {
+
+    /**
+     * @param mask
+     *            The mask used to index the matchings
+     * @param owner the object "owning" this memory
+     * @param bucketType the kind of tuple collection maintained for each indexer bucket
+     * @since 2.0
+     */
+    public IdentityMaskedTupleMemory(TupleMask mask, MemoryType bucketType, Object owner) {
+        super(mask, bucketType, owner);
+        if (!mask.isIdentity()) throw new IllegalArgumentException(mask.toString());
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return tuples.size();
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return tuples;
+    }
+
+    @Override
+    public Collection<Tuple> get(ITuple signature) {
+        Tuple contained = tuples.theContainedVersionOfUnsafe(signature);
+        return contained != null ? 
+                        Collections.singleton(contained) :
+                        null;
+    }
+
+    @Override
+    public boolean remove(Tuple tuple, Tuple signature) {
+        return tuples.removeOne(tuple);
+    }
+
+    @Override
+    public boolean remove(Tuple tuple) {
+        return tuples.removeOne(tuple);
+    }
+
+    @Override
+    public boolean add(Tuple tuple, Tuple signature) {
+        return tuples.addOne(tuple);
+    }
+
+    @Override
+    public boolean add(Tuple tuple) {
+        return tuples.addOne(tuple);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/MaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/MaskedTupleMemory.java
new file mode 100644
index 00000000..62377624
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/MaskedTupleMemory.java
@@ -0,0 +1,385 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.memories.timely.TimelyDefaultMaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.memories.timely.TimelyIdentityMaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.memories.timely.TimelyNullaryMaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.memories.timely.TimelyUnaryMaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Clearable;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.resumable.MaskedResumable;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Indexes a collection of tuples by their signature (i.e. footprint, projection) obtained according to a mask. May
+ * belong to an "owner" (for documentation / traceability purposes).
+ * <p>
+ * There are timeless and timely versions of the different memories. Timely versions associate {@link Timeline}s with
+ * the stored tuples.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @author Gabor Bergmann
+ * @author Tamas Szabo
+ * @since 2.0
+ */
+public abstract class MaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        implements Clearable, MaskedResumable<Timestamp> {
+
+    /**
+     * Creates a new memory for the given owner that indexes tuples according to the given mask.
+     */
+    public static <T extends Comparable<T>> MaskedTupleMemory<T> create(final TupleMask mask,
+            final MemoryType bucketType, final Object owner) {
+        return create(mask, bucketType, owner, false);
+    }
+
+    /**
+     * Creates a new memory for the given owner that indexes tuples according to the given mask. Clients can specify if
+     * the created memory should be timely or not. <br>
+     * <br>
+     * Timely means that tuples are associated with a timeline.
+     * 
+     * @since 2.3
+     */
+    public static <T extends Comparable<T>> MaskedTupleMemory<T> create(final TupleMask mask,
+            final MemoryType bucketType, final Object owner, final boolean isTimely) {
+        return create(mask, bucketType, owner, isTimely, false);
+    }
+
+    /**
+     * Creates a new memory for the given owner that indexes tuples according to the given mask. Clients can specify if
+     * the created memory should be timely or not. In case of timely memory, clients can also specify if the memory is
+     * lazy or not. <br>
+     * <br>
+     * Timely means that tuples are associated with a timeline. <br>
+     * <br>
+     * Lazyness can only be used together with timely memories. It means that the maintenance of the timelines is lazy,
+     * that is, the memory only updates its internal data structures at the timestamp affected by an update, and can be
+     * instructed later to resume the maintenance at higher timestamps, as well.
+     * 
+     * @since 2.4
+     */
+    public static <T extends Comparable<T>> MaskedTupleMemory<T> create(final TupleMask mask,
+            final MemoryType bucketType, final Object owner, final boolean isTimely, final boolean isLazy) {
+        if (isTimely) {
+            if (bucketType != MemoryType.SETS) {
+                throw new IllegalArgumentException("Timely memories only support SETS as the bucket type!");
+            }
+            if (mask.isIdentity()) {
+                return new TimelyIdentityMaskedTupleMemory<T>(mask, owner, isLazy);
+            } else if (0 == mask.getSize()) {
+                return new TimelyNullaryMaskedTupleMemory<T>(mask, owner, isLazy);
+            } else if (1 == mask.getSize()) {
+                return new TimelyUnaryMaskedTupleMemory<T>(mask, owner, isLazy);
+            } else {
+                return new TimelyDefaultMaskedTupleMemory<T>(mask, owner, isLazy);
+            }
+        } else {
+            if (isLazy) {
+                throw new IllegalArgumentException("Lazy maintenance is only supported by timely memories!");
+            }
+            if (mask.isIdentity()) {
+                return new IdentityMaskedTupleMemory<T>(mask, bucketType, owner);
+            } else if (0 == mask.getSize()) {
+                return new NullaryMaskedTupleMemory<T>(mask, bucketType, owner);
+            } else if (1 == mask.getSize()) {
+                return new UnaryMaskedTupleMemory<T>(mask, bucketType, owner);
+            } else {
+                return new DefaultMaskedTupleMemory<T>(mask, bucketType, owner);
+            }
+        }
+    }
+
+    @Override
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp) {
+        throw new UnsupportedOperationException("This is only supported by lazy timely memory implementations!");
+    }
+
+    @Override
+    public Iterable<Tuple> getResumableSignatures() {
+        throw new UnsupportedOperationException("This is only supported by lazy timely memory implementations!");
+    }
+
+    @Override
+    public Timestamp getResumableTimestamp() {
+        return null;
+    }
+
+    /**
+     * Initializes the contents of this memory based on the contents of another memory. The default value is associated
+     * with each tuple in the timely memories.
+     * 
+     * @since 2.3
+     */
+    public void initializeWith(final MaskedTupleMemory<Timestamp> other, final Timestamp defaultValue) {
+        throw new UnsupportedOperationException("This is only supported by timely memory implementations!");
+    }
+
+    /**
+     * Returns true if there is any tuple with the given signature that is present at the timestamp +inf, false
+     * otherwise.
+     * @since 2.4
+     */
+    public boolean isPresentAtInfinity(final ITuple signature) {
+        return get(signature) != null;
+    }
+
+    /**
+     * Returns true of this memory is timely, false otherwise.
+     * 
+     * @since 2.3
+     */
+    public boolean isTimely() {
+        return false;
+    }
+
+    /**
+     * The mask by which the tuples are indexed.
+     */
+    protected final TupleMask mask;
+
+    /**
+     * The object "owning" this memory. May be null.
+     * 
+     * @since 1.7
+     */
+    protected final Object owner;
+
+    /**
+     * The node owning this memory. May be null.
+     * 
+     * @since 2.0
+     */
+    public Object getOwner() {
+        return owner;
+    }
+
+    /**
+     * The mask according to which tuples are projected and indexed.
+     * 
+     * @since 2.0
+     */
+    public TupleMask getMask() {
+        return mask;
+    }
+
+    /**
+     * @return the number of distinct signatures of all stored tuples.
+     */
+    public abstract int getKeysetSize();
+
+    /**
+     * @return the total number of distinct tuples stored. Multiple copies of the same tuple, if allowed, are counted as
+     *         one.
+     * 
+     *         <p>
+     *         This is currently not cached but computed on demand. It is therefore not efficient, and shall only be
+     *         used for debug / profiling purposes.
+     */
+    public abstract int getTotalSize();
+
+    /**
+     * Iterates over distinct tuples stored in the memory, regardless of their signatures.
+     */
+    public abstract Iterator<Tuple> iterator();
+
+    /**
+     * Retrieves a read-only view of exactly those signatures for which at least one tuple is stored
+     * 
+     * @since 2.0
+     */
+    public abstract Iterable<Tuple> getSignatures();
+
+    /**
+     * Retrieves tuples that have the specified signature
+     * 
+     * @return collection of tuples found, null if none
+     */
+    public abstract Collection<Tuple> get(final ITuple signature);
+
+    /**
+     * Retrieves the tuples and their associated timelines that have the specified signature.
+     * 
+     * @return the mappings from tuples to timelines, null if there is no mapping for the signature
+     * @since 2.4
+     */
+    public abstract Map<Tuple, Timeline<Timestamp>> getWithTimeline(final ITuple signature);
+
+    /**
+     * Retrieves tuples that have the specified signature.
+     * 
+     * @return collection of tuples found, never null
+     * @since 2.1
+     */
+    public Collection<Tuple> getOrEmpty(final ITuple signature) {
+        final Collection<Tuple> result = get(signature);
+        return result == null ? Collections.emptySet() : result;
+    }
+
+    /**
+     * Retrieves tuples with their associated timelines that have the specified signature.
+     * 
+     * @return map of tuples and timelines found, never null
+     * @since 2.4
+     */
+    public Map<Tuple, Timeline<Timestamp>> getOrEmptyWithTimeline(final ITuple signature) {
+        final Map<Tuple, Timeline<Timestamp>> result = getWithTimeline(signature);
+        return result == null ? Collections.emptyMap() : result;
+    }
+
+    /**
+     * Removes a tuple occurrence from the memory with the given signature.
+     * 
+     * @param tuple
+     *            the tuple to be removed from the memory
+     * @param signature
+     *            precomputed footprint of the tuple according to the mask
+     * 
+     * @return true if this was the the last occurrence of the signature (according to the mask)
+     */
+    public boolean remove(final Tuple tuple, final Tuple signature) {
+        throw new UnsupportedOperationException("This is only supported by timeless memory implementations!");
+    }
+
+    /**
+     * Removes a tuple occurrence from the memory with the given signature and timestamp.
+     * 
+     * @param tuple
+     *            the tuple to be removed from the memory
+     * @param signature
+     *            precomputed footprint of the tuple according to the mask
+     * @param timestamp
+     *            the timestamp associated with the tuple
+     * 
+     * @return A {@link Diff} describing how the timeline of the given tuple changed.
+     * 
+     * @since 2.4
+     */
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        throw new UnsupportedOperationException("This is only supported by timely memory implementations!");
+    }
+
+    /**
+     * Removes a tuple occurrence from the memory.
+     * 
+     * @param tuple
+     *            the tuple to be removed from the memory
+     * 
+     * @return true if this was the the last occurrence of the signature (according to the mask)
+     */
+    public boolean remove(final Tuple tuple) {
+        throw new UnsupportedOperationException("This is only supported by timeless memory implementations!");
+    }
+
+    /**
+     * Removes a tuple occurrence from the memory with the given timestamp.
+     * 
+     * @param tuple
+     *            the tuple to be removed from the memory
+     * @param timestamp
+     *            the timestamp associated with the tuple
+     * 
+     * @return A {@link Diff} describing how the timeline of the given tuple changed.
+     * 
+     * @since 2.4
+     */
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        throw new UnsupportedOperationException("This is only supported by timely memory implementations!");
+    }
+
+    /**
+     * Adds a tuple occurrence to the memory with the given signature.
+     * 
+     * @param tuple
+     *            the tuple to be added to the memory
+     * @param signature
+     *            precomputed footprint of the tuple according to the mask
+     * 
+     * @return true if new signature encountered (according to the mask)
+     */
+    public boolean add(final Tuple tuple, final Tuple signature) {
+        throw new UnsupportedOperationException("This is only supported by timeless memory implementations!");
+    }
+
+    /**
+     * Adds a tuple occurrence to the memory with the given signature and timestamp.
+     * 
+     * @param tuple
+     *            the tuple to be added to the memory
+     * @param signature
+     *            precomputed footprint of the tuple according to the mask
+     * @param timestamp
+     *            the timestamp associated with the tuple
+     * 
+     * @return A {@link Diff} describing how the timeline of the given tuple changed.
+     * 
+     * @since 2.4
+     */
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        throw new UnsupportedOperationException("This is only supported by timely memory implementations!");
+    }
+
+    /**
+     * Adds a tuple occurrence to the memory.
+     * 
+     * @param tuple
+     *            the tuple to be added to the memory
+     * 
+     * @return true if new signature encountered (according to the mask)
+     */
+    public boolean add(final Tuple tuple) {
+        throw new UnsupportedOperationException("This is only supported by timeless memory implementations!");
+    }
+
+    /**
+     * Adds a tuple occurrence to the memory with the given timestamp.
+     * 
+     * @param tuple
+     *            the tuple to be added to the memory
+     * @param timestamp
+     *            the timestamp associated with the tuple
+     * 
+     * @return A {@link Diff} describing how the timeline of the given tuple changed.
+     * 
+     * @since 2.4
+     */
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        throw new UnsupportedOperationException("This is only supported by timely memory implementations!");
+    }
+
+    protected MaskedTupleMemory(final TupleMask mask, final Object owner) {
+        super();
+        this.mask = mask;
+        this.owner = owner;
+    }
+
+    protected IllegalStateException raiseDuplicateInsertion(final Tuple tuple) {
+        return new IllegalStateException(String.format("Duplicate insertion of tuple %s into %s", tuple, owner));
+    }
+
+    protected IllegalStateException raiseDuplicateDeletion(final Tuple tuple) {
+        return new IllegalStateException(String.format("Duplicate deletion of tuple %s from %s", tuple, owner));
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "<" + mask + ">@" + owner;
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/NullaryMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/NullaryMaskedTupleMemory.java
new file mode 100644
index 00000000..7fa9e053
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/NullaryMaskedTupleMemory.java
@@ -0,0 +1,85 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+
+/**
+ * Specialized for nullary mask; tuples are stored as a simple set/multiset memory.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public final class NullaryMaskedTupleMemory<Timestamp extends Comparable<Timestamp>> extends AbstractTrivialMaskedMemory<Timestamp> {
+
+    protected static final Set<Tuple> UNIT_RELATION = 
+            Collections.singleton(Tuples.staticArityFlatTupleOf());
+    protected static final Set<Tuple> EMPTY_RELATION = 
+            Collections.emptySet();
+    /**
+     * @param mask
+     *            The mask used to index the matchings
+     * @param owner the object "owning" this memory
+     * @param bucketType the kind of tuple collection maintained for each indexer bucket
+     * @since 2.0
+     */
+    public NullaryMaskedTupleMemory(TupleMask mask, MemoryType bucketType, Object owner) {
+        super(mask, bucketType, owner);
+        if (0 != mask.getSize()) throw new IllegalArgumentException(mask.toString());
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return tuples.isEmpty() ? 0 : 1;
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return tuples.isEmpty() ? EMPTY_RELATION : UNIT_RELATION;
+    }
+
+    @Override
+    public Collection<Tuple> get(ITuple signature) {
+        if (0 == signature.getSize())
+            return tuples.distinctValues(); 
+        else return null;
+    }
+
+    @Override
+    public boolean remove(Tuple tuple, Tuple signature) {
+        tuples.removeOne(tuple);
+        return tuples.isEmpty();
+    }
+
+    @Override
+    public boolean remove(Tuple tuple) {
+        return remove(tuple, null);
+    }
+
+    @Override
+    public boolean add(Tuple tuple, Tuple signature) {
+        boolean wasEmpty = tuples.isEmpty();
+        tuples.addOne(tuple);
+        return wasEmpty;
+    }
+
+    @Override
+    public boolean add(Tuple tuple) {
+        return add(tuple, null);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/UnaryMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/UnaryMaskedTupleMemory.java
new file mode 100644
index 00000000..f34cc9e3
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/UnaryMaskedTupleMemory.java
@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup.ChangeGranularity;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Specialized for unary mask; tuples are indexed by a single column as opposed to a projection (signature) tuple.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public final class UnaryMaskedTupleMemory<Timestamp extends Comparable<Timestamp>> extends MaskedTupleMemory<Timestamp> {
+
+    protected IMultiLookup<Object, Tuple> columnToTuples;
+    protected final int keyPosition;
+
+    /**
+     * @param mask
+     *            The mask used to index the matchings
+     * @param owner the object "owning" this memory
+     * @param bucketType the kind of tuple collection maintained for each indexer bucket
+     * @since 2.0
+     */
+    public UnaryMaskedTupleMemory(TupleMask mask, MemoryType bucketType, Object owner) {
+        super(mask, owner);
+        if (1 != mask.getSize()) throw new IllegalArgumentException(mask.toString());
+        
+        columnToTuples = CollectionsFactory.<Object, Tuple>createMultiLookup(
+                Object.class, bucketType, Object.class);
+        keyPosition = mask.indices[0];
+    }
+    
+    @Override
+    public void clear() {
+        columnToTuples.clear();
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return columnToTuples.countKeys();
+    }
+
+    @Override
+    public int getTotalSize() {
+        int i = 0;
+        for (Object key : columnToTuples.distinctKeys()) {
+            i += columnToTuples.lookup(key).size();
+        }
+        return i;
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return columnToTuples.distinctValues().iterator();
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return () -> {
+            Iterator<Object> wrapped = columnToTuples.distinctKeys().iterator();
+            return new Iterator<Tuple>() {
+                @Override
+                public boolean hasNext() {
+                    return wrapped.hasNext();
+                }
+                @Override
+                public Tuple next() {
+                    Object key = wrapped.next();
+                    return Tuples.staticArityFlatTupleOf(key);
+                }
+            };
+        };
+    }
+
+    @Override
+    public Collection<Tuple> get(ITuple signature) {
+        Object key = signature.get(0);
+        IMemoryView<Tuple> bucket = columnToTuples.lookup(key);
+        return bucket == null ? null : bucket.distinctValues();
+    }
+    
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(ITuple signature) {
+        throw new UnsupportedOperationException("Timeless memories do not support timestamp-based lookup!");
+    }
+
+    @Override
+    public boolean remove(Tuple tuple, Tuple signature) {
+        return removeInternal(tuple, tuple.get(keyPosition));
+    }
+
+    @Override
+    public boolean remove(Tuple tuple) {
+        return removeInternal(tuple, tuple.get(keyPosition));
+    }
+
+    @Override
+    public boolean add(Tuple tuple, Tuple signature) {
+        return addInternal(tuple, tuple.get(keyPosition));
+    }
+
+    @Override
+    public boolean add(Tuple tuple) {
+        return addInternal(tuple, tuple.get(keyPosition));
+    }
+    
+    protected boolean addInternal(Tuple tuple, Object key) {
+        try {
+            return columnToTuples.addPair(key, tuple) == ChangeGranularity.KEY;
+        } catch (IllegalStateException ex) { // ignore worthless internal exception details
+            throw raiseDuplicateInsertion(tuple);
+        }
+    }
+    
+    protected boolean removeInternal(Tuple tuple, Object key) {
+        try {
+            return columnToTuples.removePair(key, tuple) == ChangeGranularity.KEY;
+        } catch (IllegalStateException ex) { // ignore worthless internal exception details
+            throw raiseDuplicateDeletion(tuple);
+        }
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyMaskedMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyMaskedMemory.java
new file mode 100644
index 00000000..45ce3a4e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyMaskedMemory.java
@@ -0,0 +1,228 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeMap;
+
+import tools.refinery.viatra.runtime.matchers.memories.MaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Common parts of timely default and timely unary implementations.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+abstract class AbstractTimelyMaskedMemory<Timestamp extends Comparable<Timestamp>, KeyType>
+        extends MaskedTupleMemory<Timestamp> {
+
+    protected final TreeMap<Timestamp, Set<KeyType>> foldingStates;
+    protected final Map<KeyType, TimelyMemory<Timestamp>> memoryMap;
+    protected final boolean isLazy;
+
+    public AbstractTimelyMaskedMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner);
+        this.isLazy = isLazy;
+        this.memoryMap = CollectionsFactory.createMap();
+        this.foldingStates = this.isLazy ? CollectionsFactory.createTreeMap() : null;
+    }
+
+    @Override
+    public void initializeWith(final MaskedTupleMemory<Timestamp> other, final Timestamp defaultValue) {
+        final Iterable<Tuple> signatures = other.getSignatures();
+        for (final Tuple signature : signatures) {
+            if (other.isTimely()) {
+                final Map<Tuple, Timeline<Timestamp>> tupleMap = other.getWithTimeline(signature);
+                for (final Entry<Tuple, Timeline<Timestamp>> entry : tupleMap.entrySet()) {
+                    for (final Signed<Timestamp> signed : entry.getValue().asChangeSequence()) {
+                        if (signed.getDirection() == Direction.DELETE) {
+                            this.removeWithTimestamp(entry.getKey(), signed.getPayload());
+                        } else {
+                            this.addWithTimestamp(entry.getKey(), signed.getPayload());
+                        }
+                    }
+                }
+            } else {
+                final Collection<Tuple> tuples = other.get(signature);
+                for (final Tuple tuple : tuples) {
+                    this.addWithTimestamp(tuple, defaultValue);
+                }
+            }
+        }
+    }
+
+    public boolean isPresentAtInfinityInteral(KeyType key) {
+        final TimelyMemory<Timestamp> values = this.memoryMap.get(key);
+        if (values == null) {
+            return false;
+        } else {
+            return values.getCountAtInfinity() != 0;
+        }
+    }
+
+    @Override
+    public void clear() {
+        this.memoryMap.clear();
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return this.memoryMap.keySet().size();
+    }
+
+    @Override
+    public int getTotalSize() {
+        int i = 0;
+        for (final Entry<KeyType, TimelyMemory<Timestamp>> entry : this.memoryMap.entrySet()) {
+            i += entry.getValue().size();
+        }
+        return i;
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return this.memoryMap.values().stream().flatMap(e -> e.keySet().stream()).iterator();
+    }
+
+    protected Collection<Tuple> getInternal(final KeyType key) {
+        final TimelyMemory<Timestamp> memory = this.memoryMap.get(key);
+        if (memory == null) {
+            return null;
+        } else {
+            return memory.getTuplesAtInfinity();
+        }
+    }
+
+    public Map<Tuple, Timeline<Timestamp>> getWithTimestampInternal(final KeyType key) {
+        final TimelyMemory<Timestamp> memory = this.memoryMap.get(key);
+        if (memory == null) {
+            return null;
+        } else {
+            return memory.asMap();
+        }
+    }
+
+    protected Diff<Timestamp> removeInternal(final KeyType key, final Tuple tuple, final Timestamp timestamp) {
+        Timestamp oldResumableTimestamp = null;
+        Timestamp newResumableTimestamp = null;
+        
+        final TimelyMemory<Timestamp> keyMemory = this.memoryMap.get(key);
+        if (keyMemory == null) {
+            throw raiseDuplicateDeletion(tuple);
+        }
+        
+        if (this.isLazy) {            
+            oldResumableTimestamp = keyMemory.getResumableTimestamp();
+        }
+        
+        Diff<Timestamp> diff = null;
+        try {
+            diff = keyMemory.remove(tuple, timestamp);
+        } catch (final IllegalStateException e) {
+            throw raiseDuplicateDeletion(tuple);
+        }
+        if (keyMemory.isEmpty()) {
+            this.memoryMap.remove(key);
+        }
+        
+        if (this.isLazy) {            
+            newResumableTimestamp = keyMemory.getResumableTimestamp();
+            if (!Objects.equals(oldResumableTimestamp, newResumableTimestamp)) {
+                unregisterFoldingState(oldResumableTimestamp, key);
+                registerFoldingState(newResumableTimestamp, key);
+            }
+        }
+        
+        return diff;
+    }
+
+    protected Diff<Timestamp> addInternal(final KeyType key, final Tuple tuple, final Timestamp timestamp) {
+        Timestamp oldResumableTimestamp = null;
+        Timestamp newResumableTimestamp = null;
+                
+        final TimelyMemory<Timestamp> keyMemory = this.memoryMap.computeIfAbsent(key,
+                k -> new TimelyMemory<Timestamp>(this.isLazy));
+        
+        if (this.isLazy) {            
+            oldResumableTimestamp = keyMemory.getResumableTimestamp();
+        }
+        
+        final Diff<Timestamp> diff = keyMemory.put(tuple, timestamp);
+        
+        if (this.isLazy) {            
+            newResumableTimestamp = keyMemory.getResumableTimestamp();
+            if (!Objects.equals(oldResumableTimestamp, newResumableTimestamp)) {
+                unregisterFoldingState(oldResumableTimestamp, key);
+                registerFoldingState(newResumableTimestamp, key);
+            }
+        }
+        
+        return diff;
+    }
+    
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        return removeWithTimestamp(tuple, null, timestamp);
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        return addWithTimestamp(tuple, null, timestamp);
+    }
+
+    @Override
+    public boolean isTimely() {
+        return true;
+    }
+    
+    protected void registerFoldingState(final Timestamp timestamp, final KeyType key) {
+        if (timestamp != null) {
+            this.foldingStates.compute(timestamp, (k, v) -> {
+                if (v == null) {
+                    v = CollectionsFactory.createSet();
+                }
+                v.add(key);
+                return v;
+            });
+        }
+    }
+    
+    protected void unregisterFoldingState(final Timestamp timestamp, final KeyType key) {
+        if (timestamp != null) {
+            this.foldingStates.compute(timestamp, (k, v) -> {
+                v.remove(key);
+                return v.isEmpty() ? null : v;
+            });
+        }
+    }
+    
+    @Override
+    public Timestamp getResumableTimestamp() {
+        if (this.foldingStates == null || this.foldingStates.isEmpty()) {
+            return null;
+        } else {
+            return this.foldingStates.firstKey();
+        }
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyTrivialMaskedMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyTrivialMaskedMemory.java
new file mode 100644
index 00000000..ca06685a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyTrivialMaskedMemory.java
@@ -0,0 +1,100 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import tools.refinery.viatra.runtime.matchers.memories.MaskedTupleMemory;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Common parts of timely nullary and timely identity implementations.
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+abstract class AbstractTimelyTrivialMaskedMemory<Timestamp extends Comparable<Timestamp>> extends MaskedTupleMemory<Timestamp> {
+
+    protected final TimelyMemory<Timestamp> memory;
+
+    protected AbstractTimelyTrivialMaskedMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner);
+        this.memory = new TimelyMemory<Timestamp>(isLazy);
+    }
+    
+    @Override
+    public void initializeWith(final MaskedTupleMemory<Timestamp> other, final Timestamp defaultValue) {
+        final Iterable<Tuple> signatures = other.getSignatures();
+        for (final Tuple signature : signatures) {
+            if (other.isTimely()) {
+                final Map<Tuple, Timeline<Timestamp>> tupleMap = other.getWithTimeline(signature);
+                for (final Entry<Tuple, Timeline<Timestamp>> entry : tupleMap.entrySet()) {
+                    for (final Signed<Timestamp> signed : entry.getValue().asChangeSequence()) {
+                        if (signed.getDirection() == Direction.DELETE) {
+                            this.removeWithTimestamp(entry.getKey(), signed.getPayload());
+                        } else {
+                            this.addWithTimestamp(entry.getKey(), signed.getPayload());                                            
+                        }
+                    }
+                }                
+            } else {
+                final Collection<Tuple> tuples = other.get(signature);
+                for (final Tuple tuple : tuples) {
+                    this.removeWithTimestamp(tuple, defaultValue);
+                }
+            }
+        }            
+    }
+
+    @Override
+    public void clear() {
+        this.memory.clear();
+    }
+
+    @Override
+    public int getTotalSize() {
+        return this.memory.size();
+    }
+
+    @Override
+    public Iterator<Tuple> iterator() {
+        return this.memory.keySet().iterator();
+    }
+    
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        return removeWithTimestamp(tuple, null, timestamp);
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Timestamp timestamp) {
+        return addWithTimestamp(tuple, null, timestamp);
+    }
+    
+    @Override
+    public boolean isTimely() {
+        return true;
+    }
+        
+    @Override
+    public Timestamp getResumableTimestamp() {
+        return this.memory.getResumableTimestamp();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyDefaultMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyDefaultMaskedTupleMemory.java
new file mode 100644
index 00000000..623d7399
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyDefaultMaskedTupleMemory.java
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Default timely implementation that covers all cases.
+ * 
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public final class TimelyDefaultMaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        extends AbstractTimelyMaskedMemory<Timestamp, Tuple> {
+
+    public TimelyDefaultMaskedTupleMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner, isLazy);
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return this.memoryMap.keySet();
+    }
+
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Tuple signature,
+            final Timestamp timestamp) {
+        final Tuple key = mask.transform(tuple);
+        return removeInternal(key, tuple, timestamp);
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Tuple signature,
+            final Timestamp timestamp) {
+        final Tuple key = this.mask.transform(tuple);
+        return addInternal(key, tuple, timestamp);
+    }
+
+    @Override
+    public Collection<Tuple> get(final ITuple signature) {
+        return getInternal(signature.toImmutable());
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(final ITuple signature) {
+        return getWithTimestampInternal(signature.toImmutable());
+    }
+    
+    @Override
+    public boolean isPresentAtInfinity(final ITuple signature) {
+        return isPresentAtInfinityInteral(signature.toImmutable());
+    }
+    
+    @Override
+    public Set<Tuple> getResumableSignatures() {
+        if (this.foldingStates == null || this.foldingStates.isEmpty()) {
+            return Collections.emptySet();
+        } else {
+            return this.foldingStates.firstEntry().getValue();
+        }
+    }
+    
+    @Override
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp) {
+        final Map<Tuple, Map<Tuple, Diff<Timestamp>>> result = CollectionsFactory.createMap();
+        final Timestamp resumableTimestamp = this.getResumableTimestamp();
+        if (resumableTimestamp == null || resumableTimestamp.compareTo(timestamp) != 0) {
+            throw new IllegalStateException("Expected to continue folding at " + resumableTimestamp + "!");
+        }
+        final Set<Tuple> signatures = this.foldingStates.remove(timestamp);
+        for (final Tuple signature : signatures) {
+            final TimelyMemory<Timestamp> memory = this.memoryMap.get(signature);
+            final Map<Tuple, Diff<Timestamp>> diffMap = memory.resumeAt(resumableTimestamp);
+            result.put(signature, diffMap);
+            registerFoldingState(memory.getResumableTimestamp(), signature);
+        }
+        return result;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyIdentityMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyIdentityMaskedTupleMemory.java
new file mode 100644
index 00000000..568f274d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyIdentityMaskedTupleMemory.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Timely specialization for identity mask. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public final class TimelyIdentityMaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        extends AbstractTimelyTrivialMaskedMemory<Timestamp> {
+
+    public TimelyIdentityMaskedTupleMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner, isLazy);
+        if (!mask.isIdentity())
+            throw new IllegalArgumentException(mask.toString());
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return this.memory.size();
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return this.memory.keySet();
+    }
+
+    @Override
+    public Collection<Tuple> get(final ITuple signature) {
+        if (this.memory.getTuplesAtInfinity().contains(signature)) {
+            return Collections.singleton(signature.toImmutable());
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(final ITuple signature) {
+        final Timeline<Timestamp> value = this.memory.get(signature);
+        if (value != null) {
+            return Collections.singletonMap(signature.toImmutable(), value);
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        try {
+            return this.memory.remove(tuple, timestamp);
+        } catch (final IllegalStateException e) {
+            throw raiseDuplicateDeletion(tuple);
+        }
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        return this.memory.put(tuple, timestamp);
+    }
+
+    @Override
+    public boolean isPresentAtInfinity(final ITuple signature) {
+        return this.memory.isPresentAtInfinity(signature.toImmutable());
+    }
+
+    @Override
+    public Set<Tuple> getResumableSignatures() {
+        if (this.memory.getResumableTimestamp() != null) {
+            return this.memory.getResumableTuples();
+        } else {
+            return Collections.emptySet();
+        }
+    }
+
+    @Override
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp) {
+        final Map<Tuple, Diff<Timestamp>> diffMap = this.memory.resumeAt(timestamp);
+        final Map<Tuple, Map<Tuple, Diff<Timestamp>>> result = CollectionsFactory.createMap();
+        for (final Entry<Tuple, Diff<Timestamp>> entry : diffMap.entrySet()) {
+            result.put(entry.getKey(), Collections.singletonMap(entry.getKey(), entry.getValue()));
+        }
+        return result;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyNullaryMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyNullaryMaskedTupleMemory.java
new file mode 100644
index 00000000..75987a89
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyNullaryMaskedTupleMemory.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Timely specialization for nullary mask. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public final class TimelyNullaryMaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        extends AbstractTimelyTrivialMaskedMemory<Timestamp> {
+
+    protected static final Tuple EMPTY_TUPLE = Tuples.staticArityFlatTupleOf();
+    protected static final Set<Tuple> UNIT_RELATION = Collections.singleton(EMPTY_TUPLE);
+    protected static final Set<Tuple> EMPTY_RELATION = Collections.emptySet();
+
+    public TimelyNullaryMaskedTupleMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner, isLazy);
+        if (0 != mask.getSize()) {
+            throw new IllegalArgumentException(mask.toString());
+        }
+    }
+
+    @Override
+    public int getKeysetSize() {
+        return this.memory.isEmpty() ? 0 : 1;
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return this.memory.isEmpty() ? EMPTY_RELATION : UNIT_RELATION;
+    }
+
+    @Override
+    public Collection<Tuple> get(final ITuple signature) {
+        if (0 == signature.getSize()) {
+            return this.memory.getTuplesAtInfinity();
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(final ITuple signature) {
+        if (0 == signature.getSize()) {
+            return this.memory.asMap();
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        try {
+            return this.memory.remove(tuple, timestamp);
+        } catch (final IllegalStateException e) {
+            throw raiseDuplicateDeletion(tuple);
+        }
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        return this.memory.put(tuple, timestamp);
+    }
+
+    @Override
+    public boolean isPresentAtInfinity(final ITuple signature) {
+        if (0 == signature.getSize()) {
+            return this.memory.getCountAtInfinity() > 0;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public Set<Tuple> getResumableSignatures() {
+        if (this.memory.getResumableTimestamp() != null) {
+            return UNIT_RELATION;
+        } else {
+            return EMPTY_RELATION;
+        }
+    }
+
+    @Override
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp) {
+        return Collections.singletonMap(EMPTY_TUPLE, this.memory.resumeAt(timestamp));
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyUnaryMaskedTupleMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyUnaryMaskedTupleMemory.java
new file mode 100644
index 00000000..178193af
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyUnaryMaskedTupleMemory.java
@@ -0,0 +1,133 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.memories.timely;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.TimelyMemory;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+
+/**
+ * Timely specialization for unary mask. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public final class TimelyUnaryMaskedTupleMemory<Timestamp extends Comparable<Timestamp>>
+        extends AbstractTimelyMaskedMemory<Timestamp, Object> {
+
+    protected final int keyPosition;
+
+    public TimelyUnaryMaskedTupleMemory(final TupleMask mask, final Object owner, final boolean isLazy) {
+        super(mask, owner, isLazy);
+        if (1 != mask.getSize())
+            throw new IllegalArgumentException(mask.toString());
+        this.keyPosition = mask.indices[0];
+    }
+
+    @Override
+    public Iterable<Tuple> getSignatures() {
+        return () -> {
+            final Iterator<Object> wrapped = this.memoryMap.keySet().iterator();
+            return new Iterator<Tuple>() {
+                @Override
+                public boolean hasNext() {
+                    return wrapped.hasNext();
+                }
+
+                @Override
+                public Tuple next() {
+                    final Object key = wrapped.next();
+                    return Tuples.staticArityFlatTupleOf(key);
+                }
+            };
+        };
+    }
+
+    @Override
+    public Diff<Timestamp> removeWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        final Object key = tuple.get(keyPosition);
+        return removeInternal(key, tuple, timestamp);
+    }
+
+    @Override
+    public Diff<Timestamp> addWithTimestamp(final Tuple tuple, final Tuple signature, final Timestamp timestamp) {
+        final Object key = tuple.get(keyPosition);
+        return addInternal(key, tuple, timestamp);
+    }
+
+    @Override
+    public Collection<Tuple> get(final ITuple signature) {
+        return getInternal(signature.get(0));
+    }
+
+    @Override
+    public Map<Tuple, Timeline<Timestamp>> getWithTimeline(final ITuple signature) {
+        return getWithTimestampInternal(signature.get(0));
+    }
+
+    @Override
+    public boolean isPresentAtInfinity(ITuple signature) {
+        return isPresentAtInfinityInteral(signature.get(0));
+    }
+
+    @Override
+    public Iterable<Tuple> getResumableSignatures() {
+        if (this.foldingStates == null || this.foldingStates.isEmpty()) {
+            return Collections.emptySet();
+        } else {
+            return () -> {
+                final Iterator<Object> wrapped = this.foldingStates.firstEntry().getValue().iterator();
+                return new Iterator<Tuple>() {
+                    @Override
+                    public boolean hasNext() {
+                        return wrapped.hasNext();
+                    }
+
+                    @Override
+                    public Tuple next() {
+                        final Object key = wrapped.next();
+                        return Tuples.staticArityFlatTupleOf(key);
+                    }
+                };
+            };
+        }
+    }
+
+    @Override
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp) {
+        final Map<Tuple, Map<Tuple, Diff<Timestamp>>> result = CollectionsFactory.createMap();
+        final Timestamp resumableTimestamp = this.getResumableTimestamp();
+        if (resumableTimestamp == null) {
+            throw new IllegalStateException("There is nothing to fold!");
+        } else if (resumableTimestamp.compareTo(timestamp) != 0) {
+            throw new IllegalStateException("Expected to continue folding at " + resumableTimestamp + "!");
+        }
+        
+        final Set<Object> signatures = this.foldingStates.remove(timestamp);
+        for (final Object signature : signatures) {
+            final TimelyMemory<Timestamp> memory = this.memoryMap.get(signature);
+            final Map<Tuple, Diff<Timestamp>> diffMap = memory.resumeAt(resumableTimestamp);
+            result.put(Tuples.staticArityFlatTupleOf(signature), diffMap);
+            registerFoldingState(memory.getResumableTimestamp(), signature);
+        }
+        return result;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IOperationCompiler.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IOperationCompiler.java
new file mode 100644
index 00000000..c9f4b305
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IOperationCompiler.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+
+/**
+ * 
+ * An implicit common parameter is the "effort" PatternDescription. This
+ * indicates that the build request is part of an effort to build the matcher of
+ * the given pattern; it it important to record this during code generation so
+ * that the generated code can be separated according to patterns.
+ * 
+ * @param <Collector>
+ *            the handle of a receiver-like RETE ending to which plans can be
+ *            connected
+ * @author Gabor Bergmann
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IOperationCompiler<Collector> {
+
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public Collector patternCollector(PQuery pattern);
+ 
+    public void buildConnection(SubPlan parentPlan, Collector collector);
+    
+    /**
+     * @since 0.9
+     */
+    public void patternFinished(PQuery pattern, Collector collector);
+    
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public SubPlan patternCallPlan(Tuple nodes, PQuery supplierKey);
+
+    public SubPlan transitiveInstantiationPlan(Tuple nodes);
+
+    public SubPlan directInstantiationPlan(Tuple nodes);
+
+    public SubPlan transitiveGeneralizationPlan(Tuple nodes);
+
+    public SubPlan directGeneralizationPlan(Tuple nodes);
+
+    public SubPlan transitiveContainmentPlan(Tuple nodes);
+
+    public SubPlan directContainmentPlan(Tuple nodes);
+
+    public SubPlan binaryEdgeTypePlan(Tuple nodes, Object supplierKey);
+
+    public SubPlan ternaryEdgeTypePlan(Tuple nodes, Object supplierKey);
+
+    public SubPlan unaryTypePlan(Tuple nodes, Object supplierKey);
+
+    public SubPlan buildStartingPlan(Object[] constantValues, Object[] constantNames);
+
+    public SubPlan buildEqualityChecker(SubPlan parentPlan, int[] indices);
+
+    public SubPlan buildInjectivityChecker(SubPlan parentPlan, int subject, int[] inequalIndices);
+
+    public SubPlan buildTransitiveClosure(SubPlan parentPlan);
+
+    public SubPlan buildTrimmer(SubPlan parentPlan, TupleMask trimMask, boolean enforceUniqueness);
+
+    public SubPlan buildBetaNode(SubPlan primaryPlan, SubPlan sidePlan,
+            TupleMask primaryMask, TupleMask sideMask, TupleMask complementer, boolean negative);
+
+    public SubPlan buildCounterBetaNode(SubPlan primaryPlan, SubPlan sidePlan,
+            TupleMask primaryMask, TupleMask originalSideMask, TupleMask complementer,
+            Object aggregateResultCalibrationElement);
+
+    public SubPlan buildCountCheckBetaNode(SubPlan primaryPlan, SubPlan sidePlan,
+            TupleMask primaryMask, TupleMask originalSideMask, int resultPositionInSignature);
+
+    public SubPlan buildPredicateChecker(IExpressionEvaluator evaluator, Map<String, Integer> tupleNameMap,
+            SubPlan parentPlan);
+    public SubPlan buildFunctionEvaluator(IExpressionEvaluator evaluator, Map<String, Integer> tupleNameMap,
+            SubPlan parentPlan, Object computedResultCalibrationElement);
+    
+    /**
+     * @return an operation compiler that potentially acts on a separate container
+     */
+    public IOperationCompiler<Collector> getNextContainer();
+
+    /**
+     * @return an operation compiler that puts build actions on the tab of the given pattern
+     * @since 0.9
+     */
+    public IOperationCompiler<Collector> putOnTab(PQuery effort /*, IPatternMatcherContext context*/);
+
+    public void reinitialize();
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IQueryPlannerStrategy.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IQueryPlannerStrategy.java
new file mode 100644
index 00000000..6ce9d91b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IQueryPlannerStrategy.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+
+/**
+ * An algorithm that builds a query plan based on a PSystem representation of a body of constraints. This interface is
+ * for internal use of the various query backends.
+ * 
+ * @author Gabor Bergmann
+ */
+public interface IQueryPlannerStrategy {
+    
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public SubPlan plan(PBody pSystem, Logger logger, IQueryMetaContext context);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/QueryProcessingException.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/QueryProcessingException.java
new file mode 100644
index 00000000..501ddf73
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/QueryProcessingException.java
@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 0.9
+ */
+public class QueryProcessingException extends ViatraQueryRuntimeException {
+
+    private static final long serialVersionUID = -8272290113656867086L;
+    /**
+     * Binding the '{n}' (n = 1..N) strings to contextual conditions in 'context'
+     * 
+     * @param context
+     *            : array of context-sensitive Strings
+     */
+    protected static String bind(String message, String[] context) {
+        if (context == null) 
+            return message;
+    
+        String internal = message;
+        for (int i = 0; i < context.length; i++) {
+            internal = internal.replace("{" + (i + 1) + "}", context[i] != null ? context[i] : "<<null>>");
+        }
+        return internal;
+    }
+    
+    private Object patternDescription;
+    private String shortMessage;
+
+    /**
+     * @param message
+     *            The template of the exception message
+     * @param context
+     *            The data elements to be used to instantiate the template. Can be null if no context parameter is
+     *            defined
+     * @param patternDescription
+     *            the PatternDescription where the exception occurred
+     * @since 2.0
+     */
+    public QueryProcessingException(String message, Object patternDescription) {
+        super(message);
+        initializeFields(message, patternDescription);
+    }
+    
+    /**
+     * @param message
+     *            The template of the exception message
+     * @param context
+     *            The data elements to be used to instantiate the template. Can be null if no context parameter is
+     *            defined
+     * @param patternDescription
+     *            the PatternDescription where the exception occurred
+     */
+    public QueryProcessingException(String message, String[] context, String shortMessage, Object patternDescription) {
+        super(bind(message, context));
+        initializeFields(shortMessage, patternDescription);
+    }
+
+    /**
+     * @param message
+     *            The template of the exception message
+     * @param context
+     *            The data elements to be used to instantiate the template. Can be null if no context parameter is
+     *            defined
+     * @param patternDescription
+     *            the PatternDescription where the exception occurred
+     */
+    public QueryProcessingException(String message, String[] context, String shortMessage, Object patternDescription,
+            Throwable cause) {
+        super(bind(message, context), cause);
+        initializeFields(shortMessage, patternDescription);
+    }
+    
+    public Object getPatternDescription() {
+        return patternDescription;
+    }
+
+    public String getShortMessage() {
+        return shortMessage;
+    }
+
+    private void initializeFields(String shortMessage, Object patternDescription) {
+        this.patternDescription = patternDescription;
+        this.shortMessage = shortMessage;
+    }
+
+    
+    public void setPatternDescription(Object patternDescription) {
+        this.patternDescription = patternDescription;
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java
new file mode 100644
index 00000000..1998df9d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java
@@ -0,0 +1,240 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.TypeHelper;
+import tools.refinery.viatra.runtime.matchers.planning.operations.POperation;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PProject;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PStart;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+
+/**
+ * A plan representing a subset of (or possibly all the) constraints evaluated. A SubPlan instance is responsible for
+ * representing a state of the plan; but after it is initialized it is expected be immutable 
+ *  (exception: inferred constraints, see {@link #inferConstraint(PConstraint)}).
+ * 
+ * <p> A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans. 
+ * Important maintained information: <ul>
+ * <li>set of <b>variables</b> whose values are known when the runtime evaluation is at this stage,
+ * <li>set of <b>constraints</b> that are known to hold true at this point.
+ * </ul>
+ * 
+ * <p> Recommended to instantiate via a {@link SubPlanFactory} or subclasses, 
+ * so that query planners can subclass SubPlan if needed. 
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class SubPlan {
+    private PBody body;
+    private List<? extends SubPlan> parentPlans;
+    private POperation operation;
+
+    private final Set<PVariable> visibleVariables; 
+    private final Set<PVariable> allVariables; 
+    private final Set<PVariable> introducedVariables; // delta compared to first parent
+    private Set<PConstraint> allConstraints;
+    private Set<PConstraint> deltaConstraints; // delta compared to all parents
+    private Set<PConstraint> externallyInferredConstraints; // inferred in addition to direct consequences of the operation and parents 
+    
+
+    
+    
+    
+    /**
+     * A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans.
+     */
+    public SubPlan(PBody body, POperation operation, SubPlan... parentPlans) {
+        this(body, operation, Arrays.asList(parentPlans));
+    }
+    /**
+     * A SubPlan is constructed by applying a {@link POperation} on zero or more parent SubPlans.
+     */
+    public SubPlan(PBody body, POperation operation, List<? extends SubPlan> parentPlans) {
+        super();
+        this.body = body;
+        this.parentPlans = parentPlans;
+        this.operation = operation;
+        
+        this.externallyInferredConstraints = new HashSet<PConstraint>();
+        this.deltaConstraints = new HashSet<PConstraint>(operation.getDeltaConstraints());
+        
+        this.allVariables = new HashSet<PVariable>();
+        for (PConstraint constraint: deltaConstraints) {
+            this.allVariables.addAll(constraint.getDeducedVariables());
+        }
+        this.allConstraints = new HashSet<PConstraint>(deltaConstraints);
+        for (SubPlan parentPlan: parentPlans) {
+            this.allConstraints.addAll(parentPlan.getAllEnforcedConstraints());
+            this.allVariables.addAll(parentPlan.getAllDeducedVariables());
+        }     
+        
+        // TODO this is ugly a bit
+        if (operation instanceof PStart) {
+            this.visibleVariables = new HashSet<PVariable>(((PStart) operation).getAPrioriVariables());
+            this.allVariables.addAll(visibleVariables);
+        } else if (operation instanceof PProject) { 
+            this.visibleVariables = new HashSet<PVariable>(((PProject) operation).getToVariables());
+        } else {
+            this.visibleVariables = new HashSet<PVariable>();
+            for (SubPlan parentPlan: parentPlans)
+                this.visibleVariables.addAll(parentPlan.getVisibleVariables());
+            for (PConstraint constraint: deltaConstraints)
+                this.visibleVariables.addAll(constraint.getDeducedVariables());
+        } 
+        
+        this.introducedVariables = new HashSet<PVariable>(this.visibleVariables);
+        if (!parentPlans.isEmpty()) 
+            introducedVariables.removeAll(parentPlans.get(0).getVisibleVariables());
+        
+        operation.checkConsistency(this);
+    }
+    
+    
+    @Override
+    public String toString() {
+        return toLongString();
+    }
+    public String toShortString() {
+        return String.format("Plan{%s}:%s", 
+                visibleVariables.stream().map(PVariable::getName).collect(Collectors.joining(",")),
+                operation.getShortName());
+    }
+    public String toLongString() {
+        return String.format("%s<%s>", 
+                toShortString(),
+                parentPlans.stream().map(Object::toString).collect(Collectors.joining("; ")));
+    }
+
+
+    /**
+     * All constraints that are known to hold at this point
+     */
+    public Set<PConstraint> getAllEnforcedConstraints() {
+        return allConstraints;
+    }
+
+    /**
+     * The new constraints enforced at this stage of plan, that aren't yet enforced at parents
+     * (results are also included in {@link SubPlan#getAllEnforcedConstraints()})
+     */
+    public Set<PConstraint> getDeltaEnforcedConstraints() {
+        return deltaConstraints;
+    }
+
+    /**
+     * Indicate that a given constraint was found to be automatically satisfied at this point 
+     *   without additional operations. 
+     * (results are also included in {@link SubPlan#getDeltaEnforcedConstraints()})
+     *   
+     * <p>Warning: not propagated automatically to child plans, 
+     *  so best to invoke before constructing further SubPlans. </p>
+     */
+    public void inferConstraint(PConstraint constraint) {
+        externallyInferredConstraints.add(constraint);
+        deltaConstraints.add(constraint);
+        allConstraints.add(constraint);
+    }
+    
+    public PBody getBody() {
+        return body;
+    }
+    
+    /**
+     * Variables which are assigned a value at this point 
+     * (results are also included in {@link SubPlan#getAllDeducedVariables()})
+     */
+    public Set<PVariable> getVisibleVariables() {
+        return visibleVariables;
+    }
+    /**
+     * Variables which have been assigned a value; 
+     * includes visible variables (see {@link #getVisibleVariables()}) 
+     *   and additionally any variables hidden by a projection (see {@link PProject}). 
+     */
+    public Set<PVariable> getAllDeducedVariables() {
+        return allVariables;
+    }
+    /**
+     * Delta compared to first parent: variables that are visible here but were not visible at the first parent.
+     */
+    public Set<PVariable> getIntroducedVariables() {
+        return introducedVariables;
+    }
+    public List<? extends SubPlan> getParentPlans() {
+        return parentPlans;
+    }
+    public POperation getOperation() {
+        return operation;
+    }
+    
+    
+    /**
+     * The closure of all type judgments of enforced constraints at this point.
+     * <p> No subsumption applied.
+     */
+    public Set<TypeJudgement> getAllImpliedTypeJudgements(IQueryMetaContext context) {
+        Set<TypeJudgement> impliedJudgements = allImpliedTypeJudgements.get(context);
+        if (impliedJudgements == null) {
+            Set<TypeJudgement> equivalentJudgements = TypeHelper.getDirectJudgements(getAllEnforcedConstraints(), context);
+            impliedJudgements = TypeHelper.typeClosure(equivalentJudgements, context);
+
+            allImpliedTypeJudgements.put(context, impliedJudgements);
+        }
+        return impliedJudgements;
+    }
+    private WeakHashMap<IQueryMetaContext, Set<TypeJudgement>> allImpliedTypeJudgements = new WeakHashMap<IQueryMetaContext, Set<TypeJudgement>>();   
+    
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result
+                + ((operation == null) ? 0 : operation.hashCode());
+        result = prime * result
+                + ((parentPlans == null) ? 0 : parentPlans.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof SubPlan))
+            return false;
+        SubPlan other = (SubPlan) obj;
+        if (operation == null) {
+            if (other.operation != null)
+                return false;
+        } else if (!operation.equals(other.operation))
+            return false;
+        if (parentPlans == null) {
+            if (other.parentPlans != null)
+                return false;
+        } else if (!parentPlans.equals(other.parentPlans))
+            return false;
+        return true;
+    }
+
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlanFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlanFactory.java
new file mode 100644
index 00000000..d0df5fac
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlanFactory.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning;
+
+import tools.refinery.viatra.runtime.matchers.planning.operations.POperation;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+
+/**
+ * Single entry point for creating subplans.
+ * Can be subclassed by query planner to provide specialized SubPlans.
+ * @author Bergmann Gabor
+ *
+ */
+public class SubPlanFactory {
+
+    protected PBody body;
+
+    public SubPlanFactory(PBody body) {
+        super();
+        this.body = body;
+    }
+    
+    public SubPlan createSubPlan(POperation operation, SubPlan... parentPlans) {
+        return new SubPlan(body, operation, parentPlans);               
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/BuildHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/BuildHelper.java
new file mode 100644
index 00000000..ed5d1cbb
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/BuildHelper.java
@@ -0,0 +1,165 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning.helpers;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlanFactory;
+import tools.refinery.viatra.runtime.matchers.planning.operations.PProject;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class BuildHelper {
+
+    private BuildHelper() {
+        // Hiding constructor for utility class
+    }
+
+//    public static SubPlan naturalJoin(IOperationCompiler buildable,
+//            SubPlan primaryPlan, SubPlan secondaryPlan) {
+//        JoinHelper joinHelper = new JoinHelper(primaryPlan, secondaryPlan);
+//        return buildable.buildBetaNode(primaryPlan, secondaryPlan, joinHelper.getPrimaryMask(),
+//                joinHelper.getSecondaryMask(), joinHelper.getComplementerMask(), false);
+//    }
+    
+    
+    /**
+     * Reduces the number of tuples by trimming (existentially quantifying) the set of variables that <ul>
+     * <li> are visible in the subplan, 
+     * <li> are not exported parameters, 
+     * <li> have all their constraints already enforced in the subplan,
+     * </ul> and thus will not be needed anymore.
+     * 
+     * @param onlyIfNotDetermined if true, no trimming performed unless there is at least one variable that is not functionally determined
+     * @return the plan after the trimming (possibly the original)
+     * @since 1.5
+     */
+    public static SubPlan trimUnneccessaryVariables(SubPlanFactory planFactory, /*IOperationCompiler buildable,*/
+            SubPlan plan, boolean onlyIfNotDetermined, QueryAnalyzer analyzer) {
+        Set<PVariable> canBeTrimmed = new HashSet<PVariable>();
+        Set<PVariable> variablesInPlan = plan.getVisibleVariables();
+        for (PVariable trimCandidate : variablesInPlan) {
+            if (trimCandidate.getReferringConstraintsOfType(ExportedParameter.class).isEmpty()) {
+                if (plan.getAllEnforcedConstraints().containsAll(trimCandidate.getReferringConstraints()))
+                    canBeTrimmed.add(trimCandidate);
+            }
+        }
+        final Set<PVariable> retainedVars = setMinus(variablesInPlan, canBeTrimmed);    
+        if (!canBeTrimmed.isEmpty() && !(onlyIfNotDetermined && areVariablesDetermined(plan, retainedVars, canBeTrimmed, analyzer, false))) {
+            // TODO add smart ordering? 
+            plan = planFactory.createSubPlan(new PProject(retainedVars), plan);
+        }
+        return plan;
+    }
+    
+    /**
+     * @return true iff a set of given variables functionally determine all visible variables in the subplan according to the subplan's constraints
+     * @param strict if true, only "hard" dependencies are taken into account that are strictly enforced by the model representation; 
+     *  if false, user-provided soft dependencies are included as well, that are anticipated but not guaranteed by the storage mechanism;
+     *  use true if superfluous dependencies may taint the correctness of a computation, false if they would merely impact performance
+     * @since 1.5
+     */
+    public static boolean areAllVariablesDetermined(SubPlan plan, Collection<PVariable> determining, QueryAnalyzer analyzer, boolean strict) {
+        return areVariablesDetermined(plan, determining, plan.getVisibleVariables(), analyzer, strict);
+    }
+    
+    /**
+     * @return true iff one set of given variables functionally determine the other set according to the subplan's constraints
+     * @param strict if true, only "hard" dependencies are taken into account that are strictly enforced by the model representation; 
+     *  if false, user-provided soft dependencies are included as well, that are anticipated but not guaranteed by the storage mechanism;
+     *  use true if superfluous dependencies may taint the correctness of a computation, false if they would merely impact performance
+     * @since 1.5
+     */
+    public static boolean areVariablesDetermined(SubPlan plan, Collection<PVariable> determining, Collection<PVariable> determined, 
+            QueryAnalyzer analyzer, boolean strict) {
+        Map<Set<PVariable>, Set<PVariable>> dependencies = analyzer.getFunctionalDependencies(plan.getAllEnforcedConstraints(), strict);
+        final Set<PVariable> closure = FunctionalDependencyHelper.closureOf(determining, dependencies);
+        final boolean isDetermined = closure.containsAll(determined);
+        return isDetermined;
+    }
+
+    private static <T> Set<T> setMinus(Set<T> a, Set<T> b) {
+        Set<T> difference = new HashSet<T>(a);
+        difference.removeAll(b);
+        return difference;
+    }
+    
+    /**
+     * Finds an arbitrary constraint that is not enforced at the given plan.
+     * 
+     * @param pSystem
+     * @param plan
+     * @return a PConstraint that is not enforced, if any, or null if all are enforced
+     */
+    public static PConstraint getAnyUnenforcedConstraint(PBody pSystem,
+            SubPlan plan) {
+        Set<PConstraint> allEnforcedConstraints = plan.getAllEnforcedConstraints();
+        Set<PConstraint> constraints = pSystem.getConstraints();
+        for (PConstraint pConstraint : constraints) {
+            if (!allEnforcedConstraints.contains(pConstraint))
+                return pConstraint;
+        }
+        return null;
+    }
+    
+    /**
+     * Skips the last few steps, if any, that are projections, so that a custom projection can be added instead.
+     * Useful for connecting body final plans into the production node.
+     * 
+     * @since 2.1
+     */
+    public static SubPlan eliminateTrailingProjections(SubPlan plan) {
+        while (plan.getOperation() instanceof PProject)
+            plan = plan.getParentPlans().get(0);
+        return plan;
+    }
+
+    /**
+     * Verifies whether all constraints are enforced and exported parameters are present.
+     * 
+     * @param pSystem
+     * @param plan
+     * @throws ViatraQueryRuntimeException
+     */
+    public static void finalCheck(final PBody pSystem, SubPlan plan, IQueryMetaContext context) {
+        PConstraint unenforcedConstraint = getAnyUnenforcedConstraint(pSystem, plan);
+        if (unenforcedConstraint != null) {
+            throw new QueryProcessingException(
+                    "Pattern matcher construction terminated without successfully enforcing constraint {1}."
+                            + " Could be caused if the value of some variables can not be deduced, e.g. by circularity of pattern constraints.",
+                    new String[] { unenforcedConstraint.toString() }, "Could not enforce a pattern constraint", null);
+        }
+        for (ExportedParameter export : pSystem
+                .getConstraintsOfType(ExportedParameter.class)) {
+            if (!export.isReadyAt(plan, context)) {
+                throw new QueryProcessingException(
+                        "Exported pattern parameter {1} could not be deduced during pattern matcher construction."
+                                + " A pattern constraint is required to positively deduce its value.",
+                        new String[] { export.getParameterName() }, "Could not calculate pattern parameter",
+                        null);
+            }
+        }
+    }    
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/FunctionalDependencyHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/FunctionalDependencyHelper.java
new file mode 100644
index 00000000..40835f52
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/FunctionalDependencyHelper.java
@@ -0,0 +1,143 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Adam Dudas, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.helpers;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.util.Sets;
+
+/**
+ * Helper utility class for functional dependency analysis.
+ * 
+ * Throughout this class attribute sets are represented as generic sets and functional dependencies as maps from
+ * attribute set (generic sets) to attribute set (generic sets)
+ * 
+ * @author Adam Dudas
+ * 
+ */
+public class FunctionalDependencyHelper {
+    
+    private FunctionalDependencyHelper() {
+        // Hiding constructor for utility class
+    }
+    
+    /**
+     * Get the closure of the specified attribute set relative to the specified functional dependencies.
+     * 
+     * @param attributes
+     *            The attributes to get the closure of.
+     * @param dependencies
+     *            The functional dependencies of which the closure operation is relative to.
+     * @return The closure of the specified attribute set relative to the specified functional dependencies.
+     */
+    public static <A> Set<A> closureOf(Collection<A> attributes, Map<Set<A>, Set<A>> dependencies) {
+        Set<A> closureSet = new HashSet<A>();
+
+        for (Set<A> closureSet1 = new HashSet<A>(attributes); closureSet.addAll(closureSet1);) {
+            closureSet1 = new HashSet<A>();
+            for (Entry<Set<A>, Set<A>> dependency : dependencies.entrySet()) {
+                if (closureSet.containsAll(dependency.getKey()))
+                    closureSet1.addAll(dependency.getValue());
+            }
+        }
+
+        return closureSet;
+    }
+    
+    /**
+     * @return true if the dependency from the left set to the right set is trivial
+     * @since 1.5
+     */
+    public static <A> boolean isTrivial(Set<A> left, Set<A> right) {
+        return left.containsAll(right);
+    }
+    
+    /***
+     * Returns the dependency set over attributes in {@link targetAttributes} that are implied by a given source dependency set.
+     * <p> Note: exponential in the size of the target attribute set.
+     * <p> Note: minimality of the returned dependency set is currently not guaranteed.
+     * @param originalDependencies all dependencies that are known to hold on a wider set of attributes
+     * @param targetAttributes the set of attributes we are interested in
+     * @since 1.5
+     */
+    public static <A> Map<Set<A>, Set<A>> projectDependencies(Map<Set<A>, Set<A>> originalDependencies, Set<A> targetAttributes) {
+        // only those attributes are considered as left-hand-side candidates that occur at least once in dependencies
+        Set<A> leftCandidates = new HashSet<A>(); 
+        for (Entry<Set<A>, Set<A>> dependency : originalDependencies.entrySet()) {
+            if (!isTrivial(dependency.getKey(), dependency.getValue())) // only if non-trivial
+                leftCandidates.addAll(Sets.intersection(dependency.getKey(), targetAttributes));
+        }
+        
+        // Compute an initial list of nontrivial projected dependencies - it does not have to be minimal yet
+        Map<Set<A>, Set<A>> initialDependencies = new HashMap<Set<A>, Set<A>>();
+        for (Set<A> leftSet : Sets.powerSet(leftCandidates)) {
+            Set<A> rightSet = Sets.intersection(closureOf(leftSet, originalDependencies), targetAttributes);
+            if (!isTrivial(leftSet, rightSet)) {
+                initialDependencies.put(leftSet, rightSet);
+            }
+        }
+        // Don't forget to include constants!
+        Set<A> constants = Sets.intersection(closureOf(Collections.<A>emptySet(), originalDependencies), targetAttributes);
+        if (! constants.isEmpty()) {
+            initialDependencies.put(Collections.<A>emptySet(), constants);
+        }
+        
+        // Omit those dependencies where the LHS has superfluous attributes
+        Map<Set<A>, Set<A>> solidDependencies = new HashMap<Set<A>, Set<A>>();
+        for (Entry<Set<A>, Set<A>> dependency : initialDependencies.entrySet()) {
+            Set<A> leftSet = dependency.getKey();
+            Set<A> rightSet = dependency.getValue();
+            boolean solid = true;
+            for (A skipped : leftSet) { // what if we skip one attribute from the left set?
+                Set<A> singleton = Collections.singleton(skipped);
+                Set<A> candidate = Sets.difference(leftSet, singleton);
+                Set<A> rightCandidate = initialDependencies.get(candidate);
+                if (rightCandidate != null) {
+                    if (Sets.union(rightCandidate, singleton).containsAll(rightSet)) {
+                        solid = false;
+                        break;
+                    }
+                }
+            }
+            if (solid) {
+                solidDependencies.put(leftSet, rightSet);
+            }
+        }
+        
+        // TODO perform proper minimization, 
+        // see e.g. page 45 in http://www.cs.ubc.ca/~hkhosrav/db/slides/03.design%20theory.pdf
+        
+        return Collections.unmodifiableMap(solidDependencies);
+    }
+    
+    /**
+     * Adds a given dependency to a mutable accumulator.
+     * @since 1.5
+     */
+    public static <A> void includeDependency(Map<Set<A>, Set<A>> accumulator, Set<A> left, Set<A> right) {
+        Set<A> accumulatorRights = accumulator.computeIfAbsent(left, l -> new HashSet<>());
+        accumulatorRights.addAll(right);
+    }    
+    
+    /**
+     * Adds all given dependencies to a mutable accumulator.
+     * @since 1.5
+     */
+    public static <A> void includeDependencies(Map<Set<A>, Set<A>> accumulator, Map<Set<A>, Set<A>> additionalDependencies) {
+        for (Entry<Set<A>, Set<A>> entry : additionalDependencies.entrySet()) {
+            includeDependency(accumulator, entry.getKey(), entry.getValue());
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/StatisticsHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/StatisticsHelper.java
new file mode 100644
index 00000000..b4f848a7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/StatisticsHelper.java
@@ -0,0 +1,62 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.helpers;
+
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+import tools.refinery.viatra.runtime.matchers.tuple.TupleMask;
+import tools.refinery.viatra.runtime.matchers.util.Accuracy;
+
+/**
+ * Helpers dealing with optionally present statistics information 
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ *
+ */
+public class StatisticsHelper {
+    
+    private StatisticsHelper() {
+        // Hidden utility class constructor
+    }
+    
+    public static Optional<Double> estimateAverageBucketSize(TupleMask groupMask, Accuracy requiredAccuracy, 
+            BiFunction<TupleMask, Accuracy, Optional<Long>> estimateCardinality) 
+    {
+        if (groupMask.isIdentity()) return Optional.of(1.0);
+        
+        Accuracy numeratorAccuracy = requiredAccuracy;
+        Accuracy denominatorAccuracy = requiredAccuracy.reciprocal();
+        TupleMask identityMask = TupleMask.identity(groupMask.sourceWidth);
+        
+        Optional<Long> totalCountEstimate  = estimateCardinality.apply(identityMask, numeratorAccuracy);
+        Optional<Long> bucketCountEstimate = estimateCardinality.apply(groupMask,    denominatorAccuracy);
+
+        return totalCountEstimate.flatMap(matchCount -> 
+            bucketCountEstimate.map(bucketCount -> 
+                bucketCount == 0L ? 0L : ((double) matchCount) / bucketCount
+        ));
+    }
+
+    public static Optional<Double> min(Optional<Double> a,  Optional<Double> b) {
+        if (b.isPresent()) {
+            if (a.isPresent()) {
+                return Optional.of(Math.min(a.get(), b.get()));
+            } else return b;
+        } else return a;
+    }
+    public static Optional<Double> min(Optional<Double> a, double b) {
+        if (a.isPresent()) {
+            return Optional.of(Math.min(a.get(), b));
+        } else return Optional.of(b);
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/TypeHelper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/TypeHelper.java
new file mode 100644
index 00000000..926a591f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/TypeHelper.java
@@ -0,0 +1,217 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.planning.helpers;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Queue;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeInfoProviderConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+
+/**
+ * @author Gabor Bergmann
+ * @author Tamas Szabo
+ */
+public class TypeHelper {
+    
+    private TypeHelper() {
+        // Hiding constructor for utility class
+    }
+
+    /**
+     * Collects the type constraints for the specified collection of variables. The type constraints consist of the
+     * constraints directly enforced on the variable itself, plus all of those that the given variable is unified with
+     * through equalities.
+     * 
+     * @param variables
+     *            the variables in question
+     * @param constraints
+     *            the constraints in the pattern body
+     * @param context
+     *            the query meta context
+     * @return the mapping from variable to set of type constraints
+     * @since 1.6
+     */
+    public static Map<PVariable, Set<IInputKey>> inferUnaryTypesFor(Iterable<PVariable> variables,
+            Set<PConstraint> constraints, IQueryMetaContext context) {
+        Map<PVariable, Set<TypeJudgement>> typeMap = TypeHelper.inferUnaryTypes(constraints, context);
+        return inferUnaryTypesFor(variables, typeMap);
+    }
+
+    /**
+     * Collects the type constraints for the specified collection of variables. The type constraints consist of the
+     * constraints directly enforced on the variable itself, plus all of those that the given variable is unified with
+     * through equalities.
+     * 
+     * The method accepts a type map which is the result of the basic type inference from the
+     * {@link TypeHelper.inferUnaryTypes} method. The purpose of this method is that the type map can be reused across
+     * several calls to this method.
+     * 
+     * @param variables
+     *            the variables in question
+     * @param typeMap
+     *            the type map of inference results
+     * @return the mapping from variable to set of type constraints
+     * @since 1.6
+     */
+    public static Map<PVariable, Set<IInputKey>> inferUnaryTypesFor(Iterable<PVariable> variables,
+            Map<PVariable, Set<TypeJudgement>> typeMap) {
+        Map<PVariable, Set<IInputKey>> result = new HashMap<PVariable, Set<IInputKey>>();
+
+        for (PVariable original : variables) {
+            // it can happen that the variable was unified into an other one due to equalities
+            Set<IInputKey> keys = new HashSet<IInputKey>();
+            PVariable current = original;
+
+            while (current != null) {
+                Set<TypeJudgement> judgements = typeMap.get(current);
+                if (judgements != null) {
+                    for (TypeJudgement judgement : judgements) {
+                        keys.add(judgement.getInputKey());
+                    }
+                }
+                current = current.getDirectUnifiedInto();
+            }
+
+            result.put(original, keys);
+        }
+
+        return result;
+    }
+
+    /**
+     * Infers unary type information for variables, based on the given constraints.
+     * 
+     * Subsumptions are not taken into account.
+     * 
+     * @param constraints
+     *            the set of constraints to extract type info from
+     */
+    public static Map<PVariable, Set<TypeJudgement>> inferUnaryTypes(Set<PConstraint> constraints,
+            IQueryMetaContext context) {
+        Set<TypeJudgement> equivalentJudgements = getDirectJudgements(constraints, context);
+        Set<TypeJudgement> impliedJudgements = typeClosure(equivalentJudgements, context);
+
+        Map<PVariable, Set<TypeJudgement>> results = new HashMap<PVariable, Set<TypeJudgement>>();
+        for (TypeJudgement typeJudgement : impliedJudgements) {
+            final IInputKey inputKey = typeJudgement.getInputKey();
+            if (inputKey.getArity() == 1) {
+                PVariable variable = (PVariable) typeJudgement.getVariablesTuple().get(0);
+                Set<TypeJudgement> inferredTypes = results.computeIfAbsent(variable, v -> new HashSet<>());
+                inferredTypes.add(typeJudgement);
+            }
+        }
+        return results;
+    }
+
+    /**
+     * Gets direct judgements reported by constraints. No closure is applied yet.
+     */
+    public static Set<TypeJudgement> getDirectJudgements(Set<PConstraint> constraints, IQueryMetaContext context) {
+        Set<TypeJudgement> equivalentJudgements = new HashSet<TypeJudgement>();
+        for (PConstraint pConstraint : constraints) {
+            if (pConstraint instanceof ITypeInfoProviderConstraint) {
+                equivalentJudgements.addAll(((ITypeInfoProviderConstraint) pConstraint).getImpliedJudgements(context));
+            }
+        }
+        return equivalentJudgements;
+    }
+
+    /**
+     * Calculates the closure of a set of type judgements, with respect to supertyping.
+     * 
+     * @return the set of all type judgements in typesToClose and all their direct and indirect supertypes
+     */
+    public static Set<TypeJudgement> typeClosure(Set<TypeJudgement> typesToClose, IQueryMetaContext context) {
+        return typeClosure(Collections.<TypeJudgement> emptySet(), typesToClose, context);
+    }
+
+    /**
+     * Calculates the closure of a set of type judgements (with respect to supertyping), where the closure has been
+     * calculated before for a given base set, but not for a separate delta set.
+     * <p>
+     * Precondition: the set (typesToClose MINUS delta) is already closed w.r.t. supertyping.
+     * 
+     * @return the set of all type judgements in typesToClose and all their direct and indirect supertypes
+     * @since 1.6
+     */
+    public static Set<TypeJudgement> typeClosure(Set<TypeJudgement> preclosedBaseSet, Set<TypeJudgement> delta,
+            IQueryMetaContext context) {
+        Queue<TypeJudgement> queue = delta.stream().filter(input -> !preclosedBaseSet.contains(input)).collect(Collectors.toCollection(LinkedList::new)); 
+        if (queue.isEmpty())
+            return preclosedBaseSet;
+        
+        Set<TypeJudgement> closure = new HashSet<TypeJudgement>(preclosedBaseSet);
+
+        Map<TypeJudgement, Set<TypeJudgement>> conditionalImplications = new HashMap<>();
+        for (TypeJudgement typeJudgement : closure) {
+            conditionalImplications.putAll(typeJudgement.getConditionalImpliedJudgements(context));
+        }
+
+        do {
+            TypeJudgement deltaType = queue.poll();
+            if (closure.add(deltaType)) {
+                // direct implications
+                queue.addAll(deltaType.getDirectlyImpliedJudgements(context));
+
+                // conditional implications, source key processed before, this is the condition key
+                final Set<TypeJudgement> implicationSet = conditionalImplications.get(deltaType);
+                if (implicationSet != null) {
+                     queue.addAll(implicationSet);
+                }
+
+                // conditional implications, this is the source key
+                Map<TypeJudgement, Set<TypeJudgement>> deltaConditionalImplications = deltaType
+                        .getConditionalImpliedJudgements(context);
+                for (Entry<TypeJudgement, Set<TypeJudgement>> entry : deltaConditionalImplications.entrySet()) {
+                    if (closure.contains(entry.getKey())) {
+                        // condition processed before
+                        queue.addAll(entry.getValue());
+                    } else {
+                        // condition not processed yet
+                        conditionalImplications.computeIfAbsent(entry.getKey(), key -> new HashSet<>())
+                                .addAll(entry.getValue());
+                    }
+                }
+            }
+        } while (!queue.isEmpty());
+
+        return closure;
+    }
+
+    /**
+     * Calculates a remainder set of types from a larger set, that are not subsumed by a given set of subsuming types.
+     * 
+     * @param subsumableTypes
+     *            a set of types from which some may be implied by the subsuming types
+     * @param subsumingTypes
+     *            a set of types that may imply some of the subsuming types
+     * @return the collection of types in subsumableTypes that are NOT identical to or supertypes of any type in
+     *         subsumingTypes.
+     */
+    public static Set<TypeJudgement> subsumeTypes(Set<TypeJudgement> subsumableTypes, Set<TypeJudgement> subsumingTypes,
+            IQueryMetaContext context) {
+        Set<TypeJudgement> closure = typeClosure(subsumingTypes, context);
+        Set<TypeJudgement> subsumed = new HashSet<TypeJudgement>(subsumableTypes);
+        subsumed.removeAll(closure);
+        return subsumed;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PApply.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PApply.java
new file mode 100644
index 00000000..2c285b54
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PApply.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Represents a constraint application on a single parent SubPlan. 
+ * <p> Either a "selection" filter operation according to a deferred PConstraint (or transform in case of eval/aggregate), or
+ * alternatively a shorthand for PJoin + a PEnumerate on the right input for an enumerable PConstraint.
+ * 
+ * <p> <b>WARNING</b>: if there are coinciding variables in the variable tuple of the enumerable constraint, 
+ *   it is the responsibility of the compiler to check them for equality.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class PApply extends POperation {
+    
+    private PConstraint pConstraint;
+
+    public PApply(PConstraint pConstraint) {
+        super();
+        this.pConstraint = pConstraint;
+    }
+    public PConstraint getPConstraint() {
+        return pConstraint;
+    }
+
+    @Override
+    public String getShortName() {
+        return String.format("APPLY_%s", pConstraint.toString());
+    }
+    
+    @Override
+    public Set<? extends PConstraint> getDeltaConstraints() {
+        return Collections.singleton(pConstraint);
+    }
+    
+    @Override
+    public int numParentSubPlans() {
+        return 1;
+    }
+    
+    @Override
+    public void checkConsistency(SubPlan subPlan) {
+        super.checkConsistency(subPlan);
+        for (SubPlan parentPlan : subPlan.getParentPlans())
+            Preconditions.checkArgument(!parentPlan.getAllEnforcedConstraints().contains(pConstraint),
+                    "Double-checking constraint %s", pConstraint);              
+        // TODO obtain context?
+        //if (pConstraint instanceof DeferredPConstraint)
+        //      Preconditions.checkArgument(((DeferredPConstraint) pConstraint).isReadyAt(subPlan, context))
+    }
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime
+                * result
+                + ((pConstraint == null) ? 0 : pConstraint
+                        .hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof PApply))
+            return false;
+        PApply other = (PApply) obj;
+        if (pConstraint == null) {
+            if (other.pConstraint != null)
+                return false;
+        } else if (!pConstraint.equals(other.pConstraint))
+            return false;
+        return true;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PEnumerate.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PEnumerate.java
new file mode 100644
index 00000000..a975d50c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PEnumerate.java
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.psystem.EnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+
+/**
+ * Represents a base relation defined by the instance set of an enumerable PConstraint; there are no parent SubPlans.
+ * 
+ * <p> <b>WARNING</b>: if there are coinciding variables in the variable tuple of the enumerable constraint, 
+ *   it is the responsibility of the compiler to check them for equality.
+ * @author Bergmann Gabor
+ *
+ */
+public class PEnumerate extends POperation {
+
+    EnumerablePConstraint enumerablePConstraint;
+    
+    public PEnumerate(EnumerablePConstraint enumerablePConstraint) {
+        super();
+        this.enumerablePConstraint = enumerablePConstraint;
+    }
+    public EnumerablePConstraint getEnumerablePConstraint() {
+        return enumerablePConstraint;
+    }
+
+    @Override
+    public Set<? extends PConstraint> getDeltaConstraints() {
+        return Collections.singleton(enumerablePConstraint);
+    }
+    @Override
+    public int numParentSubPlans() {
+        return 0;
+    }
+    @Override
+    public String getShortName() {
+        return enumerablePConstraint.toString();
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime
+                * result
+                + ((enumerablePConstraint == null) ? 0 : enumerablePConstraint
+                        .hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof PEnumerate))
+            return false;
+        PEnumerate other = (PEnumerate) obj;
+        if (enumerablePConstraint == null) {
+            if (other.enumerablePConstraint != null)
+                return false;
+        } else if (!enumerablePConstraint.equals(other.enumerablePConstraint))
+            return false;
+        return true;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PJoin.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PJoin.java
new file mode 100644
index 00000000..10e0a85a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PJoin.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+
+/**
+ * Represents a natural join of two parent SubPlans.
+ * @author Bergmann Gabor
+ *
+ */
+public class PJoin extends POperation {
+    
+//      // TODO leave here? is this a problem in equivalnece checking?
+//      private Set<PVariable> onVariables;
+
+    public PJoin(/*Set<PVariable> onVariables*/) {
+        super();
+        //this.onVariables = new HashSet<PVariable>(onVariables);
+    }
+//      public Set<PVariable> getOnVariables() {
+//              return onVariables;
+//      }
+
+    @Override
+    public Set<? extends PConstraint> getDeltaConstraints() {
+        return Collections.emptySet();
+    }
+    @Override
+    public int numParentSubPlans() {
+        return 2;
+    }
+
+    @Override
+    public String getShortName() {
+        return "JOIN"; //String.format("JOIN_{%s}", Joiner.on(",").join(onVariables));
+    }
+    
+    @Override
+    public int hashCode() {
+        return getClass().hashCode();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof PJoin))
+            return false;
+        return true;
+    }
+    
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/POperation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/POperation.java
new file mode 100644
index 00000000..e71cf217
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/POperation.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Abstract superclass for representing a high-level query evaluation operation.
+ * 
+ *  <p> Subclasses correspond to various POperations modeled after relational algebra.  
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public abstract class POperation {
+
+    /**
+     * Newly enforced constraints
+     */
+    public abstract Set<? extends PConstraint> getDeltaConstraints();
+    
+    public abstract String getShortName();
+    
+    /**
+     * @return the number of SubPlans that must be specified as parents
+     */
+    public abstract int numParentSubPlans();
+    
+    /**
+     * Checks whether this constraint can be properly applied at the given SubPlan.
+     */
+    public void checkConsistency(SubPlan subPlan) {
+        Preconditions.checkArgument(this == subPlan.getOperation(), "POperation misalignment");
+        Preconditions.checkArgument(subPlan.getParentPlans().size() == numParentSubPlans(), "Incorrect number of parent SubPlans");
+    }
+        
+    @Override
+    public String toString() {
+        return getShortName();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PProject.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PProject.java
new file mode 100644
index 00000000..d0539b2c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PProject.java
@@ -0,0 +1,109 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Represents a projection of a single parent SubPlan onto a limited set of variables.
+ * <p> May optionally prescribe an ordering of variables (List, as opposed to Set).
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class PProject extends POperation {
+
+    private Collection<PVariable> toVariables;
+    private boolean ordered;
+        
+    
+    public PProject(Set<PVariable> toVariables) {
+        super();
+        this.toVariables = toVariables;
+        this.ordered = false;
+    }
+    public PProject(List<PVariable> toVariables) {
+        super();
+        this.toVariables = toVariables;
+        this.ordered = true;
+    }
+    
+    public Collection<PVariable> getToVariables() {
+        return toVariables;
+    }
+    public boolean isOrdered() {                
+        return ordered;
+    }
+    
+    @Override
+    public Set<? extends PConstraint> getDeltaConstraints() {
+        return Collections.emptySet();
+    }
+    @Override
+    public int numParentSubPlans() {
+        return 1;
+    }
+    @Override
+    public void checkConsistency(SubPlan subPlan) {
+        super.checkConsistency(subPlan);
+        final SubPlan parentPlan = subPlan.getParentPlans().get(0);
+        
+        Preconditions.checkArgument(parentPlan.getVisibleVariables().containsAll(toVariables), 
+                () -> toVariables.stream()
+                        .filter(input -> !parentPlan.getVisibleVariables().contains(input)).map(PVariable::getName)
+                        .collect(Collectors.joining(",", "Variables missing from project: ", "")));
+    }
+
+    @Override
+    public String getShortName() {
+        return String.format("PROJECT%s_{%s}", ordered? "!" : "", 
+                toVariables.stream().map(PVariable::getName).collect(Collectors.joining(",")));
+    }
+    
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + (ordered ? 1231 : 1237);
+        result = prime * result
+                + ((toVariables == null) ? 0 : toVariables.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof PProject))
+            return false;
+        PProject other = (PProject) obj;
+        if (ordered != other.ordered)
+            return false;
+        if (toVariables == null) {
+            if (other.toVariables != null)
+                return false;
+        } else if (!toVariables.equals(other.toVariables))
+            return false;
+        return true;
+    }
+
+
+    
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PStart.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PStart.java
new file mode 100644
index 00000000..9e6ea10e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PStart.java
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.planning.operations;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+
+/**
+ * No constraints, and no parent SubPlan, just a (possibly empty) set of a priori known (input) variables. Satisfied by a single tuple.
+ * 
+ * <p> Can also be used without a priori variables, 
+ *   e.g. as a "virtual parent" in extreme cases, 
+ *   such as <code>pattern foo(Bar) = {Bar = eval (3*4)} </code> 
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class PStart extends POperation {
+    
+    private Set<PVariable> aPrioriVariables;
+
+    
+    public PStart(Set<PVariable> aPrioriVariables) {
+        super();
+        this.aPrioriVariables = aPrioriVariables;
+    }
+    public PStart(PVariable... aPrioriVariables) {
+        this(new HashSet<PVariable>(Arrays.asList(aPrioriVariables)));
+    }
+    public Set<PVariable> getAPrioriVariables() {
+        return aPrioriVariables;
+    }
+
+    @Override
+    public String getShortName() {
+        return aPrioriVariables.stream().map(PVariable::getName).collect(Collectors.joining(",", "START_{", "}"));
+    }
+    @Override
+    public int numParentSubPlans() {
+        return 0;
+    }
+
+    @Override
+    public Set<? extends PConstraint> getDeltaConstraints() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime
+                * result
+                + ((aPrioriVariables == null) ? 0 : aPrioriVariables.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof PStart))
+            return false;
+        PStart other = (PStart) obj;
+        if (aPrioriVariables == null) {
+            if (other.aPrioriVariables != null)
+                return false;
+        } else if (!aPrioriVariables.equals(other.aPrioriVariables))
+            return false;
+        return true;
+    }
+
+
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/BasePConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/BasePConstraint.java
new file mode 100644
index 00000000..eda4aa25
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/BasePConstraint.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @author Gabor Bergmann
+ *
+ */
+public abstract class BasePConstraint implements PConstraint {
+
+
+    protected PBody pBody;
+    private final Set<PVariable> affectedVariables;
+
+
+    private final int sequentialID = nextID.getAndIncrement();
+
+        // Use a static atomic integer to avoid race conditions when creating new constraints.
+    private static AtomicInteger nextID = new AtomicInteger(0);
+
+    public BasePConstraint(PBody pBody, Set<PVariable> affectedVariables) {
+        super();
+        this.pBody = pBody;
+        this.affectedVariables = new HashSet<PVariable>(affectedVariables);
+
+        for (PVariable pVariable : affectedVariables) {
+            pVariable.refer(this);
+        }
+        pBody.registerConstraint(this);
+    }
+
+    @Override
+    public String toString() {
+        return "PC[" + getClass().getSimpleName() + ":" + toStringRest() + "]";
+    }
+
+    protected abstract String toStringRest();
+
+    @Override
+    public Set<PVariable> getAffectedVariables() {
+        return affectedVariables;
+    }
+
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public void replaceVariable(PVariable obsolete, PVariable replacement) {
+        pBody.checkMutability();
+        if (affectedVariables.remove(obsolete)) {
+            affectedVariables.add(replacement);
+            obsolete.unrefer(this);
+            replacement.refer(this);
+            doReplaceVariable(obsolete, replacement);
+        }
+    }
+
+    protected abstract void doReplaceVariable(PVariable obsolete, PVariable replacement);
+
+    @Override
+    public void delete() {
+        pBody.checkMutability();
+        for (PVariable pVariable : affectedVariables) {
+            pVariable.unrefer(this);
+        }
+        pBody.unregisterConstraint(this);
+    }
+
+    @Override
+    public void checkSanity() {
+    }
+
+    /**
+     * For backwards compatibility. Equivalent to {@link #getBody()}
+     */
+    public PBody getPSystem() {
+        return pBody;
+    }
+    /**
+     * @since 2.1
+     */
+    @Override
+    public PBody getBody() {
+        return pBody;
+    }
+
+    @Override
+    public int getMonotonousID() {
+        return sequentialID;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/DeferredPConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/DeferredPConstraint.java
new file mode 100644
index 00000000..d2bf088c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/DeferredPConstraint.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+
+/**
+ * Any constraint that can only be checked on certain SubPlans (e.g. those plans that already contain some variables).
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class DeferredPConstraint extends BasePConstraint {
+
+    public DeferredPConstraint(PBody pBody, Set<PVariable> affectedVariables) {
+        super(pBody, affectedVariables);
+    }
+
+    public abstract boolean isReadyAt(SubPlan plan, IQueryMetaContext context);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/EnumerablePConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/EnumerablePConstraint.java
new file mode 100644
index 00000000..9129aa47
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/EnumerablePConstraint.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * A constraint for which all satisfying tuples of variable values can be enumerated at any point during run-time.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class EnumerablePConstraint extends BasePConstraint {
+    protected Tuple variablesTuple;
+
+    protected EnumerablePConstraint(PBody pBody, Tuple variablesTuple) {
+        super(pBody, variablesTuple.<PVariable> getDistinctElements());
+        this.variablesTuple = variablesTuple;
+    }
+
+    @Override
+    public void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        variablesTuple = variablesTuple.replaceAll(obsolete, replacement);
+    }
+
+    @Override
+    protected String toStringRest() {
+        String stringRestRest = toStringRestRest();
+        String tupleString = "@" + variablesTuple.toString();
+        return stringRestRest == null ? tupleString : ":" + stringRestRest + tupleString;
+    }
+
+    protected String toStringRestRest() {
+        return null;
+    }
+
+    public Tuple getVariablesTuple() {
+        return variablesTuple;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return getAffectedVariables();
+    }
+
+    public PVariable getVariableInTuple(int index) {
+        return (PVariable) this.variablesTuple.get(index);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IExpressionEvaluator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IExpressionEvaluator.java
new file mode 100644
index 00000000..686999f7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IExpressionEvaluator.java
@@ -0,0 +1,42 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+/**
+ * An expression evaluator is used to execute arbitrary Java code during pattern matching. In order to include the
+ * evaluation in the planning seemlessly it is expected from the evaluator implementors to report all used PVariables by
+ * name.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public interface IExpressionEvaluator {
+
+    /**
+     * A textual description of the expression. Used only for debug purposes, but must not be null.
+     */
+    String getShortDescription();
+
+    /**
+     * All input parameter names should be reported correctly.
+     */
+    Iterable<String> getInputParameterNames();
+
+    /**
+     * The expression evaluator code
+     * 
+     * @param provider
+     *            the value provider is an engine-specific way of reading internal variable tuples to evaluate the
+     *            expression with
+     * @return the result of the expression: in case of predicate evaluation the return value must be true or false;
+     *         otherwise the result can be an arbitrary object. No null values should be returned.
+     * @throws Exception
+     */
+    Object evaluateExpression(IValueProvider provider) throws Exception;
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IMultiQueryReference.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IMultiQueryReference.java
new file mode 100644
index 00000000..8f647c64
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IMultiQueryReference.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2022, Tamas Szabo, GitHub
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Collection;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * A {@link PConstraint} that implements this interface refers to a list of PQueries.
+ * 
+ * @author Tamas Szabo
+ * @since 2.8
+ *
+ */
+public interface IMultiQueryReference {
+
+    Collection<PQuery> getReferredQueries();
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IQueryReference.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IQueryReference.java
new file mode 100644
index 00000000..9ee05b39
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IQueryReference.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Collections;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * A {@link PConstraint} that implements this interface refers to a {@link PQuery}.
+ * 
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface IQueryReference extends IMultiQueryReference {
+
+    PQuery getReferredQuery();
+
+    /**
+     * @since 2.8
+     */
+    @Override
+    default List<PQuery> getReferredQueries() {
+        return Collections.singletonList(getReferredQuery());
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IRelationEvaluator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IRelationEvaluator.java
new file mode 100644
index 00000000..e4c396d8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IRelationEvaluator.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2022, Tamas Szabo, GitHub
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Implementations of this interface take an arbitrary number of input relations with their contents and compute the
+ * tuples of a single output relation.
+ * 
+ * @author Tamas Szabo
+ * @since 2.8
+ *
+ */
+public interface IRelationEvaluator {
+
+    /**
+     * A textual description of the evaluator. Used only for debug purposes, but must not be null.
+     */
+    String getShortDescription();
+
+    /**
+     * The relation evaluator code. For performance reasons, it is expected that the returned set is a mutable
+     * collection, and the caller must be allowed to actually perform mutations!
+     */
+    Set<Tuple> evaluateRelation(List<Set<Tuple>> inputs) throws Exception;
+
+    /**
+     * For each input relation that this evaluator requires, this method returns the expected arities of the relations in order.
+     */
+    List<Integer> getInputArities();
+
+    /**
+     * Returns the arity of the output relation that this evaluator computes.
+     */
+    int getOutputArity();
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeConstraint.java
new file mode 100644
index 00000000..b72035a8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeConstraint.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+import java.util.Set;
+
+/**
+ * Common superinterface of enumerable and deferred type constraints.
+ * @author Bergmann Gabor
+ *
+ */
+public interface ITypeConstraint extends ITypeInfoProviderConstraint {
+
+    public abstract TypeJudgement getEquivalentJudgement();
+    
+    /**
+     * Static internal utility class for implementations of {@link ITypeConstraint}s.
+     * @author Bergmann Gabor
+     */
+    public static class TypeConstraintUtil {
+        
+        private TypeConstraintUtil() {
+            // Hiding constructor for utility class
+        }
+        
+        public static Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context, IInputKey inputKey, Tuple variablesTuple) {
+            final Map<Set<PVariable>, Set<PVariable>> result = new HashMap<Set<PVariable>, Set<PVariable>>();
+            
+            Set<Entry<Set<Integer>, Set<Integer>>> dependencies = context.getFunctionalDependencies(inputKey).entrySet();
+            for (Entry<Set<Integer>, Set<Integer>> dependency : dependencies) {
+                result.put(
+                        transcribeVariables(dependency.getKey(), variablesTuple), 
+                        transcribeVariables(dependency.getValue(), variablesTuple)
+                );
+            }
+
+            return result;
+        }
+
+        private static Set<PVariable> transcribeVariables(Set<Integer> indices, Tuple variablesTuple) {
+            Set<PVariable> result = new HashSet<PVariable>();
+            for (Integer index : indices) {
+                result.add((PVariable) variablesTuple.get(index));
+            }
+            return result;
+        }
+
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeInfoProviderConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeInfoProviderConstraint.java
new file mode 100644
index 00000000..ff127d38
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeInfoProviderConstraint.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public interface ITypeInfoProviderConstraint extends PConstraint {
+
+    /**
+     * Returns type information implied by this constraint.
+     * 
+     */
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IValueProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IValueProvider.java
new file mode 100644
index 00000000..d959adc4
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IValueProvider.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+/**
+ * Helper interface to get values from a tuple of variables. All pattern matching engines are expected to implement this
+ * to handle their internal structures.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public interface IValueProvider {
+
+    /**
+     * Returns the value of the selected variable
+     * @param variableName
+     * @return the value of the variable; never null
+     * @throws IllegalArgumentException if the variable is not defined
+     */
+    Object getValue(String variableName);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/InitializablePQuery.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/InitializablePQuery.java
new file mode 100644
index 00000000..a82d12ec
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/InitializablePQuery.java
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.PAnnotation;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PProblem;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Adds extra methods to the PQuery interface to initialize its contents.
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface InitializablePQuery extends PQuery {
+
+    /**
+     * Sets the query status. Only applicable if the pattern is still {@link PQueryStatus#UNINITIALIZED uninitialized}.
+     *
+     * @param status the new status
+     */
+    void setStatus(PQueryStatus status);
+    
+    /**
+     * Adds a detected error. Only applicable if the pattern is still {@link PQueryStatus#UNINITIALIZED uninitialized}.
+     *
+     * @param problem the new problem
+     */
+    void addError(PProblem problem);
+
+    /**
+     * Sets up the bodies of the pattern. Only applicable if the pattern is still {@link PQueryStatus#UNINITIALIZED
+     * uninitialized}.
+     *
+     * @param bodies
+     * @throws ViatraQueryRuntimeException
+     */
+    void initializeBodies(Set<PBody> bodies);
+
+    /**
+     * Adds an annotation to the specification. Only applicable if the pattern is still
+     * {@link PQueryStatus#UNINITIALIZED uninitialized}.
+     *
+     * @param annotation
+     */
+    void addAnnotation(PAnnotation annotation);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/KeyedEnumerablePConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/KeyedEnumerablePConstraint.java
new file mode 100644
index 00000000..91eea817
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/KeyedEnumerablePConstraint.java
@@ -0,0 +1,39 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class KeyedEnumerablePConstraint<KeyType> extends EnumerablePConstraint {
+
+    protected KeyType supplierKey;
+
+    public KeyedEnumerablePConstraint(PBody pBody, Tuple variablesTuple,
+            KeyType supplierKey) {
+        super(pBody, variablesTuple);
+        this.supplierKey = supplierKey;
+    }
+
+    @Override
+    protected String toStringRestRest() {
+        return supplierKey == null ? "$any(null)" : keyToString();
+    }
+
+    protected abstract String keyToString();
+
+    public KeyType getSupplierKey() {
+        return supplierKey;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PBody.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PBody.java
new file mode 100644
index 00000000..c38dc23a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PBody.java
@@ -0,0 +1,289 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.TypeHelper;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.ConstantValue;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * A set of constraints representing a pattern body
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class PBody implements PTraceable {
+    
+    public static final String VIRTUAL_VARIABLE_PREFIX = ".virtual";
+    private static final String VIRTUAL_VARIABLE_PATTERN = VIRTUAL_VARIABLE_PREFIX + "{%d}";
+    
+    private PQuery query;
+
+    /**
+     * If null, then parent query status is reused
+     */
+    private PQueryStatus status = PQueryStatus.UNINITIALIZED;
+
+    private Set<PVariable> allVariables;
+    private Set<PVariable> uniqueVariables;
+    private List<ExportedParameter> symbolicParameters;
+    private Map<Object, PVariable> variablesByName;
+    private Set<PConstraint> constraints;
+    private int nextVirtualNodeID;
+    private PDisjunction containerDisjunction;
+
+    public PBody(PQuery query) {
+        super();
+        this.query = query;
+        allVariables = new LinkedHashSet<>();
+        uniqueVariables = new LinkedHashSet<>();
+        variablesByName = new HashMap<>();
+        constraints = new LinkedHashSet<>();
+    }
+
+    /**
+     * @return whether the submission of the new variable was successful
+     */
+    private boolean addVariable(PVariable var) {
+        checkMutability();
+        Object name = var.getName();
+        if (!variablesByName.containsKey(name)) {
+            allVariables.add(var);
+            if (var.isUnique())
+                uniqueVariables.add(var);
+            variablesByName.put(name, var);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Use this method to add a newly created constraint to the pSystem.
+     * 
+     * @return whether the submission of the new constraint was successful
+     */
+    boolean registerConstraint(PConstraint constraint) {
+        checkMutability();
+        return constraints.add(constraint);
+    }
+
+    /**
+     * Use this method to remove an obsolete constraint from the pSystem.
+     * 
+     * @return whether the removal of the constraint was successful
+     */
+    boolean unregisterConstraint(PConstraint constraint) {
+        checkMutability();
+        return constraints.remove(constraint);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <ConstraintType> Set<ConstraintType> getConstraintsOfType(Class<ConstraintType> constraintClass) {
+        Set<ConstraintType> result = new HashSet<ConstraintType>();
+        for (PConstraint pConstraint : constraints) {
+            if (constraintClass.isInstance(pConstraint))
+                result.add((ConstraintType) pConstraint);
+        }
+        return result;
+    }
+
+    public PVariable newVirtualVariable() {
+        checkMutability();
+        String name;
+        do {
+            
+            name = String.format(VIRTUAL_VARIABLE_PATTERN, nextVirtualNodeID++);
+        } while (variablesByName.containsKey(name));
+        PVariable var = new PVariable(this, name, true);
+        addVariable(var);
+        return var;
+    }
+    
+    public PVariable newVirtualVariable(String name) {
+        checkMutability();
+        Preconditions.checkArgument(!variablesByName.containsKey(name), "ID %s already used for a virtual variable", name);
+        PVariable var = new PVariable(this, name, true);
+        addVariable(var);
+        return var;
+    }
+
+    public PVariable newConstantVariable(Object value) {
+        checkMutability();
+        PVariable virtual = newVirtualVariable();
+        new ConstantValue(this, virtual, value);
+        return virtual;
+    }
+
+    public Set<PVariable> getAllVariables() {
+        return allVariables;
+    }
+
+    public Set<PVariable> getUniqueVariables() {
+        return uniqueVariables;
+    }
+
+    private PVariable getVariableByName(Object name) {
+        return variablesByName.get(name).getUnifiedIntoRoot();
+    }
+
+    /**
+     * Find a PVariable by name
+     * 
+     * @param name
+     * @return the found variable
+     * @throws IllegalArgumentException
+     *             if no PVariable is found with the selected name
+     */
+    public PVariable getVariableByNameChecked(Object name) {
+        if (!variablesByName.containsKey(name))
+            throw new IllegalArgumentException(String.format("Cannot find PVariable %s", name));
+        return getVariableByName(name);
+    }
+
+    /**
+     * Finds and returns a PVariable by name. If no PVariable exists with the name in the body, a new one is created. If
+     * the name of the variable starts with {@value #VIRTUAL_VARIABLE_PREFIX}, the created variable will be considered
+     * virtual.
+     * 
+     * @param name
+     * @return a PVariable with the selected name; never null
+     */
+    public PVariable getOrCreateVariableByName(String name) {
+        checkMutability();
+        if (!variablesByName.containsKey(name)) {
+            addVariable(new PVariable(this, name, name.startsWith(VIRTUAL_VARIABLE_PREFIX)));
+        }
+        return getVariableByName(name);
+    }
+
+    public Set<PConstraint> getConstraints() {
+        return constraints;
+    }
+
+    public PQuery getPattern() {
+        return query;
+    }
+
+    void noLongerUnique(PVariable pVariable) {
+        assert (!pVariable.isUnique());
+        uniqueVariables.remove(pVariable);
+    }
+
+    /**
+     * Returns the symbolic parameters of the body. </p>
+     * 
+     * <p>
+     * <strong>Warning</strong>: if two PVariables are unified, the returned list changes. If you want to have a stable
+     * version, consider using {@link #getSymbolicParameters()}.
+     * 
+     * @return a non-null, but possibly empty list
+     */
+    public List<PVariable> getSymbolicParameterVariables() {
+        return getSymbolicParameters().stream().map(ExportedParameter::getParameterVariable)
+                .collect(Collectors.toList());
+    }
+
+    /**
+     * Returns the exported parameter constraints of the body.
+     * 
+     * @return a non-null, but possibly empty list
+     */
+    public List<ExportedParameter> getSymbolicParameters() {
+        if (symbolicParameters == null) 
+            symbolicParameters = new ArrayList<>();
+        return symbolicParameters;
+    }
+
+    /**
+     * Sets the exported parameter constraints of the body, if this instance is mutable.
+     * @param symbolicParameters the new value
+     */
+    public void setSymbolicParameters(List<ExportedParameter> symbolicParameters) {
+        checkMutability();
+        this.symbolicParameters = new ArrayList<>(symbolicParameters);
+    }
+
+    /**
+     * Sets a specific status for the body. If set, the parent PQuery status will not be checked; if set to null, its corresponding PQuery
+     * status is checked for mutability.
+     * 
+     * @param status
+     *            the status to set
+     */
+    public void setStatus(PQueryStatus status) {
+        this.status = status;
+    }
+
+    public boolean isMutable() {
+        if (status == null) {
+            return query.isMutable();
+        } else {
+            return status.equals(PQueryStatus.UNINITIALIZED);
+        }
+    }
+    
+    void checkMutability() {
+        if (status == null) {
+            query.checkMutability();
+        } else {
+            Preconditions.checkState(status.equals(PQueryStatus.UNINITIALIZED), "Initialized queries are not mutable");
+        }
+    }
+
+    /**
+     * Returns the disjunction the body is contained with. This disjunction may either be the
+     * {@link PQuery#getDisjunctBodies() canonical disjunction of the corresponding query} or something equivalent.
+     * 
+     * @return the container disjunction of the body. Can be null if body is not in a disjunction yet.
+     */
+    public PDisjunction getContainerDisjunction() {
+        return containerDisjunction;
+    }
+
+    /**
+     * @param containerDisjunction the containerDisjunction to set
+     */
+    public void setContainerDisjunction(PDisjunction containerDisjunction) {
+        Preconditions.checkArgument(query.equals(containerDisjunction.getQuery()), "Disjunction of pattern %s incompatible with body %s", containerDisjunction.getQuery().getFullyQualifiedName(), query.getFullyQualifiedName());
+        Preconditions.checkState(this.containerDisjunction == null, "Disjunction is already set.");
+        this.containerDisjunction = containerDisjunction;
+    }
+
+    /**
+     * All unary input keys directly prescribed by constraints, grouped by variable.
+     * <p> to supertype inference or subsumption applied at this point.
+     */
+    public Map<PVariable, Set<TypeJudgement>> getAllUnaryTypeRestrictions(IQueryMetaContext context) {
+        Map<PVariable, Set<TypeJudgement>> currentRestrictions = allUnaryTypeRestrictions.get(context);
+        if (currentRestrictions == null) {
+            currentRestrictions = TypeHelper.inferUnaryTypes(getConstraints(), context);
+            allUnaryTypeRestrictions.put(context, currentRestrictions);
+        }
+        return currentRestrictions;
+    }
+    private WeakHashMap<IQueryMetaContext, Map<PVariable, Set<TypeJudgement>>> allUnaryTypeRestrictions = new WeakHashMap<IQueryMetaContext, Map<PVariable,Set<TypeJudgement>>>();   
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PConstraint.java
new file mode 100644
index 00000000..ae2c4632
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PConstraint.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.analysis.QueryAnalyzer;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public interface PConstraint extends PTraceable {
+
+    /**
+     * @since 2.1
+     * @return the query body this constraint belongs to
+     */
+    public PBody getBody();
+
+    /**
+     * All variables affected by this constraint.
+     */
+    public Set<PVariable> getAffectedVariables();
+
+    /**
+     * The set of variables whose potential values can be enumerated (once all non-deduced variables have known values).  
+     */
+    public Set<PVariable> getDeducedVariables();
+    
+    /**
+     * A (preferably minimal) cover of known functional dependencies between variables.
+     * @noreference Use {@link QueryAnalyzer} instead to properly handle dependencies of pattern calls. 
+     * @return non-trivial functional dependencies in the form of {variables} --> {variables}, where dependencies with the same lhs are unified.   
+     */
+    public Map<Set<PVariable>,Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context);  
+
+    public void replaceVariable(PVariable obsolete, PVariable replacement);
+
+    public void delete();
+
+    public void checkSanity();
+
+    /**
+     * Returns an integer ID that is guaranteed to increase strictly monotonously for constraints within a pBody.
+     */
+    public abstract int getMonotonousID();
+    
+
+    /**
+     * A comparator that orders constraints by their {@link #getMonotonousID() monotonous identifiers}. Should only used
+     * for tiebreaking in other comparators.
+     * 
+     * @since 2.0
+     */
+    public static final Comparator<PConstraint> COMPARE_BY_MONOTONOUS_ID = (arg0, arg1) -> arg0.getMonotonousID() - arg1.getMonotonousID();
+
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PTraceable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PTraceable.java
new file mode 100644
index 00000000..f0241a9c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PTraceable.java
@@ -0,0 +1,16 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Dénes Harmath, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+/**
+ * Marker interface for PSystem elements that can be traced.
+ * @since 1.6
+ */
+public interface PTraceable {
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PVariable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PVariable.java
new file mode 100644
index 00000000..b6ea4861
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PVariable.java
@@ -0,0 +1,203 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * @author Gabor Bergmann
+ *
+ */
+public class PVariable {
+    private PBody pBody;
+    /**
+     * The name of the pattern variable. This is the unique key of the pattern node.
+     */
+    private String name;
+    /**
+     * virtual pVariables are nodes that do not correspond to actual pattern variables; they represent constants or Term
+     * substitutes
+     */
+    private boolean virtual;
+
+    /**
+     * Set of constraints that mention this variable
+     */
+    private Set<PConstraint> referringConstraints;
+
+    /**
+     * Determines whether there are any constraints that can deduce this variable
+     */
+    private Boolean deducable;
+
+    /**
+     * Another PVariable this variable has been unified into. Please use the other variable instead of this. Null iff
+     * this is still a first-class variable.
+     */
+    private PVariable unifiedInto;
+
+    PVariable(PBody pBody, String name) {
+        this(pBody, name, false);
+    }
+
+    PVariable(PBody pBody, String name, boolean virtual) {
+        super();
+        this.pBody = pBody;
+        this.name = name;
+        this.virtual = virtual;
+        // this.exportedParameter = false;
+        this.referringConstraints = new HashSet<PConstraint>();
+        this.unifiedInto = null;
+        this.deducable = false;
+    }
+
+    /**
+     * Replaces this variable with a given other, resulting in their unification. This variable will no longer be
+     * unique.
+     *
+     * @param replacement
+     */
+    public void unifyInto(PVariable replacement) {
+        pBody.checkMutability();
+        replacementCheck();
+        replacement = replacement.getUnifiedIntoRoot();
+
+        if (this.equals(replacement))
+            return;
+
+        if (!this.isVirtual() && replacement.isVirtual()) {
+            replacement.unifyInto(this);
+        } else {
+            // replacement.referringConstraints.addAll(this.referringConstraints);
+            // replacement.exportedParameter |= this.exportedParameter;
+            replacement.virtual &= this.virtual;
+            if (replacement.deducable != null && this.deducable != null)
+                replacement.deducable |= this.deducable;
+            else
+                replacement.deducable = null;
+            Set<PConstraint> snapshotConstraints = // avoid ConcurrentModificationX
+                    new HashSet<PConstraint>(this.referringConstraints);
+            for (PConstraint constraint : snapshotConstraints) {
+                constraint.replaceVariable(this, replacement);
+            }
+            // replacementCheck() will fail from this point
+            this.unifiedInto = replacement;
+            pBody.noLongerUnique(this);
+        }
+    }
+
+    /**
+     * Determines whether there are any constraints that can deduce this variable
+     */
+    public boolean isDeducable() {
+        replacementCheck();
+        if (deducable == null) {
+            deducable = false;
+            for (PConstraint pConstraint : getReferringConstraints()) {
+                if (pConstraint.getDeducedVariables().contains(this)) {
+                    deducable = true;
+                    break;
+                }
+            }
+        }
+        return deducable;
+    }
+
+    /**
+     * Register that this variable is referred by the given constraint.
+     *
+     * @param constraint
+     */
+    public void refer(PConstraint constraint) {
+        pBody.checkMutability();
+        replacementCheck();
+        deducable = null;
+        referringConstraints.add(constraint);
+    }
+
+    /**
+     * Register that this variable is no longer referred by the given constraint.
+     *
+     * @param constraint
+     */
+    public void unrefer(PConstraint constraint) {
+        pBody.checkMutability();
+        replacementCheck();
+        deducable = null;
+        referringConstraints.remove(constraint);
+    }
+
+    /**
+     * @return the name of the pattern variable. This is the unique key of the pattern node.
+     */
+    public String getName() {
+        replacementCheck();
+        return name;
+    }
+
+    /**
+     * @return the virtual
+     */
+    public boolean isVirtual() {
+        replacementCheck();
+        return virtual;
+    }
+
+    /**
+     * @return the referringConstraints
+     */
+    public Set<PConstraint> getReferringConstraints() {
+        replacementCheck();
+        return referringConstraints;
+    }
+
+    @SuppressWarnings("unchecked")
+    public <ConstraintType> Set<ConstraintType> getReferringConstraintsOfType(Class<ConstraintType> constraintClass) {
+        replacementCheck();
+        Set<ConstraintType> result = new HashSet<ConstraintType>();
+        for (PConstraint pConstraint : referringConstraints) {
+            if (constraintClass.isInstance(pConstraint))
+                result.add((ConstraintType) pConstraint);
+        }
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        // replacementCheck();
+        return name;// + ":PatternNode";
+    }
+
+    public PVariable getDirectUnifiedInto() {
+        return unifiedInto;
+    }
+
+    public PVariable getUnifiedIntoRoot() {
+        PVariable nextUnified = unifiedInto;
+        PVariable oldUnifiedInto = this;
+        while (nextUnified != null) {
+            oldUnifiedInto = nextUnified;
+            nextUnified = oldUnifiedInto.getDirectUnifiedInto();
+        }
+        return oldUnifiedInto; // unifiedInto;
+    }
+
+    public boolean isUnique() {
+        return unifiedInto == null;
+    }
+
+    private void replacementCheck() {
+        if (unifiedInto != null)
+            throw new IllegalStateException("Illegal usage of variable " + name + " which has been replaced with "
+                    + unifiedInto.name);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/TypeJudgement.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/TypeJudgement.java
new file mode 100644
index 00000000..4447b225
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/TypeJudgement.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.context.InputKeyImplication;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * A judgement that means that the given tuple of variables will represent a tuple of values that is a member of the extensional relation identified by the given input key.
+ * @author Bergmann Gabor
+ *
+ */
+public class TypeJudgement {
+    
+    private IInputKey inputKey;
+    private Tuple variablesTuple;
+    /**
+     * @param inputKey
+     * @param variablesTuple
+     */
+    public TypeJudgement(IInputKey inputKey, Tuple variablesTuple) {
+        super();
+        this.inputKey = inputKey;
+        this.variablesTuple = variablesTuple;
+    }
+    public IInputKey getInputKey() {
+        return inputKey;
+    }
+    public Tuple getVariablesTuple() {
+        return variablesTuple;
+    }
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result
+                + ((inputKey == null) ? 0 : inputKey.hashCode());
+        result = prime * result
+                + ((variablesTuple == null) ? 0 : variablesTuple.hashCode());
+        return result;
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof TypeJudgement))
+            return false;
+        TypeJudgement other = (TypeJudgement) obj;
+        if (inputKey == null) {
+            if (other.inputKey != null)
+                return false;
+        } else if (!inputKey.equals(other.inputKey))
+            return false;
+        if (variablesTuple == null) {
+            if (other.variablesTuple != null)
+                return false;
+        } else if (!variablesTuple.equals(other.variablesTuple))
+            return false;
+        return true;
+    }
+    
+    public Set<TypeJudgement> getDirectlyImpliedJudgements(IQueryMetaContext context) {
+        Set<TypeJudgement> results = new HashSet<TypeJudgement>();
+        results.add(this);
+        
+        Collection<InputKeyImplication> implications = context.getImplications(this.inputKey);
+        for (InputKeyImplication inputKeyImplication : implications) {
+            results.add(
+                transcribeImplication(inputKeyImplication)
+            );
+        }
+        
+        return results;
+    }
+    
+    /**
+     * @since 1.6
+     */
+    public Set<TypeJudgement> getWeakenedAlternativeJudgements(IQueryMetaContext context) {
+        Set<TypeJudgement> results = new HashSet<TypeJudgement>();
+        
+        Collection<InputKeyImplication> implications = context.getWeakenedAlternatives(this.inputKey);
+        for (InputKeyImplication inputKeyImplication : implications) {
+            results.add(
+                transcribeImplication(inputKeyImplication)
+            );
+        }
+        
+        return results;
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public Map<TypeJudgement, Set<TypeJudgement>> getConditionalImpliedJudgements(IQueryMetaContext context) {
+        return context.getConditionalImplications(this.inputKey).entrySet().stream().collect(Collectors.toMap(
+                entry -> transcribeImplication(entry.getKey()),
+                entry -> entry.getValue().stream().map(this::transcribeImplication).collect(Collectors.toSet())));
+    }
+    
+    
+    
+    private TypeJudgement transcribeImplication(InputKeyImplication inputKeyImplication) {
+        return new TypeJudgement(
+                inputKeyImplication.getImpliedKey(), 
+                transcribeVariablesToTuple(inputKeyImplication.getImpliedIndices())
+        );
+    }
+    private Tuple transcribeVariablesToTuple(List<Integer> indices) {
+        Object[] elements = new Object[indices.size()];
+        for (int i = 0; i < indices.size(); ++i)
+            elements[i] = variablesTuple.get(indices.get(i));
+        return Tuples.flatTupleOf(elements);
+    }
+
+    @Override
+    public String toString() {
+        return "TypeJudgement:" + inputKey.getPrettyPrintableName() + "@" + variablesTuple.toString();
+    }
+    
+    /**
+     * Creates this judgement as a direct type constraint in the given PBody under construction.
+     * <p> pre: the variables tuple must be formed of variables of that PBody.
+     * @since 1.6
+     */
+    public PConstraint createConstraintFor(PBody pBody) {
+        if (inputKey.isEnumerable()) {
+            return new TypeConstraint(pBody, variablesTuple, inputKey);
+        } else {
+            return new TypeFilterConstraint(pBody, variablesTuple, inputKey);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/VariableDeferredPConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/VariableDeferredPConstraint.java
new file mode 100644
index 00000000..8ea6bb93
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/VariableDeferredPConstraint.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+
+/**
+ * A kind of deferred constraint that can only be checked when a set of deferring variables are all present in a plan.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class VariableDeferredPConstraint extends DeferredPConstraint {
+
+    public VariableDeferredPConstraint(PBody pBody,
+            Set<PVariable> affectedVariables) {
+        super(pBody, affectedVariables);
+    }
+
+    public abstract Set<PVariable> getDeferringVariables();
+
+    /**
+     * Refine further if needed
+     */
+    @Override
+    public boolean isReadyAt(SubPlan plan, IQueryMetaContext context) {
+        return plan.getVisibleVariables().containsAll(getDeferringVariables());
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AbstractMemorylessAggregationOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AbstractMemorylessAggregationOperator.java
new file mode 100644
index 00000000..63a37bbe
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AbstractMemorylessAggregationOperator.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.aggregations;
+
+/**
+ * 
+ * An aggregation operator that does not store interim results beyond the final aggregated value.
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public abstract class AbstractMemorylessAggregationOperator<Domain, AggregateResult> 
+    implements IMultisetAggregationOperator<Domain, AggregateResult, AggregateResult> 
+{
+
+    @Override
+    public AggregateResult getAggregate(AggregateResult result) {
+        return result;
+    }
+
+    @Override
+    public AggregateResult clone(AggregateResult original) {
+        return original;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AggregatorType.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AggregatorType.java
new file mode 100644
index 00000000..4cc40a2b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AggregatorType.java
@@ -0,0 +1,49 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.aggregations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import tools.refinery.viatra.runtime.matchers.aggregators.count;
+
+/**
+ * The aggregator type annotation describes the type constraints for the selected aggregator. In version 1.4, two kinds of
+ * aggregators are supported:
+ * 
+ * <ol>
+ * <li>An aggregator that does not consider any parameter value from the call ({@link count}), just calculates the
+ * number of matches. This is represented by a single {@link Void} and a single corresponding return type.</li>
+ * <li>An aggregator that considers a single parameter from the call, and executes some aggregate operations over it.
+ * Such an aggregate operation can be defined over multiple types, where each possible parameter type has a corresponding return type declared.</li>
+ * </ol>
+ * 
+ * <strong>Important!</strong> The parameterTypes and returnTypes arrays must have
+ * <ul>
+ * <li>The same number of classes defined each.</li>
+ * <li>Items are corresponded by index.</li>
+ * <li>Items should represent data types</li>
+ * </ul>
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.4
+ *
+ */
+@Target({ ElementType.TYPE })
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+public @interface AggregatorType {
+
+    Class<?>[] parameterTypes();
+
+    Class<?>[] returnTypes();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/BoundAggregator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/BoundAggregator.java
new file mode 100644
index 00000000..e6972544
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/BoundAggregator.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.aggregations;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+
+/**
+ * Augments an aggregator operator with type bindings for the type of values being aggregated and the aggregate result.
+ * <p> In case of <em>count</em>, the operator should be null.
+ * @author Gabor Bergmann
+ * @since 1.4
+ */
+public class BoundAggregator {
+    private final IMultisetAggregationOperator<?, ?, ?> operator;
+    private final Class<?> domainType;
+    private final Class<?> aggregateResultType;
+
+    public BoundAggregator(IMultisetAggregationOperator<?, ?, ?> operator, 
+            Class<?> domainType,
+            Class<?> aggregateResultType) {
+        super();
+        this.operator = operator;
+        this.domainType = domainType;
+        this.aggregateResultType = aggregateResultType;
+    }
+
+    public IMultisetAggregationOperator<?, ?, ?> getOperator() {
+        return operator;
+    }
+
+    public Class<?> getDomainType() {
+        return domainType;
+    }
+
+    public Class<?> getAggregateResultType() {
+        return aggregateResultType;
+    }
+
+    public IInputKey getDomainTypeAsInputKey() {
+        return toJavaInputKey(domainType);
+    }
+
+    public IInputKey getAggregateResultTypeAsInputKey() {
+        return toJavaInputKey(aggregateResultType);
+    }
+
+    private static IInputKey toJavaInputKey(Class<?> type) {
+        if (type==null) {
+            return null;
+        } else { 
+            return new JavaTransitiveInstancesKey(type);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IAggregatorFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IAggregatorFactory.java
new file mode 100644
index 00000000..c970bd6a
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IAggregatorFactory.java
@@ -0,0 +1,40 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Zoltan Ujhelyi, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.aggregations;
+
+/**
+ * 
+ * Describes an aggregation operator keyword, potentially with type polymorphism. The actual runtime
+ * {@link IMultisetAggregationOperator} that implements the aggregation logic may depend on the type context.
+ * 
+ * <p>
+ * Implementors are suggested to use lower-case classnames (as it will end up in the language) and are required use the
+ * annotation {@link AggregatorType} to indicate type inference rules.
+ * 
+ * <p>
+ * <strong>Important!</strong> Implemented aggregators must be (1) deterministic (2) pure and (3)support incremental
+ * value updates in the internal operation.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.4
+ */
+
+public interface IAggregatorFactory {
+
+    /**
+     * Given type parameters selected from {@link AggregatorType} annotations, returns a run-time aggregator operator
+     * that is bound to the actual types.
+     * 
+     * @param domainClass
+     *            Java type of the values that are being aggregated
+     * @return the actual run-time aggregator logic, with type bindings
+     */
+    public BoundAggregator getAggregatorLogic(Class<?> domainClass);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IMultisetAggregationOperator.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IMultisetAggregationOperator.java
new file mode 100644
index 00000000..3bc22274
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IMultisetAggregationOperator.java
@@ -0,0 +1,106 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.aggregations;
+
+import java.util.Collection;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.aggregators.ExtremumOperator;
+
+/**
+ * A single column aggregator is used to incrementally compute the aggregate of a multiset of values according to an aggregator operator.
+ * 
+ * <p> The operator provides two methods of computation: <ul>
+ *  <li>Stateless aggregation of an explicit multiset, provided by {@link #aggregateStatelessly(Collection)}.</li>
+ *  <li>Incremental aggregation, provided by {@link #createNeutral()}, {@link #update(Object, Object, boolean)}, {@link #isNeutral(Object)}, {@link #getAggregate(Object)}.    
+ * </ul>
+ * 
+ * <p> In case of incremental computation, the aggregable multiset is conceptual; it is not represented by an explicit Collection<Domain> object, but its update operations are tracked.  
+ * 
+ * <p> In case of incremental computation, internal results, potentially distinct from the final aggregate result, may be stored in a helper data structure called <b>accumulator</b>.
+ * The goal of this distinction is that the final result may not be sufficient for incremental updates (see e.g. {@link ExtremumOperator}).
+ * 
+ * @author Gabor Bergmann
+ *
+ * @param <Domain> the type of elements to be aggregated.
+ * @param <Accumulator> the type used to store the interim results of the aggregate computation, 
+ *  that may be incrementally refreshed upon updates to the multiset, and that can easily yield the final result.
+ * @param <AggregateResult> the type of the final result of the aggregation to be output.
+ * 
+ * @since 1.4
+ */
+public interface IMultisetAggregationOperator<Domain, Accumulator, AggregateResult> {
+    
+    /**
+     * A textual description of the operator.
+     */
+    String getShortDescription();
+    
+    /**
+     * A name or identifier of the operator.
+     */
+    String getName();
+    
+    /**
+     * @return the neutral element, i.e. the interim result of aggregating an empty multiset.
+     */
+    Accumulator createNeutral();
+    
+    /**
+     * @return true if the interim result is equivalent to the neutral element, as if there are no values in the multiset.
+     * Must return true if the multiset is empty.
+     */
+    boolean isNeutral(Accumulator result);
+
+    /**
+     * @return an updated intermediate result, 
+     *  changed to reflect that a given object was added to / removed from the multiset 
+     *      (as indicated by the parameter isInsertion)
+     */
+    Accumulator update(Accumulator oldResult, Domain updateValue, boolean isInsertion);
+    
+    /**
+     * @return the aggregate result obtained from the given intermediate result. 
+     * May be null to indicate that the current multiset cannot be aggregated (e.g. 0 elements have no minimum).
+     */
+    AggregateResult getAggregate(Accumulator result);
+
+    /**
+     * Calculates the aggregate results from a given stream of values; all values are considered as inserted
+     * @return the aggregate result, or null if no result can be calculated (e.g. because of an empty stream)
+     * @since 2.0
+     */
+    AggregateResult aggregateStream(Stream<Domain> stream);
+    
+    /**
+     * Clones the given accumulator (with all its internal contents).
+     */
+    default Accumulator clone(Accumulator original) {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * Combines the given aggregate result and accumulator into a single aggregate result. 
+     */
+    default AggregateResult combine(AggregateResult left, Accumulator right) {
+        throw new UnsupportedOperationException();
+    }
+    
+    default boolean contains(Domain value, Accumulator accumulator) {
+        throw new UnsupportedOperationException();
+    }
+    
+    /**
+     * Pretty prints the contents of the given accumulator. 
+     */
+    default String prettyPrint(final Accumulator accumulator) {
+        return accumulator.toString();
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/analysis/QueryAnalyzer.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/analysis/QueryAnalyzer.java
new file mode 100644
index 00000000..e3f28cff
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/analysis/QueryAnalyzer.java
@@ -0,0 +1,194 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.analysis;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryBackendContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.FunctionalDependencyHelper;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.PAnnotation;
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.ParameterReference;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Object responsible for computing and caching static query analysis results.
+ * <p> Any client can instantiate this to statically analyze queries. 
+ * Query backends should share an instance obtained via {@link IQueryBackendContext} to save resources.
+ * <p> Precondition: all involved queries must be initialized.
+ * @noinstantiate Considered unstable API; subject to change in future versions. 
+ * Either use the analyzer provided by {@link IQueryBackendContext}, or anticipate 
+ * potential future breakage when instantiating your own analyzer.
+ * @author Gabor Bergmann
+ * @since 1.5
+ */
+public final class QueryAnalyzer {
+    
+    private IQueryMetaContext metaContext;
+
+    public QueryAnalyzer(IQueryMetaContext metaContext) {
+        this.metaContext = metaContext;
+    }
+
+    // Functional dependencies
+    
+    /**
+     * Maps query and strictness to functional dependencies 
+     */
+    private Map<PQuery, Map<Set<Integer>, Set<Integer>>> strictFunctionalDependencyGuarantees =  
+            new HashMap<>();
+    private Map<PQuery, Map<Set<Integer>, Set<Integer>>> softFunctionalDependencyGuarantees =  
+            new HashMap<>();
+
+    /**
+     * Functional dependency information, expressed on query parameters, that the match set of the query is guaranteed to respect. 
+     * <p> The type dependencies shall be expressed on the <i>parameter index</i> integers, NOT the {@link PParameter} object.
+     * @return a non-null map of functional dependencies on parameters that can be processed by {@link FunctionalDependencyHelper}
+     * @param strict if true, only "hard" dependencies are taken into account that are strictly enforced by the model representation; 
+     *  if false, user-provided soft dependencies (@FunctionalDependency) are included as well, that are anticipated but not guaranteed by the storage mechanism;
+     *  use true if superfluous dependencies may taint the correctness of a computation, false if they would merely impact performance
+     * @since 1.5
+     */
+    public Map<Set<Integer>, Set<Integer>> getProjectedFunctionalDependencies(PQuery query, boolean strict) {
+        Map<PQuery, Map<Set<Integer>, Set<Integer>>> guaranteeStore =  strict ? strictFunctionalDependencyGuarantees : softFunctionalDependencyGuarantees;
+        Map<Set<Integer>, Set<Integer>> dependencies = guaranteeStore.get(query);
+        //  Why not computeIfAbsent? See Bug 532507
+        //      Invoked method #computeFunctionalDependencies may trigger functional dependency computation for called queries;
+        //      and may thus recurs back into #getProjectedFunctionalDependencies, causing a ConcurrentModificationException
+        //      if the called query has not been previously analyzed.
+        //
+        //      Note: if patterns are recursive, the empty accumulator will be found in the store 
+        //          (this yields a safe lower estimate and guarantees termination for #getProjectedFunctionalDependencies)
+        //          But this case probably will not occur due to recursive queries having a disjunction at some point, 
+        //          and thus ignored by #computeFunctionalDependencies  
+        if (dependencies == null) {
+            dependencies = new HashMap<>(); // accumulator
+            guaranteeStore.put(query, dependencies);
+            computeFunctionalDependencies(dependencies, query, strict);
+        }
+        return dependencies;
+    }
+
+    private void computeFunctionalDependencies(Map<Set<Integer>, Set<Integer>> accumulator, PQuery query, boolean strict) {
+        Set<PBody> bodies = query.getDisjunctBodies().getBodies();            
+        if (bodies.size() == 1) { // no support for recursion or disjunction
+
+            PBody body = bodies.iterator().next();
+            
+            // collect parameter variables
+            Map<PVariable, Integer> parameters = body.getSymbolicParameters().stream()
+                    .collect(Collectors.toMap(ExportedParameter::getParameterVariable,
+                            param -> query.getParameters().indexOf(param.getPatternParameter())));
+            
+            // collect all internal dependencies
+            Map<Set<PVariable>, Set<PVariable>> internalDependencies = 
+                    getFunctionalDependencies(body.getConstraints(), strict);
+            
+            // project onto parameter variables
+            Map<Set<PVariable>, Set<PVariable>> projectedDeps = 
+                    FunctionalDependencyHelper.projectDependencies(internalDependencies, parameters.keySet());
+            
+            // translate into indices
+            for (Entry<Set<PVariable>, Set<PVariable>> entry : projectedDeps.entrySet()) {
+                Set<Integer> left = new HashSet<Integer>();
+                Set<Integer> right = new HashSet<Integer>();
+                for (PVariable pVariable : entry.getKey()) {
+                    left.add(parameters.get(pVariable));
+                }
+                for (PVariable pVariable : entry.getValue()) {
+                    right.add(parameters.get(pVariable));
+                }
+                accumulator.put(left, right);
+            }
+            
+        } else {
+            // Disjunctive case, no dependencies are inferred
+            // TODO: we can still salvage the intersection of dependencies IF 
+            // - all bodies have disjoint match sets
+            // - and we avoid recursion
+        }
+        
+        // add annotation-based soft dependencies (regardless of number of bodies)
+        if (!strict) {
+            outer:
+                for (PAnnotation annotation : query.getAnnotationsByName("FunctionalDependency")) {
+                    Set<Integer> lefts = new HashSet<Integer>();
+                    Set<Integer> rights = new HashSet<Integer>();
+                    
+                    for (Object object : annotation.getAllValues("forEach")) {
+                        ParameterReference parameter = (ParameterReference) object;
+                        Integer position = query.getPositionOfParameter(parameter.getName());
+                        if (position == null) continue outer;
+                        lefts.add(position);
+                    }
+                    for (Object object : annotation.getAllValues("unique")) {
+                        ParameterReference parameter = (ParameterReference) object;
+                        Integer position = query.getPositionOfParameter(parameter.getName());
+                        if (position == null) continue outer;
+                        rights.add(position);
+                    }
+                    
+                    FunctionalDependencyHelper.includeDependency(accumulator, lefts, rights);
+                }
+        }
+    }
+
+    /**
+     * Functional dependency information, expressed on PVariables within a body, that the selected constraints imply. 
+     * @return a non-null map of functional dependencies on PVariables that can be processed by {@link FunctionalDependencyHelper}
+     * @param constraints the set of constraints whose consequences will be analyzed
+     * @param strict if true, only "hard" dependencies are taken into account that are strictly enforced by the model representation; 
+     *  if false, user-provided soft dependencies (@FunctionalDependency) are included as well, that are anticipated but not guaranteed by the storage mechanism;
+     *  use true if superfluous dependencies may taint the correctness of a computation, false if they would merely impact performance
+     * @since 1.5
+     */
+   public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(Set<? extends PConstraint> constraints, boolean strict) {
+        Map<Set<PVariable>, Set<PVariable>> accumulator = new HashMap<Set<PVariable>, Set<PVariable>>();
+        for (PConstraint pConstraint : constraints){
+            if (pConstraint instanceof PositivePatternCall) {
+                // use query analysis results instead
+                PositivePatternCall call = (PositivePatternCall) pConstraint;
+                PQuery query = call.getSupplierKey();
+                Map<Set<Integer>, Set<Integer>> paramDependencies = getProjectedFunctionalDependencies(query, strict);
+                for (Entry<Set<Integer>, Set<Integer>> entry : paramDependencies.entrySet()) {
+                    Set<PVariable> lefts = new HashSet<PVariable>();
+                    Set<PVariable> rights = new HashSet<PVariable>();
+                    
+                    for (Integer index : entry.getKey()) {
+                        lefts.add(call.getVariableInTuple(index));
+                    }
+                    for (Integer index : entry.getValue()) {
+                        rights.add(call.getVariableInTuple(index));
+                    }
+                    
+                    FunctionalDependencyHelper.includeDependency(accumulator, 
+                            lefts, rights);
+                }
+            } else {
+                // delegate to PConstraint
+                FunctionalDependencyHelper.includeDependencies(accumulator, 
+                        pConstraint.getFunctionalDependencies(metaContext));
+            }
+        }
+        return accumulator;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/PAnnotation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/PAnnotation.java
new file mode 100644
index 00000000..c4fbe0e9
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/PAnnotation.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.annotations;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.BiConsumer;
+
+import org.eclipse.collections.api.multimap.MutableMultimap;
+import org.eclipse.collections.impl.multimap.list.FastListMultimap;
+
+/**
+ * A container describing query annotations
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class PAnnotation {
+
+    private final String name;
+    private MutableMultimap<String, Object> attributes = FastListMultimap.newMultimap();
+
+    public PAnnotation(String name) {
+        this.name = name;
+
+    }
+
+    /**
+     * Adds an attribute to the annotation
+     * @param attributeName
+     * @param value
+     */
+    public void addAttribute(String attributeName, Object value) {
+        attributes.put(attributeName, value);
+    }
+
+    /**
+     * Return the name of the annotation
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns the value of the first occurrence of an attribute
+     * @param attributeName
+     * @return the attribute value, or null, if attribute is not available
+     * @since 2.0
+     */
+    public Optional<Object> getFirstValue(String attributeName) {
+        return getAllValues(attributeName).stream().findFirst();
+    }
+    
+    /**
+     * Returns the value of the first occurrence of an attribute
+     * @param attributeName
+     * @return the attribute value, or null, if attribute is not available
+     * @since 2.0
+     */
+    public <T> Optional<T> getFirstValue(String attributeName, Class<T> clazz) {
+        return getAllValues(attributeName).stream().filter(clazz::isInstance).map(clazz::cast).findFirst();
+    }
+
+    /**
+     * Returns all values of a selected attribute
+     * @param attributeName
+     * @return a non-null, but possibly empty list of attributes
+     */
+    public List<Object> getAllValues(String attributeName) {
+        return attributes.get(attributeName).toList();
+    }
+    
+    /**
+     * Executes a consumer over all attributes. A selected attribute name (key) can appear (and thus consumed) multiple times.
+     * @since 2.0
+     */
+    public void forEachValue(BiConsumer<String, Object> consumer) {
+        attributes.forEachKeyValue(consumer::accept);
+    }
+
+    /**
+     * Returns a set of all attribute names used in this annotation
+     * @since 2.1
+     */
+    public Set<String> getAllAttributeNames() {
+        return attributes.keySet().toSet();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/ParameterReference.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/ParameterReference.java
new file mode 100644
index 00000000..c67e9046
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/ParameterReference.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.annotations;
+
+/**
+ * An annotation parameter referencing a query parameter by name. Does not check whether the parameter exists.
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class ParameterReference {
+
+    final String name;
+
+    public ParameterReference(String name) {
+        super();
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/AggregatorConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/AggregatorConstraint.java
new file mode 100644
index 00000000..56f86e89
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/AggregatorConstraint.java
@@ -0,0 +1,98 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeInfoProviderConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.aggregations.BoundAggregator;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * The PSystem representation of an aggregation.
+ * 
+ * @author Tamas Szabo
+ * @since 1.4
+ */
+public class AggregatorConstraint extends PatternCallBasedDeferred implements ITypeInfoProviderConstraint {
+
+    protected PVariable resultVariable;
+    private BoundAggregator aggregator;
+    protected int aggregatedColumn;
+
+    public AggregatorConstraint(BoundAggregator aggregator, PBody pBody, Tuple actualParametersTuple, PQuery query,
+            PVariable resultVariable, int aggregatedColumn) {
+        super(pBody, actualParametersTuple, query, Collections.singleton(resultVariable));
+        this.resultVariable = resultVariable;
+        this.aggregatedColumn = aggregatedColumn;
+        this.aggregator = aggregator;
+    }
+
+    public int getAggregatedColumn() {
+        return this.aggregatedColumn;
+    }
+
+    public BoundAggregator getAggregator() {
+        return this.aggregator;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.singleton(resultVariable);
+    }
+
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        final Map<Set<PVariable>, Set<PVariable>> result = new HashMap<Set<PVariable>, Set<PVariable>>();
+        result.put(getDeferringVariables(), getDeducedVariables());
+        return result;
+    }
+
+    @Override
+    protected void doDoReplaceVariables(PVariable obsolete, PVariable replacement) {
+        if (resultVariable.equals(obsolete))
+            resultVariable = replacement;
+    }
+
+    @Override
+    protected Set<PVariable> getCandidateQuantifiedVariables() {
+        return actualParametersTuple.<PVariable> getDistinctElements();
+    }
+
+    @Override
+    protected String toStringRest() {
+        return query.getFullyQualifiedName() + "@" + actualParametersTuple.toString() + "->"
+                + resultVariable.toString();
+    }
+
+    public PVariable getResultVariable() {
+        return resultVariable;
+    }
+
+    @Override
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+        Set<TypeJudgement> result = new HashSet<TypeJudgement>();
+        IInputKey aggregateResultType = aggregator.getAggregateResultTypeAsInputKey();
+        if (aggregateResultType != null) {
+            result.add(new TypeJudgement(aggregateResultType, Tuples.staticArityFlatTupleOf(resultVariable)));
+        }
+        return result;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/BaseTypeSafeConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/BaseTypeSafeConstraint.java
new file mode 100644
index 00000000..7bc949a8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/BaseTypeSafeConstraint.java
@@ -0,0 +1,99 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class BaseTypeSafeConstraint extends
+        VariableDeferredPConstraint {
+    
+    protected Set<PVariable> inputVariables;
+    protected PVariable outputVariable;
+
+    public PVariable getOutputVariable() {
+        return outputVariable;
+    }
+
+    /**
+     * @param pBody
+     * @param inputVariables
+     * @param outputVariable null iff no output (check-only)
+     */
+    public BaseTypeSafeConstraint(PBody pBody,
+            Set<PVariable> inputVariables, final PVariable outputVariable) {
+        super(pBody, 
+                (outputVariable == null) ? 
+                        inputVariables : 
+                            Stream.concat(inputVariables.stream(), Stream.of(outputVariable)).collect(Collectors.toSet())
+                    );
+        this.inputVariables = inputVariables;
+        this.outputVariable = outputVariable;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        if (outputVariable == null) 
+            return Collections.emptySet(); 
+        else
+            return Collections.singleton(outputVariable);
+    }
+
+    @Override
+    public Set<PVariable> getDeferringVariables() {
+        return inputVariables;
+    }
+
+    @Override
+    public boolean isReadyAt(SubPlan plan, IQueryMetaContext context) {
+        if (super.isReadyAt(plan, context)) {
+            return checkTypeSafety(plan, context) == null;
+        }
+        return false;
+    }
+
+    /**
+     * Checks whether all type restrictions are already enforced on affected variables.
+     * 
+     * @param plan
+     * @return a variable whose type safety is not enforced yet, or null if the plan is typesafe
+     */
+    public PVariable checkTypeSafety(SubPlan plan, IQueryMetaContext context) {
+        Set<TypeJudgement> impliedJudgements = plan.getAllImpliedTypeJudgements(context);
+        
+        for (PVariable pVariable : inputVariables) {
+            Set<TypeJudgement> allTypeRestrictionsForVariable = pBody.getAllUnaryTypeRestrictions(context).get(pVariable);
+            if (allTypeRestrictionsForVariable != null && !impliedJudgements.containsAll(allTypeRestrictionsForVariable))
+                return pVariable;
+        }
+        return null;
+    }
+    
+    @Override
+    protected void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        if (inputVariables.remove(obsolete)) 
+            inputVariables.add(replacement);
+        if (outputVariable == obsolete) 
+            outputVariable = replacement;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Equality.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Equality.java
new file mode 100644
index 00000000..b978b62c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Equality.java
@@ -0,0 +1,96 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.SubPlan;
+import tools.refinery.viatra.runtime.matchers.psystem.DeferredPConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class Equality extends DeferredPConstraint {
+
+    private PVariable who;
+    private PVariable withWhom;
+
+    public Equality(PBody pBody, PVariable who, PVariable withWhom) {
+        super(pBody, buildSet(who, withWhom));
+        this.who = who;
+        this.withWhom = withWhom;
+    }
+
+    private static Set<PVariable> buildSet(PVariable who, PVariable withWhom) {
+        Set<PVariable> set = new HashSet<PVariable>();
+        set.add(who);
+        set.add(withWhom);
+        return set;
+    }
+
+    /**
+     * An equality is moot if it compares the a variable with itself.
+     * 
+     * @return true, if the equality is moot
+     */
+    public boolean isMoot() {
+        return who.equals(withWhom);
+    }
+
+    @Override
+    public void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        if (obsolete.equals(who))
+            who = replacement;
+        if (obsolete.equals(withWhom))
+            withWhom = replacement;
+    }
+
+    @Override
+    protected String toStringRest() {
+        return who.getName() + "=" + withWhom.getName();
+    }
+
+    public PVariable getWho() {
+        return who;
+    }
+
+    public PVariable getWithWhom() {
+        return withWhom;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.emptySet();
+    }
+    
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        final Map<Set<PVariable>, Set<PVariable>> result = new HashMap<Set<PVariable>, Set<PVariable>>();
+        result.put(Collections.singleton(who), Collections.singleton(withWhom));
+        result.put(Collections.singleton(withWhom), Collections.singleton(who));
+        return result;
+    }
+
+    @Override
+    public boolean isReadyAt(SubPlan plan, IQueryMetaContext context) {
+        return plan.getVisibleVariables().contains(who) && plan.getVisibleVariables().contains(withWhom);
+        // will be replaced by || if copierNode is available;
+        // until then, LayoutHelper.unifyVariablesAlongEqualities(PSystem<PatternDescription, StubHandle, Collector>) is
+        // recommended.
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExportedParameter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExportedParameter.java
new file mode 100644
index 00000000..80706792
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExportedParameter.java
@@ -0,0 +1,108 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * @author Gabor Bergmann
+ *
+ */
+public class ExportedParameter extends VariableDeferredPConstraint {
+    PVariable parameterVariable;
+    final String parameterName;
+    final PParameter patternParameter;
+
+    /**
+     * @since 1.4
+     */
+    public ExportedParameter(PBody pBody, PVariable parameterVariable, PParameter patternParameter) {
+        super(pBody, Collections.singleton(parameterVariable));
+        this.parameterVariable = parameterVariable;
+        this.patternParameter = patternParameter;
+        parameterName = patternParameter.getName();
+    }
+
+    @Override
+    public void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        if (obsolete.equals(parameterVariable))
+            parameterVariable = replacement;
+    }
+
+    @Override
+    protected String toStringRest() {
+        Object varName = parameterVariable.getName();
+        return parameterName.equals(varName) ? parameterName : parameterName + "(" + varName + ")";
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * The name of the parameter; usually, it is expected that {@link #getParameterVariable()} is more useful, except
+     * maybe for debugging purposes.
+     * 
+     * @return a non-null name of the parameter
+     */
+    public String getParameterName() {
+        return parameterName;
+    }
+
+    public PVariable getParameterVariable() {
+        return parameterVariable;
+    }
+
+    /**
+     * @since 1.4
+     */
+    public PParameter getPatternParameter() {
+        if (patternParameter == null) {
+            PQuery query = pBody.getPattern();
+            Integer index = query.getPositionOfParameter(parameterName);
+            if (index == null) {
+                throw new IllegalStateException(String.format("Pattern %s does not have a parameter named %s",
+                        query.getFullyQualifiedName(), parameterName));
+            }
+            return query.getParameters().get(index);
+        } else {
+            return patternParameter;
+        }
+    }
+
+    @Override
+    public Set<PVariable> getDeferringVariables() {
+        return Collections.singleton(parameterVariable);
+    }
+
+    @Override
+    public void checkSanity() {
+        super.checkSanity();
+        if (!parameterVariable.isDeducable()) {
+            String[] args = { parameterName };
+            String msg = "Impossible to match pattern: "
+                    + "exported pattern variable {1} can not be determined based on the pattern constraints. "
+                    + "HINT: certain constructs (e.g. negative patterns or check expressions) cannot output symbolic parameters.";
+            String shortMsg = "Could not deduce value of parameter";
+            throw new QueryProcessingException(msg, args, shortMsg, null);
+        }
+
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExpressionEvaluation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExpressionEvaluation.java
new file mode 100644
index 00000000..06688c36
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExpressionEvaluation.java
@@ -0,0 +1,80 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class ExpressionEvaluation extends BaseTypeSafeConstraint {
+
+    private IExpressionEvaluator evaluator;
+    private boolean isUnwinding;
+
+    public ExpressionEvaluation(PBody pBody, IExpressionEvaluator evaluator, PVariable outputVariable) {
+        this(pBody, evaluator, outputVariable, false);
+    }
+
+    /**
+     * @since 2.4
+     */
+    public ExpressionEvaluation(PBody pBody, IExpressionEvaluator evaluator, PVariable outputVariable,
+            boolean isUnwinding) {
+        super(pBody, getPVariablesOfExpression(pBody, evaluator), outputVariable);
+        this.evaluator = evaluator;
+        this.isUnwinding = isUnwinding;
+    }
+
+    /**
+     * @since 2.4
+     */
+    public boolean isUnwinding() {
+        return isUnwinding;
+    }
+
+    public IExpressionEvaluator getEvaluator() {
+        return evaluator;
+    }
+
+    @Override
+    protected String toStringRest() {
+        return Tuples.flatTupleOf(new ArrayList<PVariable>(inputVariables).toArray()).toString() + "|="
+                + evaluator.getShortDescription();
+    }
+
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        if (outputVariable == null)
+            return Collections.emptyMap();
+        else
+            return Collections.singletonMap(inputVariables, Collections.singleton(outputVariable));
+    }
+
+    private static Set<PVariable> getPVariablesOfExpression(PBody pBody, IExpressionEvaluator evaluator) {
+        // use a linked set, so that the variables will come in the order of the parameters
+        Set<PVariable> result = new LinkedHashSet<PVariable>();
+        for (String name : evaluator.getInputParameterNames()) {
+            PVariable variable = pBody.getOrCreateVariableByName(name);
+            result.add(variable);
+        }
+        return result;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Inequality.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Inequality.java
new file mode 100644
index 00000000..5cac33dc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Inequality.java
@@ -0,0 +1,151 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class Inequality extends VariableDeferredPConstraint {
+
+    private PVariable who;
+    private PVariable withWhom;
+
+    /**
+     * The inequality constraint is weak if it can be ignored when who is the same as withWhom, or if any if them is
+     * undeducible.
+     */
+    private boolean weak;
+
+    public Inequality(PBody pBody, PVariable who, PVariable withWhom) {
+        this(pBody, who, withWhom, false);
+    }
+
+    public Inequality(PBody pBody, PVariable who, PVariable withWhom,
+            boolean weak) {
+        super(pBody, new HashSet<>(Arrays.asList(who, withWhom) ));
+        this.who = who;
+        this.withWhom = withWhom;
+        this.weak = weak;
+    }
+
+    // private Inequality(
+    // PSystem<PatternDescription, StubHandle, ?> pSystem,
+    // PVariable subject, Set<PVariable> inequals)
+    // {
+    // super(pSystem, include(inequals, subject));
+    // this.subject = subject;
+    // this.inequals = inequals;
+    // }
+
+    // private static HashSet<PVariable> include(Set<PVariable> inequals, PVariable subject) {
+    // HashSet<PVariable> hashSet = new HashSet<PVariable>(inequals);
+    // hashSet.add(subject);
+    // return hashSet;
+    // }
+
+    @Override
+    public Set<PVariable> getDeferringVariables() {
+        return getAffectedVariables();
+    }
+
+    // private static int[] mapIndices(Map<Object, Integer> variablesIndex, Set<PVariable> keys) {
+    // int[] result = new int[keys.size()];
+    // int k = 0;
+    // for (PVariable key : keys) {
+    // result[k++] = variablesIndex.get(key);
+    // }
+    // return result;
+    // }
+
+    // @Override
+    // public IFoldablePConstraint getIncorporator() {
+    // return incorporator;
+    // }
+    //
+    // @Override
+    // public void registerIncorporatationInto(IFoldablePConstraint incorporator) {
+    // this.incorporator = incorporator;
+    // }
+    //
+    // @Override
+    // public boolean incorporate(IFoldablePConstraint other) {
+    // if (other instanceof Inequality<?, ?>) {
+    // Inequality other2 = (Inequality) other;
+    // if (subject.equals(other2.subject)) {
+    // Set<PVariable> newInequals = new HashSet<PVariable>(inequals);
+    // newInequals.addAll(other2.inequals);
+    // return new Inequality<PatternDescription, StubHandle>(buildable, subject, newInequals);
+    // }
+    // } else return false;
+    // }
+
+    @Override
+    protected String toStringRest() {
+        return who.toString() + (isWeak() ? "!=?" : "!=") + withWhom.toString();
+    }
+
+    @Override
+    public void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        if (obsolete.equals(who))
+            who = replacement;
+        if (obsolete.equals(withWhom))
+            withWhom = replacement;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * The inequality constraint is weak if it can be ignored when who is the same as withWhom, or if any if them is
+     * undeducible.
+     * 
+     * @return the weak
+     */
+    public boolean isWeak() {
+        return weak;
+    }
+
+    /**
+     * A weak inequality constraint is eliminable if who is the same as withWhom, or if any if them is undeducible.
+     */
+    public boolean isEliminable() {
+        return isWeak() && (who.equals(withWhom) || !who.isDeducable() || !withWhom.isDeducable());
+    }
+
+    /**
+     * Eliminates a weak inequality constraint if it can be ignored when who is the same as withWhom, or if any if them
+     * is undeducible.
+     */
+    public void eliminateWeak() {
+        if (isEliminable())
+            delete();
+    }
+
+    public PVariable getWho() {
+        return who;
+    }
+
+    public PVariable getWithWhom() {
+        return withWhom;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/NegativePatternCall.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/NegativePatternCall.java
new file mode 100644
index 00000000..87d9d9fc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/NegativePatternCall.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class NegativePatternCall extends PatternCallBasedDeferred {
+
+    public NegativePatternCall(PBody pBody, Tuple actualParametersTuple, PQuery query) {
+        super(pBody, actualParametersTuple, query);
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.emptySet();
+    }
+
+    /**
+     * @return all variables that may potentially be quantified they are not used anywhere else
+     */
+    @Override
+    protected Set<PVariable> getCandidateQuantifiedVariables() {
+        return getAffectedVariables();
+    }
+
+    @Override
+    protected void doDoReplaceVariables(PVariable obsolete, PVariable replacement) {
+    }
+
+    @Override
+    protected String toStringRest() {
+        return "!" + query.getFullyQualifiedName() + "@" + actualParametersTuple.toString();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternCallBasedDeferred.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternCallBasedDeferred.java
new file mode 100644
index 00000000..93eeffec
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternCallBasedDeferred.java
@@ -0,0 +1,118 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * @author Gabor Bergmann
+ *
+ */
+public abstract class PatternCallBasedDeferred extends VariableDeferredPConstraint implements IQueryReference {
+
+    protected Tuple actualParametersTuple;
+
+    protected abstract void doDoReplaceVariables(PVariable obsolete, PVariable replacement);
+
+    protected abstract Set<PVariable> getCandidateQuantifiedVariables();
+
+    protected PQuery query;
+    private Set<PVariable> deferringVariables;
+
+    public PatternCallBasedDeferred(PBody pBody, Tuple actualParametersTuple,
+            PQuery pattern, Set<PVariable> additionalAffectedVariables) {
+        super(pBody, union(actualParametersTuple.<PVariable> getDistinctElements(), additionalAffectedVariables));
+        this.actualParametersTuple = actualParametersTuple;
+        this.query = pattern;
+    }
+
+    public PatternCallBasedDeferred(PBody pBody, Tuple actualParametersTuple,
+            PQuery pattern) {
+        this(pBody, actualParametersTuple, pattern, Collections.<PVariable> emptySet());
+    }
+
+    private static Set<PVariable> union(Set<PVariable> a, Set<PVariable> b) {
+        Set<PVariable> result = new HashSet<PVariable>();
+        result.addAll(a);
+        result.addAll(b);
+        return result;
+    }
+
+    @Override
+    public Set<PVariable> getDeferringVariables() {
+        if (deferringVariables == null) {
+            deferringVariables = new HashSet<PVariable>();
+            for (PVariable var : getCandidateQuantifiedVariables()) {
+                if (var.isDeducable())
+                    deferringVariables.add(var);
+            }
+        }
+        return deferringVariables;
+    }
+
+    @Override
+    public void checkSanity() {
+        super.checkSanity();
+        for (Object obj : this.actualParametersTuple.getDistinctElements()) {
+            PVariable var = (PVariable) obj;
+            if (!getDeferringVariables().contains(var)) {
+                // so this is a free variable of the NAC / aggregation?
+                for (PConstraint pConstraint : var.getReferringConstraints()) {
+                    if (pConstraint != this
+                            && !(pConstraint instanceof Equality && ((Equality) pConstraint).isMoot()))
+                        throw new QueryProcessingException (
+                                "Variable {1} of constraint {2} is not a positively determined part of the pattern, yet it is also affected by {3}.",
+                                new String[] { var.toString(), this.toString(), pConstraint.toString() },
+                                "Read-only variable can not be deduced", null);
+                }
+            }
+        }
+
+    }
+
+//    public SubPlan getSidePlan(IOperationCompiler compiler) throws QueryPlannerException {
+//        SubPlan sidePlan = compiler.patternCallPlan(actualParametersTuple, query);
+//        sidePlan = BuildHelper.enforceVariableCoincidences(compiler, sidePlan);
+//        return sidePlan;
+//    }
+
+    @Override
+    protected void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        if (deferringVariables != null) {
+            // FAIL instead of hopeless attempt to fix
+            // if (deferringVariables.remove(obsolete)) deferringVariables.add(replacement);
+            throw new IllegalStateException("Cannot replace variables on " + this
+                    + " when deferring variables have already been identified.");
+        }
+        actualParametersTuple = actualParametersTuple.replaceAll(obsolete, replacement);
+        doDoReplaceVariables(obsolete, replacement);
+    }
+
+    public Tuple getActualParametersTuple() {
+        return actualParametersTuple;
+    }
+
+    @Override
+    public PQuery getReferredQuery() {
+        return query;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternMatchCounter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternMatchCounter.java
new file mode 100644
index 00000000..0c40d91e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternMatchCounter.java
@@ -0,0 +1,70 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * @author Gabor Bergmann
+ */
+public class PatternMatchCounter extends PatternCallBasedDeferred {
+
+    private PVariable resultVariable;
+
+    public PatternMatchCounter(PBody pBody, Tuple actualParametersTuple,
+            PQuery query, PVariable resultVariable) {
+        super(pBody, actualParametersTuple, query, Collections.singleton(resultVariable));
+        this.resultVariable = resultVariable;
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.singleton(resultVariable);
+    }
+    
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        final Map<Set<PVariable>, Set<PVariable>> result = new HashMap<Set<PVariable>, Set<PVariable>>();
+        result.put(getDeferringVariables(), getDeducedVariables());
+        return result;
+    }
+
+    @Override
+    protected void doDoReplaceVariables(PVariable obsolete, PVariable replacement) {
+        if (resultVariable.equals(obsolete))
+            resultVariable = replacement;
+    }
+
+    @Override
+    protected Set<PVariable> getCandidateQuantifiedVariables() {
+        return actualParametersTuple.<PVariable> getDistinctElements();
+    }
+
+
+    @Override
+    protected String toStringRest() {
+        return query.getFullyQualifiedName() + "@" + actualParametersTuple.toString() + "->"
+                + resultVariable.toString();
+    }
+
+    public PVariable getResultVariable() {
+        return resultVariable;
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/RelationEvaluation.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/RelationEvaluation.java
new file mode 100644
index 00000000..336a83fb
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/RelationEvaluation.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2022, Tamas Szabo, GitHub
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.psystem.EnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.IMultiQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.IRelationEvaluator;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * A constraint which prescribes the evaluation of custom Java logic that takes an arbitrary number of input relations
+ * and produces one output relation. Contrast this to {@link ExpressionEvaluation}, which produces a single output value
+ * given an input tuple.
+ * 
+ * The assumption is that the relation evaluation logic is not incremental, that is, it can only perform from-scratch
+ * computation of the output relation given the complete input relations. To this end, the relation evaluator always
+ * receives the complete input relations with all their contents as input. However, the evaluator engine makes sure that
+ * the output of the relation evaluation is at least "seemingly" incremental. This means that the underlying computation
+ * network computes the delta on the output compared to the previous output and only propagates the delta further.
+ * 
+ * @author Tamas Szabo
+ * 
+ * @since 2.8
+ *
+ */
+public class RelationEvaluation extends EnumerablePConstraint implements IMultiQueryReference {
+
+    private final IRelationEvaluator evaluator;
+    private final List<PQuery> inputQueries;
+
+    public RelationEvaluation(final PBody body, final Tuple variablesTuple, final List<PQuery> inputQueries,
+            final IRelationEvaluator evaluator) {
+        super(body, variablesTuple);
+        this.evaluator = evaluator;
+        this.inputQueries = inputQueries;
+    }
+
+    public IRelationEvaluator getEvaluator() {
+        return this.evaluator;
+    }
+
+    @Override
+    public List<PQuery> getReferredQueries() {
+        return this.inputQueries;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/TypeFilterConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/TypeFilterConstraint.java
new file mode 100644
index 00000000..8b6e29ef
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/TypeFilterConstraint.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicdeferred;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.VariableDeferredPConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Represents a non-enumerable type constraint that asserts that values substituted for the given tuple of variables 
+ *      form a tuple that belongs to a (typically non-enumerable) extensional relation identified by an {@link IInputKey}.
+ * 
+ * <p> The InputKey is typically not enumerable. If it is enumerable, use {@link TypeConstraint} instead, so that the PConstraint carries over the property of enumerability.
+ * 
+ * @author Bergmann Gabor
+ *
+ */
+public class TypeFilterConstraint extends VariableDeferredPConstraint implements
+        ITypeConstraint {
+
+    private Tuple variablesTuple;
+    private IInputKey inputKey;
+    
+    private TypeJudgement equivalentJudgement;
+
+    
+    public TypeFilterConstraint(PBody pBody, Tuple variablesTuple, IInputKey inputKey) {
+        super(pBody, variablesTuple.<PVariable> getDistinctElements());
+        this.equivalentJudgement = new TypeJudgement(inputKey, variablesTuple);
+
+        this.variablesTuple = variablesTuple;
+        this.inputKey = inputKey;
+        
+        if (variablesTuple.getSize() != inputKey.getArity())
+            throw new IllegalArgumentException(
+                    this.getClass().getSimpleName() + 
+                    " applied for variable tuple " + variablesTuple + " having wrong arity for input key " + 
+                            inputKey);
+   }
+
+    
+    
+    public Tuple getVariablesTuple() {
+        return variablesTuple;
+    }
+
+    public IInputKey getInputKey() {
+        return inputKey;
+    }
+
+    @Override
+    public TypeJudgement getEquivalentJudgement() {
+        return equivalentJudgement;
+    }
+
+    @Override
+    protected void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        variablesTuple = variablesTuple.replaceAll(obsolete, replacement);
+        this.equivalentJudgement = new TypeJudgement(inputKey, variablesTuple);
+    }
+
+    @Override
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+        return Collections.singleton(equivalentJudgement);
+    }
+
+    @Override
+    public Set<PVariable> getDeducedVariables() {
+        return Collections.emptySet();
+    }
+
+    @Override
+    public Set<PVariable> getDeferringVariables() {
+        return getAffectedVariables();
+    }
+
+    @Override
+    protected String toStringRest() {
+        return inputKey.getPrettyPrintableName() + "@" + variablesTuple;
+    }
+    
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        return TypeConstraintUtil.getFunctionalDependencies(context, inputKey, variablesTuple);
+    }
+
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/AbstractTransitiveClosure.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/AbstractTransitiveClosure.java
new file mode 100644
index 00000000..7bbf7118
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/AbstractTransitiveClosure.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeInfoProviderConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.KeyedEnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * @since 2.0
+ */
+public abstract class AbstractTransitiveClosure extends KeyedEnumerablePConstraint<PQuery> implements IQueryReference, ITypeInfoProviderConstraint {
+
+    public AbstractTransitiveClosure(PBody pBody, Tuple variablesTuple, PQuery supplierKey) {
+        super(pBody, variablesTuple, supplierKey);
+    }
+
+    @Override
+    public PQuery getReferredQuery() {
+        return supplierKey;
+    }
+
+    /**
+     * @since 1.3
+     */
+    @Override
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+        return PositivePatternCall.getTypesImpliedByCall(supplierKey, variablesTuple);
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryReflexiveTransitiveClosure.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryReflexiveTransitiveClosure.java
new file mode 100644
index 00000000..e3dae240
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryReflexiveTransitiveClosure.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Zoltan Ujhelyi, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * For a binary base pattern over an enumerable universe type, computes the reflexive transitive closure (base)*
+ * 
+ * @author Gabor Bergmann, Zoltan Ujhelyi
+ * @since 2.0
+ */
+public class BinaryReflexiveTransitiveClosure extends AbstractTransitiveClosure {
+
+    private final IInputKey universeType;
+
+    public BinaryReflexiveTransitiveClosure(PBody pBody, Tuple variablesTuple,
+            PQuery pattern, IInputKey universeType) {
+        super(pBody, variablesTuple, pattern);
+        this.universeType = universeType;
+    }
+
+    @Override
+    protected String keyToString() {
+        return supplierKey.getFullyQualifiedName() + "*";
+    }
+
+    /**
+     * Returns the type whose instances should be returned as 0-long paths. 
+     * @since 2.0
+     */
+    public IInputKey getUniverseType() {
+        return universeType;
+    }
+
+    @Override
+    public void checkSanity() {
+        if (!universeType.isEnumerable() || universeType.getArity() != 1) {
+            throw new QueryProcessingException(
+                    String.format("Invalid universe type %s - it should be enumerable and must have an arity of 1.",
+                            universeType.getPrettyPrintableName()),
+                    pBody.getPattern());
+        }
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryTransitiveClosure.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryTransitiveClosure.java
new file mode 100644
index 00000000..716d043b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryTransitiveClosure.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * For a binary base pattern, computes the irreflexive transitive closure (base)+
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class BinaryTransitiveClosure extends AbstractTransitiveClosure {
+
+    public BinaryTransitiveClosure(PBody pBody, Tuple variablesTuple,
+            PQuery pattern) {
+        super(pBody, variablesTuple, pattern);
+    }
+
+    @Override
+    protected String keyToString() {
+        return supplierKey.getFullyQualifiedName() + "+";
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/Connectivity.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/Connectivity.java
new file mode 100644
index 00000000..10da2e21
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/Connectivity.java
@@ -0,0 +1,11 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+public enum Connectivity {
+        WEAK,
+        STRONG;
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/ConstantValue.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/ConstantValue.java
new file mode 100644
index 00000000..251146c8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/ConstantValue.java
@@ -0,0 +1,57 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.KeyedEnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * @author Gabor Bergmann
+ * 
+ */
+public class ConstantValue extends KeyedEnumerablePConstraint<Object> {
+
+    private PVariable variable;
+
+    public ConstantValue(PBody pBody, PVariable variable, Object value) {
+        super(pBody, Tuples.staticArityFlatTupleOf(variable), value);
+        this.variable = variable;
+    }
+
+    @Override
+    protected String keyToString() {
+        return supplierKey.toString();
+    }
+    
+    /**
+     * @since 1.7
+     */
+    public PVariable getVariable() {
+        return variable;
+    }
+    
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        final Map<Set<PVariable>, Set<PVariable>> result = new HashMap<Set<PVariable>, Set<PVariable>>();
+        final Set<PVariable> emptySet = Collections.emptySet(); // a constant value is functionally determined by everything
+        result.put(emptySet, Collections.singleton(getVariableInTuple(0)));
+        return result;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/PositivePatternCall.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/PositivePatternCall.java
new file mode 100644
index 00000000..25ab34b4
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/PositivePatternCall.java
@@ -0,0 +1,76 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.IQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeInfoProviderConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.KeyedEnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * @author Gabor Bergmann
+ *
+ */
+public class PositivePatternCall extends KeyedEnumerablePConstraint<PQuery> implements IQueryReference, ITypeInfoProviderConstraint {
+
+    public PositivePatternCall(PBody pBody, Tuple variablesTuple,
+            PQuery pattern) {
+        super(pBody, variablesTuple, pattern);
+    }
+
+    @Override
+    protected String keyToString() {
+        return supplierKey.getFullyQualifiedName();
+    }
+
+    // Note: #getFunctionalDependencies is intentionally not implemented - use QueryAnalyzer instead!
+//    @Override
+//    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+//        return super.getFunctionalDependencies(context);
+//    }
+
+    @Override
+    public PQuery getReferredQuery() {
+        return supplierKey;
+    }
+
+    @Override
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+        return getTypesImpliedByCall(supplierKey, variablesTuple);
+    }
+
+    /**
+     * @since 1.3
+     */
+    public static Set<TypeJudgement> getTypesImpliedByCall(PQuery calledQuery, Tuple actualParametersTuple) {
+        Set<TypeJudgement> result = new HashSet<TypeJudgement>();
+        for (TypeJudgement parameterJudgement : calledQuery.getTypeGuarantees()) {                      
+            IInputKey inputKey = parameterJudgement.getInputKey();
+            Tuple judgementIndexTuple = parameterJudgement.getVariablesTuple();
+            
+            Object[] judgementVariables = new Object[judgementIndexTuple.getSize()];
+            for (int i=0; i<judgementVariables.length; ++i)
+                judgementVariables[i] = actualParametersTuple.get((int) judgementIndexTuple.get(i));
+            
+            result.add(new TypeJudgement(inputKey, Tuples.flatTupleOf(judgementVariables))); 
+        }
+        return result;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/RepresentativeElectionConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/RepresentativeElectionConstraint.java
new file mode 100644
index 00000000..b97ff55f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/RepresentativeElectionConstraint.java
@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: 2023 The Refinery Authors <https://refinery.tools/>
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.*;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+import java.util.Set;
+
+public class RepresentativeElectionConstraint extends KeyedEnumerablePConstraint<PQuery>
+                implements IQueryReference, ITypeInfoProviderConstraint {
+        private final Connectivity connectivity;
+
+        public RepresentativeElectionConstraint(PBody pBody, Tuple variablesTuple, PQuery supplierKey,
+                                                                                        Connectivity connectivity) {
+                super(pBody, variablesTuple, supplierKey);
+                this.connectivity = connectivity;
+        }
+
+        public Connectivity getConnectivity() {
+                return connectivity;
+        }
+
+        @Override
+        public PQuery getReferredQuery() {
+                return supplierKey;
+        }
+
+        @Override
+        public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+                return PositivePatternCall.getTypesImpliedByCall(supplierKey, variablesTuple);
+        }
+
+        @Override
+        protected String keyToString() {
+                return supplierKey.getFullyQualifiedName() + "#" + connectivity + "#representative";
+        }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/TypeConstraint.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/TypeConstraint.java
new file mode 100644
index 00000000..2ca54cc0
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/TypeConstraint.java
@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.basicenumerables;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.KeyedEnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * Represents an enumerable type constraint that asserts that values substituted for the given tuple of variables 
+ *      form a tuple that belongs to an enumerable extensional relation identified by an {@link IInputKey}.
+ *
+ * <p> The InputKey must be enumerable!
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class TypeConstraint extends KeyedEnumerablePConstraint<IInputKey> implements ITypeConstraint {
+    
+    private TypeJudgement equivalentJudgement;
+    
+    public TypeConstraint(PBody pBody, Tuple variablesTuple, IInputKey inputKey) {
+        super(pBody, variablesTuple, inputKey);
+        this.equivalentJudgement = new TypeJudgement(inputKey, variablesTuple);
+        
+        if (! inputKey.isEnumerable())
+            throw new IllegalArgumentException(
+                    this.getClass().getSimpleName() + 
+                    " applicable for enumerable input keys only; received instead " + 
+                            inputKey);
+        if (variablesTuple.getSize() != inputKey.getArity())
+            throw new IllegalArgumentException(
+                    this.getClass().getSimpleName() + 
+                    " applied for variable tuple " + variablesTuple + " having wrong arity for input key " + 
+                            inputKey);
+    }
+
+    @Override
+    protected String keyToString() {
+        return supplierKey.getPrettyPrintableName();
+    }
+    
+    @Override
+    public TypeJudgement getEquivalentJudgement() {
+        return equivalentJudgement;
+    }
+
+    @Override
+    public Set<TypeJudgement> getImpliedJudgements(IQueryMetaContext context) {
+        return Collections.singleton(equivalentJudgement);
+        //return equivalentJudgement.getDirectlyImpliedJudgements(context);
+    }
+    
+    @Override
+    public Map<Set<PVariable>, Set<PVariable>> getFunctionalDependencies(IQueryMetaContext context) {
+        return TypeConstraintUtil.getFunctionalDependencies(context, supplierKey, variablesTuple);
+    }
+
+    @Override
+    public void doReplaceVariable(PVariable obsolete, PVariable replacement) {
+        super.doReplaceVariable(obsolete, replacement);
+        this.equivalentJudgement = new TypeJudgement(getSupplierKey(), variablesTuple);
+    }
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/BasePQuery.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/BasePQuery.java
new file mode 100644
index 00000000..2c03a894
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/BasePQuery.java
@@ -0,0 +1,231 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendFactory;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.PAnnotation;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Default implementation of PQuery.
+ * 
+ * @author Bergmann Gabor
+ */
+public abstract class BasePQuery implements PQuery {
+
+        protected PQueryStatus status = PQueryStatus.UNINITIALIZED;
+        /**
+     * @since 2.0
+     */
+        protected final PVisibility visibility;
+        protected List<PProblem> pProblems = new ArrayList<PProblem>();
+        private List<PAnnotation> annotations = new ArrayList<PAnnotation>();
+        private QueryEvaluationHint evaluationHints = new QueryEvaluationHint(null, (IQueryBackendFactory)null);
+        PDisjunction canonicalDisjunction;
+        private List<String> parameterNames = null; // Lazy initialization
+        
+        /** For traceability only. */
+        private List<Object> wrappingQuerySpecifications = new ArrayList<Object>(1);
+
+        @Override
+        public Integer getPositionOfParameter(String parameterName) {
+                ensureInitialized();
+            int index = getParameterNames().indexOf(parameterName);
+            return index != -1 ? index : null;
+        }
+
+        protected void setStatus(PQueryStatus newStatus) {
+            this.status = newStatus;
+        }
+
+        protected void addError(PProblem problem) {
+                status = PQueryStatus.ERROR;
+            pProblems.add(problem);
+        }
+
+        @Override
+        public PQueryStatus getStatus() {
+            return status;
+        }
+
+        @Override
+        public List<PProblem> getPProblems() {
+                return Collections.unmodifiableList(pProblems);
+        }
+
+        @Override
+        public boolean isMutable() {
+            return status.equals(PQueryStatus.UNINITIALIZED) || status.equals(PQueryStatus.INITIALIZING);
+        }
+
+        @Override
+        public void checkMutability() {
+            Preconditions.checkState(isMutable(), "Cannot edit query definition %s", getFullyQualifiedName());
+        }
+
+        /**
+     * @since 1.5
+     */
+        public void setEvaluationHints(QueryEvaluationHint hints) {
+            checkMutability();
+            this.evaluationHints = hints;
+        }
+
+        @Override
+        public QueryEvaluationHint getEvaluationHints() {
+                ensureInitialized();
+                return evaluationHints;
+                // TODO instead of field, compute something from annotations?
+        }
+
+        protected void addAnnotation(PAnnotation annotation) {
+            checkMutability();
+            annotations.add(annotation);
+        }
+
+        @Override
+        public List<PAnnotation> getAllAnnotations() {
+                ensureInitialized();
+            return new ArrayList<>(annotations);
+        }
+
+        private Stream<PAnnotation> getAnnotationStreamByName(final String name) {
+            ensureInitialized();
+        return annotations.stream().filter(Objects::nonNull).filter(annotation -> Objects.equals(name, annotation.getName()));
+        }
+        
+        @Override
+        public List<PAnnotation> getAnnotationsByName(final String annotationName) {
+                return getAnnotationStreamByName(annotationName).collect(Collectors.toList());
+        }
+
+        @Override
+        public Optional<PAnnotation> getFirstAnnotationByName(String annotationName) {
+            return getAnnotationStreamByName(annotationName).findFirst();
+        }
+
+        @Override
+        public List<String> getParameterNames() {
+                ensureInitialized();
+                if (parameterNames == null) {
+                    parameterNames = getParameters().stream().map(PParameter::getName).collect(Collectors.toList()); 
+                }
+            return parameterNames;
+        }
+
+        @Override
+        public Set<PQuery> getDirectReferredQueries() {
+                ensureInitialized();
+            return canonicalDisjunction.getDirectReferredQueries();
+        }
+
+        @Override
+        public Set<PQuery> getAllReferredQueries() {
+            ensureInitialized();
+            return canonicalDisjunction.getAllReferredQueries();
+        }
+
+
+        @Override
+        public List<Object> publishedAs() {
+                return wrappingQuerySpecifications;
+        }
+        
+        @Override
+        public Set<TypeJudgement> getTypeGuarantees() {
+            ensureInitialized();
+                Set<TypeJudgement> result = new HashSet<TypeJudgement>();
+                
+                List<PParameter> parameters = getParameters();
+                for (int i=0; i<parameters.size(); ++i) {
+                        PParameter parameter = parameters.get(i);
+                        IInputKey declaredUnaryType = parameter.getDeclaredUnaryType();
+                        if (declaredUnaryType != null) {
+                                result.add(new TypeJudgement(declaredUnaryType, Tuples.staticArityFlatTupleOf(i)));
+                        }
+                }
+                
+                return result;
+        }
+        
+        /**
+     * @since 2.0
+     */
+        public BasePQuery(PVisibility visibility) {
+                super();
+                this.visibility = visibility;
+        }
+
+        @Override
+        public PDisjunction getDisjunctBodies() {
+                ensureInitialized();
+            Preconditions.checkState(!status.equals(PQueryStatus.ERROR), "Query %s contains errors.", getFullyQualifiedName());
+            return canonicalDisjunction;
+        }
+
+        @Override
+        public final void ensureInitialized() {
+            try {
+            if (status.equals(PQueryStatus.UNINITIALIZED)) {
+                setStatus(PQueryStatus.INITIALIZING);
+                setBodies(doGetContainedBodies());
+                setStatus(PQueryStatus.OK);
+            }
+            } catch (QueryInitializationException e) {
+                addError(new PProblem(e, e.getShortMessage()));
+                throw e;
+            }
+        }
+
+        protected final void setBodies(Set<PBody> bodies) {
+            canonicalDisjunction = new PDisjunction(this, bodies);
+            for (PBody body : canonicalDisjunction.getBodies()) {
+                body.setStatus(null);
+            }
+            setStatus(PQueryStatus.OK);
+        }
+
+        /**
+         * Creates and returns the bodies of the query. If recalled again, a new instance is created.
+         * 
+         * @return
+         * @throws ViatraQueryRuntimeException
+         */
+        protected abstract Set<PBody> doGetContainedBodies();
+
+        @Override
+        public String toString() {
+            return String.format("PQuery<%s>=%s", getFullyQualifiedName(), super.toString());
+        }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public PVisibility getVisibility() {
+        return visibility;
+    }
+        
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PDisjunction.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PDisjunction.java
new file mode 100644
index 00000000..eae4eacf
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PDisjunction.java
@@ -0,0 +1,104 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.Collections;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+
+/**
+ * 
+ * A disjunction is a set of bodies representing separate conditions. A {@link PQuery} has a single, canonical
+ * PDisjunction, that can be replaced using rewriter
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public class PDisjunction {
+
+    private Set<PBody> bodies;
+    private PQuery query;
+
+    public PDisjunction(Set<PBody> bodies) {
+        this(bodies.iterator().next().getPattern(), bodies);
+    }
+
+    public PDisjunction(PQuery query, Set<PBody> bodies) {
+        super();
+        this.query = query;
+        this.bodies = Collections.unmodifiableSet(new LinkedHashSet<>(bodies));
+        this.bodies.forEach(body -> body.setContainerDisjunction(this));
+    }
+
+    /**
+     * Returns an immutable set of bodies that consists of this disjunction
+     * 
+     * @return the bodies
+     */
+    public Set<PBody> getBodies() {
+        return bodies;
+    }
+
+    /**
+     * Returns the corresponding query specification. May be null if not set.
+     */
+    public PQuery getQuery() {
+        return query;
+    }
+
+    /**
+     * Returns all queries directly referred in the constraints. They are all required to evaluate this query
+     * 
+     * @return a non-null, but possibly empty list of query definitions
+     */
+    public Set<PQuery> getDirectReferredQueries() {
+        return this.getBodies().stream().
+                flatMap(PQueries.directlyReferencedQueriesFunction()). // flatten stream of streams
+                collect(Collectors.toCollection(LinkedHashSet::new));
+    }
+
+    /**
+     * Returns all queries required to evaluate this query (transitively).
+     * 
+     * @return a non-null, but possibly empty list of query definitions
+     */
+    public Set<PQuery> getAllReferredQueries() {
+        Set<PQuery> processedQueries = new LinkedHashSet<>();
+        processedQueries.add(this.getQuery());
+        Set<PQuery> foundQueries = getDirectReferredQueries();
+        Set<PQuery> newQueries = new LinkedHashSet<>(foundQueries);
+    
+        while(!processedQueries.containsAll(newQueries)) {
+            PQuery query = newQueries.iterator().next();
+            processedQueries.add(query);
+            newQueries.remove(query);
+            Set<PQuery> referred = query.getDirectReferredQueries();
+            referred.removeAll(processedQueries);
+            foundQueries.addAll(referred);
+            newQueries.addAll(referred);
+        }
+        return foundQueries;
+    }
+    
+    /**
+     * Decides whether a disjunction is mutable. A disjunction is mutable if all its contained bodies are mutable.
+     * 
+     */
+    public boolean isMutable() {
+        for (PBody body : bodies) {
+            if (!body.isMutable()) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameter.java
new file mode 100644
index 00000000..07165aa2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameter.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.Objects;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+
+/**
+ * A descriptor for declared PQuery parameters. A parameter has a name, a declared type and a direction constraint
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class PParameter {
+
+    private final String name;
+    private final String typeName;
+    private final IInputKey declaredUnaryType;
+    private final PParameterDirection direction;
+
+    public PParameter(String name) {
+        this(name, (String) null);
+    }
+
+    public PParameter(String name, String typeName) {
+        this(name, typeName, (IInputKey) null);
+    }
+
+    public PParameter(String name, String typeName, IInputKey declaredUnaryType) {
+        this(name, typeName, declaredUnaryType, PParameterDirection.INOUT);
+    }
+
+    /**
+     * @since 1.4
+     */
+    public PParameter(String name, String typeName, IInputKey declaredUnaryType, PParameterDirection direction) {
+        super();
+        this.name = name;
+        this.typeName = typeName;
+        this.declaredUnaryType = declaredUnaryType;
+        this.direction = direction;
+
+        if (declaredUnaryType != null && declaredUnaryType.getArity() != 1) {
+            throw new IllegalArgumentException(
+                    "PParameter declared type must be unary instead of " + declaredUnaryType.getPrettyPrintableName());
+        }
+    }
+
+    /**
+     * @return the direction
+     * @since 1.4
+     */
+    public PParameterDirection getDirection() {
+        return direction;
+    }
+
+    /**
+     * @return the name of the parameter
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Returns a textual representation of the declared type of the parameter
+     * 
+     * @return the type description, or null if not available
+     */
+    public String getTypeName() {
+        return typeName;
+    }
+
+    /**
+     * Yield an {@link IInputKey} representation of the type declared for this parameter.
+     * 
+     * @return the unary type that was declared on this parameter in the query header, or null if not available
+     */
+    public IInputKey getDeclaredUnaryType() {
+        return declaredUnaryType;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof PParameter) {
+            return Objects.equals(name, ((PParameter) obj).name)
+                    && Objects.equals(typeName, ((PParameter) obj).typeName)
+                    && Objects.equals(declaredUnaryType, ((PParameter) obj).declaredUnaryType)
+                    && Objects.equals(direction, ((PParameter) obj).direction);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, typeName, declaredUnaryType);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameterDirection.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameterDirection.java
new file mode 100644
index 00000000..c94d4797
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameterDirection.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+/**
+ * Values of this enum describe a constraint to the calling of patterns regarding its parameters.
+ * 
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public enum PParameterDirection {
+
+    /**
+     * Default value, no additional constraint is applied
+     */
+    INOUT,
+    
+    /**
+     * The parameters marked with this constraints shall be set to a value before calling the pattern
+     */
+    IN,
+    
+    /**
+     * The parameters marked with this constraints shall not be set to a value before calling the pattern
+     */
+    OUT
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PProblem.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PProblem.java
new file mode 100644
index 00000000..1fe4f541
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PProblem.java
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+
+/**
+ * Represents an error that was detected while the {@link PQuery} object was built from a source.
+ * @author Bergmann Gabor
+ *
+ */
+public class PProblem {
+
+    private final String shortMessage;
+    private final String location; 
+    private final Exception exception;
+
+    public PProblem(String shortMessage) {
+        this(null, shortMessage, null, null);
+    }
+    /**
+     * @since 2.0
+     */
+    public PProblem(String shortMessage, Integer line, Integer column) {
+        this(null, shortMessage, line, column);
+    }
+    public PProblem(QueryProcessingException exception) {
+        this(exception, exception.getShortMessage(), null, null);
+    }
+    public PProblem(Exception exception, String shortMessage) {
+        this(exception, shortMessage, null, null);
+    }
+    
+    /**
+     * @since 2.0
+     */
+    public PProblem(Exception exception, String shortMessage, Integer line, Integer column) {
+        this.shortMessage = shortMessage;
+        this.exception = exception;
+        if (line == null) {
+            location = "Unspecified location";
+        } else if (column == null) {
+            location = String.format("Line %d", line);
+        } else {
+            location = String.format("Line %d Column %d", line, column);
+        }
+    }
+
+    public String getShortMessage() {
+        return shortMessage;
+    }
+    public Exception getException() {
+        return exception;
+    }
+    /**
+     * @since 2.0
+     */
+    public String getLocation() {
+        return location;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueries.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueries.java
new file mode 100644
index 00000000..56f8ca76
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueries.java
@@ -0,0 +1,110 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.psystem.IMultiQueryReference;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+
+/**
+ * Utility class for using PQueries in functional/streaming collection operations effectively
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public final class PQueries {
+
+    /**
+     * Hidden constructor for utility class
+     */
+    private PQueries() {
+    }
+
+    /**
+     * Predicate checking for the status of selected queries
+     *
+     */
+    public static Predicate<PQuery> queryStatusPredicate(final PQueryStatus status) {
+        return query -> query.getStatus().equals(status);
+    }
+
+    /**
+     * Enumerates referred queries (without duplicates) for the given body
+     */
+    public static Function<PBody, Stream<PQuery>> directlyReferencedQueriesFunction() {
+        return body -> (body.getConstraintsOfType(IMultiQueryReference.class).stream()
+                .flatMap(e -> e.getReferredQueries().stream()).distinct());
+    }
+
+    /**
+     * Enumerates directly referred extensional relations (without duplicates) in the canonical form of the given query
+     * 
+     * @param enumerablesOnly
+     *                            only enumerable type constraints are considered
+     * @since 2.0
+     */
+    public static Stream<IInputKey> directlyRequiredTypesOfQuery(PQuery query, boolean enumerablesOnly) {
+        return directlyRequiredTypesOfDisjunction(query.getDisjunctBodies(), enumerablesOnly);
+    }
+
+    /**
+     * Enumerates directly referred extensional relations (without duplicates) for the given formulation of a query.
+     * 
+     * @param enumerablesOnly
+     *                            only enumerable type constraints are considered
+     * @since 2.0
+     */
+    public static Stream<IInputKey> directlyRequiredTypesOfDisjunction(PDisjunction disjunctBodies,
+            boolean enumerablesOnly) {
+        Class<? extends ITypeConstraint> filterClass = enumerablesOnly ? TypeConstraint.class : ITypeConstraint.class;
+        return disjunctBodies.getBodies().stream().flatMap(body -> body.getConstraintsOfType(filterClass).stream())
+                .map(constraint -> constraint.getEquivalentJudgement().getInputKey()).distinct();
+    }
+
+    /**
+     * @since 1.4
+     */
+    public static Predicate<PParameter> parameterDirectionPredicate(final PParameterDirection direction) {
+        return input -> input.getDirection() == direction;
+    }
+
+    /**
+     * Returns all {@link PTraceable}s contained in the given {@link PQuery}: itself, its bodies and their constraints.
+     * 
+     * @since 1.6
+     */
+    public static Set<PTraceable> getTraceables(PQuery query) {
+        final Set<PTraceable> traceables = new HashSet<>();
+        traceables.add(query);
+        query.getDisjunctBodies().getBodies().forEach(body -> {
+            traceables.add(body);
+            body.getConstraints().forEach(traceables::add);
+        });
+        return traceables;
+    }
+
+    /**
+     * Calculates the simple name related from a given qualified name by finding the part after the last '.' character.
+     * 
+     * @since 2.0
+     */
+    public static String calculateSimpleName(String qualifiedName) {
+        return qualifiedName.substring(qualifiedName.lastIndexOf('.') + 1);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQuery.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQuery.java
new file mode 100644
index 00000000..a909c650
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQuery.java
@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.List;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackend;
+import tools.refinery.viatra.runtime.matchers.backend.IQueryBackendHintProvider;
+import tools.refinery.viatra.runtime.matchers.backend.QueryEvaluationHint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+
+/**
+ * Internal representation of a query / graph pattern (using a constraint system formalism), 
+ * to be interpreted by a query evaluator ({@link IQueryBackend}). 
+ * End-users of VIATRA Query should access a query as an IQuerySpecification instead. 
+ * 
+ * <p>
+ * PQuerys are definitions of queries usable inside pattern descriptions. Such description always has (a non-null) name. The query
+ * itself is defined as a (non-empty) set of {@link PBody} instances, the result is the disjunction of the single
+ * {@link PBody} instances. </p>
+ * <p>
+ * A PQuery might be constructed from erroneous patterns or might be uninitialized - this is represented by its status.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 0.8.0
+ * @noimplement This interface is not intended to be implemented by clients. Use {@link BasePQuery} as a base class instead.
+ */
+public interface PQuery extends PQueryHeader, PTraceable {
+
+    // TODO rewritten as / rewritten from traceability to PDisjunction?
+    
+    /**
+     * @author Zoltan Ujhelyi
+     * 
+     */
+    public enum PQueryStatus {
+        /**
+         * Marks that the query definition is not initialized
+         */
+        UNINITIALIZED,
+        /**
+         * Marks that the query definition is being initialized
+         * @since 1.4
+         */
+        INITIALIZING,
+        /**
+         * The query definition was successfully initialized
+         */
+        OK,
+        /**
+         * The query definition was initialized, but some issues were present
+         */
+        WARNING,
+        /**
+         * The query definition was not successfully initialized because of an error
+         */
+        ERROR
+    }
+
+    /**
+     * Returns all bodies associated with the query in their canonical form. If called multiple times, the same set with
+     * the same contents will be returned.
+     * 
+     */
+    PDisjunction getDisjunctBodies();
+
+    /**
+     * Returns all queries directly referred in the constraints. They are all required to evaluate this query
+     * 
+     * @return a non-null, but possibly empty list of query definitions
+     */
+    Set<PQuery> getDirectReferredQueries();
+
+    /**
+     * Returns all queries required to evaluate this query (transitively).
+     * 
+     * @return a non-null, but possibly empty list of query definitions
+     */
+    Set<PQuery> getAllReferredQueries();
+
+    /**
+     * Returns the initialization status of the definition
+     * 
+     */
+    PQueryStatus getStatus();
+    
+    /**
+     * Returns a list describing the problems that were found in this query.
+     * 
+     * <p> TODO: formulate invariant connecting {@link #getPProblems()} and {@link #getStatus()}.
+     * 
+     * @return a non-null, but possibly empty list of problems
+     */
+    List<PProblem> getPProblems();
+
+    /**
+     * Before a modification operation is executed, a mutability check is performed (via the {@link #getStatus()}
+     * implementation, and in case of problems an {@link IllegalStateException} is thrown.
+     */
+    void checkMutability();
+
+    /**
+     * An option to check mutability of the query. It can be used to avoid getting an {@link IllegalStateException} by
+     * the execution of {@link #checkMutability()}.
+     * 
+     * @return true if the query specification is still editable
+     */
+    boolean isMutable();
+
+    /**
+     * Optional hints regarding the query evaluation strategy, to be interpreted by the query engine.
+     * <p> To ensure the possibility of external overrides, 
+     *  the evaluation engine should not directly consult this field, 
+     *  but use an {@link IQueryBackendHintProvider} instead.
+     */
+    public QueryEvaluationHint getEvaluationHints();
+
+    
+    /**
+     * Type information, expressed on query parameters, that all matches of the query are guaranteed to respect. 
+     * <p> At the very minimum, this should include the declared types of the parameters.
+     * <p> The type judgement tuples shall contain the <i>parameter index</i>, NOT the {@link PParameter} object.
+     * 
+     * @return a non-null set of type judgements that the query guarantees for its matches
+     */
+    public Set<TypeJudgement> getTypeGuarantees();
+
+    /**
+     * If the query definition is uninitialized, initializes it.
+     * @throws ViatraQueryRuntimeException if initialization of query specification fails
+     */
+    public abstract void ensureInitialized();
+    
+    /**
+     * Returns the end-user query specification API objects that wrap this query.
+     * 
+     * <p> Intended for traceability and debug purposes, not part of normal operation. 
+     * Returned list is intended to be appended during query specification construction time.
+     * 
+     * @return a non-null, but possibly empty list of query specification objects;
+     */
+    List<Object> publishedAs();
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueryHeader.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueryHeader.java
new file mode 100644
index 00000000..f3671934
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueryHeader.java
@@ -0,0 +1,101 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import java.util.List;
+import java.util.Optional;
+
+import tools.refinery.viatra.runtime.matchers.psystem.annotations.PAnnotation;
+
+/**
+ * Represents header information (metainfo) about a query. 
+ * <p> To be implemented both by IQuerySpecifications intended for end users, 
+ * and the internal query representation {@link PQuery}.
+ * 
+ * 
+ * @author Bergmann Gabor
+ * @since 0.9
+ */
+public interface PQueryHeader {
+
+    /**
+     * Identifies the pattern for which matchers can be instantiated.
+     */
+    public String getFullyQualifiedName();
+
+    /**
+     * Return the list of parameter names
+     * 
+     * @return a non-null, but possibly empty list of parameter names
+     */
+    public List<String> getParameterNames();
+
+    /**
+     * Returns a list of parameter descriptions
+     * 
+     * @return a non-null, but possibly empty list of parameter descriptions
+     */
+    public List<PParameter> getParameters();
+
+    /**
+     * Returns the index of a named parameter
+     * 
+     * @param parameterName
+     * @return the index, or null of no such parameter is available
+     */
+    public Integer getPositionOfParameter(String parameterName);
+
+    /**
+     * Returns a parameter by name if exists
+     * @since 2.1
+     */
+    default Optional<PParameter> getParameter(String parameterName) {
+        return Optional.ofNullable(getPositionOfParameter(parameterName))
+            .map(getParameters()::get);
+    }
+    
+    /**
+     * Returns the list of annotations specified for this query
+     * 
+     * @return a non-null, but possibly empty list of annotations
+     */
+    public List<PAnnotation> getAllAnnotations();
+
+    /**
+     * Returns the list of annotations with a specified name
+     * 
+     * @param annotationName
+     * @return a non-null, but possibly empty list of annotations
+     */
+    public List<PAnnotation> getAnnotationsByName(String annotationName);
+
+    /**
+     * Returns the first annotation with a specified name
+     * 
+     * @since 2.0
+     */
+    public Optional<PAnnotation> getFirstAnnotationByName(String annotationName);
+    
+    /**
+     * Returns the visibility information about the query.
+     * @since 2.0
+     */
+    public PVisibility getVisibility();
+    
+    /**
+     * Returns the non-qualified name of the query. By default this means returning the qualified name after the last
+     * '.' character.
+     * 
+     * @since 2.0
+     */
+    public default String getSimpleName() {
+        return PQueries.calculateSimpleName(getFullyQualifiedName());
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PVisibility.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PVisibility.java
new file mode 100644
index 00000000..7cb312bd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PVisibility.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ *
+ */
+public enum PVisibility {
+
+    /**
+     * A public (default) visibility means a pattern can be called at any time.
+     */
+    PUBLIC,
+    /**
+     * A private query is not expected to be called directly, only by a different query matcher. 
+     */
+    PRIVATE,
+    /**
+     * A query that is only used inside a single caller query and is not visible outside its container query. Such
+     * patterns must also fulfill the following additional constraints:
+     * 
+     * <ul>
+     * <li>An embedded query must have only a single body.</li>
+     * <li>An embedded query must not be recursice.</li>
+     * </ul>
+     */
+    EMBEDDED
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/QueryInitializationException.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/QueryInitializationException.java
new file mode 100644
index 00000000..470d7287
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/QueryInitializationException.java
@@ -0,0 +1,35 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Bergmann Gabor, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.queries;
+
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+
+/**
+ * Represent an exception that occurred while initializing the specification of a query. 
+ * @author Bergmann Gabor
+ * @since 0.9
+ *
+ */
+public class QueryInitializationException extends QueryProcessingException {
+
+    public QueryInitializationException(String message, String[] context, String shortMessage, Object patternDescription,
+            Throwable cause) {
+        super(message, context, shortMessage, patternDescription, cause);
+    }
+
+    public QueryInitializationException(String message, String[] context, String shortMessage, Object patternDescription) {
+        super(message, context, shortMessage, patternDescription);
+    }
+
+    private static final long serialVersionUID = 9106033062252951489L;
+
+
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/AbstractRewriterTraceSource.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/AbstractRewriterTraceSource.java
new file mode 100644
index 00000000..276b2b42
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/AbstractRewriterTraceSource.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.Objects;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+
+/**
+ * @since 1.6
+ *
+ */
+public class AbstractRewriterTraceSource {
+
+    private IRewriterTraceCollector traceCollector = NopTraceCollector.INSTANCE;
+    
+    public void setTraceCollector(IRewriterTraceCollector traceCollector) {
+        this.traceCollector = Objects.requireNonNull(traceCollector);
+    }
+    
+    public IPTraceableTraceProvider getTraces() {
+        return traceCollector;
+    }
+    
+    protected IRewriterTraceCollector getTraceCollector() {
+        return traceCollector;
+    }
+    
+    /**
+     * Mark the given derivative to be originated from the given original constraint.
+     * @since 1.6
+     */
+    protected void addTrace(PTraceable original, PTraceable derivative){
+        traceCollector.addTrace(original, derivative);
+    }
+    
+    /**
+     * Indicate that the given derivative is removed from the resulting query, thus its trace
+     * information should be removed also.
+     * @since 1.6
+     */
+    protected void derivativeRemoved(PConstraint derivative, IDerivativeModificationReason reason){
+        traceCollector.derivativeRemoved(derivative, reason);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/ConstraintRemovalReason.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/ConstraintRemovalReason.java
new file mode 100644
index 00000000..237a762d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/ConstraintRemovalReason.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+/**
+ * Common reasons for removing constraint through rewriters
+ *
+ * @noreference This enum is not intended to be referenced by clients.
+ */
+public enum ConstraintRemovalReason implements IDerivativeModificationReason {
+
+    MOOT_EQUALITY,
+    WEAK_INEQUALITY_SELF_LOOP,
+    TYPE_SUBSUMED,
+    DUPLICATE
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/DefaultFlattenCallPredicate.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/DefaultFlattenCallPredicate.java
new file mode 100644
index 00000000..3b5d7390
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/DefaultFlattenCallPredicate.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+
+/**
+ * @author Marton Bur
+ *
+ */
+public class DefaultFlattenCallPredicate implements IFlattenCallPredicate {
+
+    @Override
+    public boolean shouldFlatten(PositivePatternCall positivePatternCall) {
+        return true;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/FlattenerCopier.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/FlattenerCopier.java
new file mode 100644
index 00000000..06b8d372
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/FlattenerCopier.java
@@ -0,0 +1,129 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.Equality;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * This rewriter class can add new equality constraints to the copied body
+ * 
+ * @author Marton Bur
+ *
+ */
+class FlattenerCopier extends PBodyCopier {
+
+    private final Map<PositivePatternCall, CallInformation> calls;
+
+    private static class CallInformation {
+        final PBody body;
+        final Map<PVariable, PVariable> variableMapping;
+        
+        private CallInformation(PBody body) {
+            this.body = body;
+            this.variableMapping = new HashMap<>();
+        }
+    }
+    
+    public FlattenerCopier(PQuery query, Map<PositivePatternCall, PBody> callsToFlatten) {
+        super(query);
+        this.calls = callsToFlatten.entrySet().stream().collect(Collectors.toMap(Entry::getKey, entry -> new CallInformation(entry.getValue())));
+    }
+    
+    protected void copyVariable(PositivePatternCall contextPatternCall, PVariable variable, String newName) {
+        PVariable newPVariable = body.getOrCreateVariableByName(newName);
+        calls.get(contextPatternCall).variableMapping.put(variable, newPVariable);
+        variableMapping.put(variable, newPVariable);
+    }
+
+    /**
+     * Merge all variables and constraints from the body called through the given pattern call to a target body. If
+     * multiple bodies are merged into a single one, use the renamer and filter options to avoid collisions.
+     * 
+     * @param sourceBody
+     * @param namingTool
+     * @param filter
+     */
+    public void mergeBody(PositivePatternCall contextPatternCall, IVariableRenamer namingTool,
+            IConstraintFilter filter) {
+
+        PBody sourceBody = calls.get(contextPatternCall).body;
+
+        // Copy variables
+        Set<PVariable> allVariables = sourceBody.getAllVariables();
+        for (PVariable pVariable : allVariables) {
+            if (pVariable.isUnique()) {
+                copyVariable(contextPatternCall, pVariable,
+                        namingTool.createVariableName(pVariable, sourceBody.getPattern()));
+            }
+        }
+
+        // Copy constraints which are not filtered
+        Set<PConstraint> constraints = sourceBody.getConstraints();
+        for (PConstraint pConstraint : constraints) {
+            if (!(pConstraint instanceof ExportedParameter) && !filter.filter(pConstraint)) {
+                copyConstraint(pConstraint);
+            }
+        }
+    }
+
+    @Override
+    protected void copyPositivePatternCallConstraint(PositivePatternCall positivePatternCall) {
+
+        if (!calls.containsKey(positivePatternCall)) {
+            // If the call was not flattened, copy the constraint
+            super.copyPositivePatternCallConstraint(positivePatternCall);
+        } else {
+            PBody calledBody = Objects.requireNonNull(calls.get(positivePatternCall).body);
+            Preconditions.checkArgument(positivePatternCall.getReferredQuery().equals(calledBody.getPattern()));
+
+            List<PVariable> symbolicParameters = calledBody.getSymbolicParameterVariables();
+            Object[] elements = positivePatternCall.getVariablesTuple().getElements();
+            for (int i = 0; i < elements.length; i++) {
+                // Create equality constraints between the caller PositivePatternCall and the corresponding body
+                // parameter variables
+                createEqualityConstraint((PVariable) elements[i], symbolicParameters.get(i), positivePatternCall);
+            }
+
+        }
+    }
+
+    private void createEqualityConstraint(PVariable pVariable1, PVariable pVariable2,
+            PositivePatternCall contextPatternCall) {
+        PVariable who = variableMapping.get(pVariable1);
+        PVariable withWhom = calls.get(contextPatternCall).variableMapping.get(pVariable2);
+        addTrace(contextPatternCall, new Equality(body, who, withWhom));
+    }
+
+    @Override
+    protected void copyExpressionEvaluationConstraint(final ExpressionEvaluation expressionEvaluation) {
+        Map<PVariable, PVariable> variableMapping = this.variableMapping.entrySet().stream()
+                .filter(input -> expressionEvaluation.getPSystem().getAllVariables().contains(input.getKey()))
+                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));
+        
+        PVariable mappedOutputVariable = variableMapping.get(expressionEvaluation.getOutputVariable());
+        addTrace(expressionEvaluation, new ExpressionEvaluation(body, new VariableMappingExpressionEvaluatorWrapper(expressionEvaluation.getEvaluator(), variableMapping), mappedOutputVariable, expressionEvaluation.isUnwinding()));
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IConstraintFilter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IConstraintFilter.java
new file mode 100644
index 00000000..518b9c64
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IConstraintFilter.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Marton Bur, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+
+/**
+ * Helper interface to exclude constraints from PBody copy processes
+ * 
+ * @author Marton Bur
+ * 
+ */
+public interface IConstraintFilter {
+    /**
+     * Returns true, if the given constraint should be filtered (thus should not be copied)
+     * 
+     * @param constraint
+     *            to check
+     * @return true, if the constraint should be filtered
+     */
+    boolean filter(PConstraint constraint);
+    
+    public static class ExportedParameterFilter implements IConstraintFilter {
+        
+        @Override
+        public boolean filter(PConstraint constraint) {
+            return constraint instanceof ExportedParameter;
+        }
+        
+    }
+    
+    public static class AllowAllFilter implements IConstraintFilter {
+        
+        @Override
+        public boolean filter(PConstraint constraint) {
+            // Nothing is filtered
+            return false;
+        }
+        
+    }
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IDerivativeModificationReason.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IDerivativeModificationReason.java
new file mode 100644
index 00000000..dbd6a78d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IDerivativeModificationReason.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+/**
+ * This is a role indication interface, implementations may provide a reason about
+ * why a modification is made during PQuery normalization.
+ * @since 1.6
+ *
+ */
+public interface IDerivativeModificationReason {
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IFlattenCallPredicate.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IFlattenCallPredicate.java
new file mode 100644
index 00000000..7e224e98
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IFlattenCallPredicate.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Marton Bur, Zoltan Ujhelyi, Akos Horvath, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+
+
+/**
+ * Interface used by the PQueryFlattener to decide which positive pattern calls to flatten
+ * 
+ * @author Marton Bur
+ *
+ */
+public interface IFlattenCallPredicate {
+    
+    /**
+     * Decides whether the called query by the pattern call should be flattened into the caller or not.
+     * 
+     * @param positivePatternCall
+     *            the pattern call
+     * @return true if the call should be flattened
+     */
+    boolean shouldFlatten(PositivePatternCall positivePatternCall);
+    
+    /**
+     * Flattens only if all operand predicates vote for flattening.
+     * @author Gabor Bergmann
+     * @since 2.1
+     */
+    public static class And implements IFlattenCallPredicate {
+        private IFlattenCallPredicate[] operands;
+        public And(IFlattenCallPredicate... operands) {
+            this.operands = operands;
+        }
+        
+        @Override
+        public boolean shouldFlatten(PositivePatternCall positivePatternCall) {
+            for (IFlattenCallPredicate operand : operands) {
+                if (!operand.shouldFlatten(positivePatternCall)) return false;
+            }
+            return true;
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IPTraceableTraceProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IPTraceableTraceProvider.java
new file mode 100644
index 00000000..84da4d1b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IPTraceableTraceProvider.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * This interface provides methods to trace the {@link PTraceable}s of a transformed {@link PQuery} produced by
+ * a {@link PDisjunctionRewriter}. In case the associated rewriter is a composite (a.k.a. {@link PDisjunctionRewriterCacher}),
+ * this trace provider handles traces end-to-end, hiding all the intermediate transformation steps.
+ * 
+ * @since 1.6
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IPTraceableTraceProvider {
+
+    /**
+     * Find and return the canonical {@link PTraceable}s in the original query which are the sources of the given derivative
+     * {@link PTraceable} according to the transformation.
+     * 
+     * @param derivative a {@link PTraceable} which is contained by the {@link PQuery} produced by the associated rewriter
+     * @since 2.0
+     */
+    public Stream<PTraceable> getCanonicalTraceables(PTraceable derivative);
+    
+    /**
+     * Find and return the {@link PTraceable}s in the rewritten query which are the destinations of the given source
+     * {@link PTraceable} according to the transformation.
+     * 
+     * @param source a {@link PTraceable} which is contained by a {@link PQuery} before rewriting
+     * @since 2.0
+     */
+    public Stream<PTraceable> getRewrittenTraceables(PTraceable source);
+    
+    /**
+     * Returns whether the given traceable element has been removed by every rewriter for a reason.
+     */
+    public boolean isRemoved(PTraceable traceable);
+
+    /**
+     * Returns the reasons for which the traceable element has been removed by the rewriters.
+     * @return the reasons of removal during rewriting
+     * @since 2.0
+     */
+    public Stream<IDerivativeModificationReason> getRemovalReasons(PTraceable traceable);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IRewriterTraceCollector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IRewriterTraceCollector.java
new file mode 100644
index 00000000..70771ea7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IRewriterTraceCollector.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+
+/**
+ * This is the internal API of {@link IPTraceableTraceProvider} expected to be used by
+ * copier and rewriter implementations.
+ * 
+ * @since 1.6
+ * @noreference This interface is not intended to be referenced by clients.
+ */
+public interface IRewriterTraceCollector extends IPTraceableTraceProvider {
+
+    /**
+     * Mark the given derivative to be originated from the given original constraint.
+     */
+    public void addTrace(PTraceable origin, PTraceable derivative);
+    
+    /**
+     * Indicate that the given derivative is removed from the resulting query, thus its trace
+     * information should be removed also.
+     */
+    public void derivativeRemoved(PTraceable derivative, IDerivativeModificationReason reason);
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IVariableRenamer.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IVariableRenamer.java
new file mode 100644
index 00000000..ce446e0d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IVariableRenamer.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Marton Bur, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * Helper interface to ease the naming of the new variables during flattening
+ * 
+ * @author Marton Bur
+ * 
+ */
+public interface IVariableRenamer {
+    /**
+     * Creates a variable name based on a given variable and a given query. It only creates a String, doesn't set
+     * anything.
+     * 
+     * @param pVariable
+     * @param query
+     * @return the new variable name as a String
+     */
+    String createVariableName(PVariable pVariable, PQuery query);
+    
+    public class SameName implements IVariableRenamer {
+        @Override
+        public String createVariableName(PVariable pVariable, PQuery query) {
+            return pVariable.getName();
+        }
+    }
+    
+    public class HierarchicalName implements IVariableRenamer {
+
+        private int callCount;
+
+        public void setCallCount(int callCount) {
+            this.callCount = callCount;
+        }
+
+        @Override
+        public String createVariableName(PVariable pVariable, PQuery query) {
+            // make sure to keep the "_" prefix before anonymous variables
+            String newVarName = getShortName(query) + "<" + callCount + ">" + "_" + pVariable.getName();
+            return pVariable.getName().startsWith("_") ? "_" + newVarName : newVarName ;
+        }
+        
+        private String getShortName(PQuery query) {
+            String fullyQualifiedName = query.getFullyQualifiedName();
+            int beginIndex = fullyQualifiedName.lastIndexOf('.') + 1;
+            return fullyQualifiedName.substring(beginIndex);
+        }
+    }
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/MappingTraceCollector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/MappingTraceCollector.java
new file mode 100644
index 00000000..7429fc60
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/MappingTraceCollector.java
@@ -0,0 +1,135 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+import java.util.function.Predicate;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * Multimap-based implementation to contain and query traces
+ * 
+ * @since 1.6
+ *
+ */
+public class MappingTraceCollector implements IRewriterTraceCollector {
+
+    /**
+     * Traces from derivative to original
+     */
+    private final IMultiLookup<PTraceable, PTraceable> traces = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+
+    /**
+     * Traces from original to derivative
+     */
+    private final IMultiLookup<PTraceable, PTraceable> inverseTraces = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    
+    /**
+     * Reasons for removing {@link PTraceable}s
+     */
+    private final Map<PTraceable, IDerivativeModificationReason> removals = new HashMap<>();
+    
+    /**
+     * Decides whether {@link PTraceable} is removed
+     */
+    private final Predicate<PTraceable> removed = removals::containsKey;
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<PTraceable> getCanonicalTraceables(PTraceable derivative) {
+        return findTraceEnds(derivative, traces).stream();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<PTraceable> getRewrittenTraceables(PTraceable source) {
+        return findTraceEnds(source, inverseTraces).stream();
+    }
+
+    /**
+     * Returns the end of trace chains starting from the given {@link PTraceable} along the given trace edges. 
+     */
+    private Set<PTraceable> findTraceEnds(PTraceable traceable, IMultiLookup<PTraceable, PTraceable> traceRecords) {
+        if (traceable instanceof PQuery) { // PQueries are preserved
+            return Collections.singleton(traceable);
+        }
+        Set<PTraceable> visited = new HashSet<>();
+        Set<PTraceable> result = new HashSet<>();
+        Queue<PTraceable> queue = new LinkedList<>();
+        queue.add(traceable);
+        while(!queue.isEmpty()){
+            PTraceable aDerivative = queue.poll();
+            // Track visited elements to avoid infinite loop via directed cycles in traces
+            visited.add(aDerivative);
+            IMemoryView<PTraceable> nextOrigins = traceRecords.lookup(aDerivative);
+            if (nextOrigins == null){
+                // End of trace chain
+                result.add(aDerivative);
+            } else {
+                // Follow traces
+                for(PTraceable nextOrigin : nextOrigins){
+                    if (!visited.contains(nextOrigin)){
+                        queue.add(nextOrigin);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public void addTrace(PTraceable original, PTraceable derivative){
+        traces.addPairOrNop(derivative, original);
+        inverseTraces.addPairOrNop(original, derivative);
+        // Even if this element was marked as removed earlier, now we replace it with another constraint!
+        removals.remove(original);
+    }
+    
+    @Override
+    public void derivativeRemoved(PTraceable derivative, IDerivativeModificationReason reason){
+        Preconditions.checkState(!removals.containsKey(derivative), "Traceable %s removed multiple times", derivative);
+        // XXX the derivative must not be removed from the trace chain, as some rewriters, e.g. the normalizer keeps trace links to deleted elements 
+        if (!inverseTraces.lookupExists(derivative)) {
+            // If there already exists a trace link, this removal means an update
+            removals.put(derivative, reason);
+        }
+    }
+
+    @Override
+    public boolean isRemoved(PTraceable traceable) {
+        return getRewrittenTraceables(traceable).allMatch(removed);
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<IDerivativeModificationReason> getRemovalReasons(PTraceable traceable) {
+        return getRewrittenTraceables(traceable).filter(removed).map(removals::get);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NeverFlattenCallPredicate.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NeverFlattenCallPredicate.java
new file mode 100644
index 00000000..96c0b205
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NeverFlattenCallPredicate.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+
+/**
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public class NeverFlattenCallPredicate implements IFlattenCallPredicate {
+
+
+    @Override
+    public boolean shouldFlatten(PositivePatternCall positivePatternCall) {
+        return false;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NopTraceCollector.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NopTraceCollector.java
new file mode 100644
index 00000000..15cf577e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NopTraceCollector.java
@@ -0,0 +1,68 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Grill Balázs, IncQueryLabs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PTraceable;
+
+/**
+ * This implementation does not store any traces and scales to NOP for every traceability feature.
+ * @since 1.6
+ *
+ */
+public class NopTraceCollector implements IRewriterTraceCollector {
+
+    public static final IRewriterTraceCollector INSTANCE = new NopTraceCollector();
+    
+    private NopTraceCollector() {
+        // Private constructor to force using the common instance
+    }
+    
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<PTraceable> getCanonicalTraceables(PTraceable derivative) {
+        return Stream.empty();
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<PTraceable> getRewrittenTraceables(PTraceable source) {
+        return Stream.empty();
+    }
+
+
+    @Override
+    public void addTrace(PTraceable origin, PTraceable derivative) {
+        // ignored
+    }
+
+    @Override
+    public void derivativeRemoved(PTraceable derivative, IDerivativeModificationReason reason) {
+        // ignored
+    }
+
+    @Override
+    public boolean isRemoved(PTraceable traceable) {
+        return false;
+    }
+
+    /**
+     * @since 2.0
+     */
+    @Override
+    public Stream<IDerivativeModificationReason> getRemovalReasons(PTraceable traceable) {
+        return Stream.empty();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyCopier.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyCopier.java
new file mode 100644
index 00000000..e66c4eea
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyCopier.java
@@ -0,0 +1,306 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.psystem.EnumerablePConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.*;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.*;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PParameter;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IConstraintFilter.AllowAllFilter;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IVariableRenamer.SameName;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * This class can create a new PBody for a PQuery. The result body contains a copy of given variables and constraints.
+ *
+ * @author Marton Bur
+ *
+ */
+public class PBodyCopier extends AbstractRewriterTraceSource {
+
+    /**
+     * The created body
+     */
+    protected PBody body;
+    /**
+     * Mapping between the original and the copied variables
+     */
+    protected Map<PVariable, PVariable> variableMapping = new HashMap<>();
+
+    public Map<PVariable, PVariable> getVariableMapping() {
+        return variableMapping;
+    }
+
+    /**
+     * @since 1.6
+     */
+    public PBodyCopier(PBody body, IRewriterTraceCollector traceCollector) {
+        this.body = new PBody(body.getPattern());
+        setTraceCollector(traceCollector);
+
+        // do the actual copying
+        mergeBody(body);
+    }
+
+    /**
+     * @since 1.6
+     */
+    public PBodyCopier(PQuery query) {
+        this.body = new PBody(query);
+    }
+
+    public void mergeBody(PBody sourceBody) {
+        mergeBody(sourceBody, new SameName(), new AllowAllFilter());
+    }
+
+    /**
+     * Merge all variables and constraints from a source body to a target body. If multiple bodies are merged into a
+     * single one, use the renamer and filter options to avoid collisions.
+     */
+    public void mergeBody(PBody sourceBody, IVariableRenamer namingTool, IConstraintFilter filter) {
+
+        // Copy variables
+        Set<PVariable> allVariables = sourceBody.getAllVariables();
+        for (PVariable pVariable : allVariables) {
+            if (pVariable.isUnique()) {
+                copyVariable(pVariable, namingTool.createVariableName(pVariable, sourceBody.getPattern()));
+            }
+        }
+
+        // Copy exported parameters
+        this.body.setSymbolicParameters(sourceBody.getSymbolicParameters().stream()
+                .map(this::copyExportedParameterConstraint).collect(Collectors.toList()));
+
+        // Copy constraints which are not filtered
+        Set<PConstraint> constraints = sourceBody.getConstraints();
+        for (PConstraint pConstraint : constraints) {
+            if (!(pConstraint instanceof ExportedParameter) && !filter.filter(pConstraint)) {
+                copyConstraint(pConstraint);
+            }
+        }
+
+        // Add trace between original and copied body
+        addTrace(sourceBody, body);
+    }
+
+    protected void copyVariable(PVariable variable, String newName) {
+        PVariable newPVariable = body.getOrCreateVariableByName(newName);
+        variableMapping.put(variable, newPVariable);
+    }
+
+    /**
+     * Returns the body with the copied variables and constraints. The returned body is still uninitialized.
+     */
+    public PBody getCopiedBody() {
+        return body;
+    }
+
+    protected void copyConstraint(PConstraint constraint) {
+        if (constraint instanceof ExportedParameter) {
+            copyExportedParameterConstraint((ExportedParameter) constraint);
+        } else if (constraint instanceof Equality) {
+            copyEqualityConstraint((Equality) constraint);
+        } else if (constraint instanceof Inequality) {
+            copyInequalityConstraint((Inequality) constraint);
+        } else if (constraint instanceof TypeConstraint) {
+            copyTypeConstraint((TypeConstraint) constraint);
+        } else if (constraint instanceof TypeFilterConstraint) {
+            copyTypeFilterConstraint((TypeFilterConstraint) constraint);
+        } else if (constraint instanceof ConstantValue) {
+            copyConstantValueConstraint((ConstantValue) constraint);
+        } else if (constraint instanceof PositivePatternCall) {
+            copyPositivePatternCallConstraint((PositivePatternCall) constraint);
+        } else if (constraint instanceof NegativePatternCall) {
+            copyNegativePatternCallConstraint((NegativePatternCall) constraint);
+        } else if (constraint instanceof BinaryTransitiveClosure) {
+            copyBinaryTransitiveClosureConstraint((BinaryTransitiveClosure) constraint);
+                } else if (constraint instanceof RepresentativeElectionConstraint) {
+                        copyRepresentativeElectionConstraint((RepresentativeElectionConstraint) constraint);
+        } else if (constraint instanceof RelationEvaluation) {
+            copyRelationEvaluationConstraint((RelationEvaluation) constraint);
+        } else if (constraint instanceof BinaryReflexiveTransitiveClosure) {
+            copyBinaryReflexiveTransitiveClosureConstraint((BinaryReflexiveTransitiveClosure) constraint);
+        } else if (constraint instanceof PatternMatchCounter) {
+            copyPatternMatchCounterConstraint((PatternMatchCounter) constraint);
+        } else if (constraint instanceof AggregatorConstraint) {
+            copyAggregatorConstraint((AggregatorConstraint) constraint);
+        } else if (constraint instanceof ExpressionEvaluation) {
+            copyExpressionEvaluationConstraint((ExpressionEvaluation) constraint);
+        } else {
+            throw new QueryProcessingException("Unknown PConstraint {0} encountered while copying PBody",
+                    new String[] { constraint.getClass().getName() }, "Unknown PConstraint", body.getPattern());
+        }
+    }
+
+    protected ExportedParameter copyExportedParameterConstraint(ExportedParameter exportedParameter) {
+        PVariable mappedPVariable = variableMapping.get(exportedParameter.getParameterVariable());
+        PParameter parameter = exportedParameter.getPatternParameter();
+        ExportedParameter newExportedParameter;
+        newExportedParameter = new ExportedParameter(body, mappedPVariable, parameter);
+        body.getSymbolicParameters().add(newExportedParameter);
+        addTrace(exportedParameter, newExportedParameter);
+        return newExportedParameter;
+    }
+
+    protected void copyEqualityConstraint(Equality equality) {
+        PVariable who = equality.getWho();
+        PVariable withWhom = equality.getWithWhom();
+        addTrace(equality, new Equality(body, variableMapping.get(who), variableMapping.get(withWhom)));
+    }
+
+    protected void copyInequalityConstraint(Inequality inequality) {
+        PVariable who = inequality.getWho();
+        PVariable withWhom = inequality.getWithWhom();
+        addTrace(inequality, new Inequality(body, variableMapping.get(who), variableMapping.get(withWhom)));
+    }
+
+    protected void copyTypeConstraint(TypeConstraint typeConstraint) {
+        PVariable[] mappedVariables = extractMappedVariables(typeConstraint);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(typeConstraint, new TypeConstraint(body, variablesTuple, typeConstraint.getSupplierKey()));
+    }
+
+    protected void copyTypeFilterConstraint(TypeFilterConstraint typeConstraint) {
+        PVariable[] mappedVariables = extractMappedVariables(typeConstraint);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(typeConstraint, new TypeFilterConstraint(body, variablesTuple, typeConstraint.getInputKey()));
+    }
+
+    protected void copyConstantValueConstraint(ConstantValue constantValue) {
+        PVariable pVariable = (PVariable) constantValue.getVariablesTuple().getElements()[0];
+        addTrace(constantValue,
+                new ConstantValue(body, variableMapping.get(pVariable), constantValue.getSupplierKey()));
+    }
+
+    protected void copyPositivePatternCallConstraint(PositivePatternCall positivePatternCall) {
+        PVariable[] mappedVariables = extractMappedVariables(positivePatternCall);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(positivePatternCall,
+                new PositivePatternCall(body, variablesTuple, positivePatternCall.getReferredQuery()));
+    }
+
+    protected void copyNegativePatternCallConstraint(NegativePatternCall negativePatternCall) {
+        PVariable[] mappedVariables = extractMappedVariables(negativePatternCall);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(negativePatternCall,
+                new NegativePatternCall(body, variablesTuple, negativePatternCall.getReferredQuery()));
+    }
+
+    protected void copyBinaryTransitiveClosureConstraint(BinaryTransitiveClosure binaryTransitiveClosure) {
+        PVariable[] mappedVariables = extractMappedVariables(binaryTransitiveClosure);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(binaryTransitiveClosure,
+                new BinaryTransitiveClosure(body, variablesTuple, binaryTransitiveClosure.getReferredQuery()));
+    }
+
+        protected void copyRepresentativeElectionConstraint(RepresentativeElectionConstraint constraint) {
+                var mappedVariables = extractMappedVariables(constraint);
+                var variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+                addTrace(constraint, new RepresentativeElectionConstraint(body, variablesTuple, constraint.getReferredQuery(),
+                                constraint.getConnectivity()));
+        }
+
+    /**
+     * @since 2.8
+     */
+    protected void copyRelationEvaluationConstraint(RelationEvaluation relationEvaluation) {
+        PVariable[] mappedVariables = extractMappedVariables(relationEvaluation);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(relationEvaluation, new RelationEvaluation(body, variablesTuple, relationEvaluation.getReferredQueries(),
+                relationEvaluation.getEvaluator()));
+    }
+
+    /**
+     * @since 2.0
+     */
+    protected void copyBinaryReflexiveTransitiveClosureConstraint(
+            BinaryReflexiveTransitiveClosure binaryReflexiveTransitiveClosure) {
+        PVariable[] mappedVariables = extractMappedVariables(binaryReflexiveTransitiveClosure);
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(binaryReflexiveTransitiveClosure,
+                new BinaryReflexiveTransitiveClosure(body, variablesTuple,
+                        binaryReflexiveTransitiveClosure.getReferredQuery(),
+                        binaryReflexiveTransitiveClosure.getUniverseType()));
+    }
+
+    protected void copyPatternMatchCounterConstraint(PatternMatchCounter patternMatchCounter) {
+        PVariable[] mappedVariables = extractMappedVariables(patternMatchCounter);
+        PVariable mappedResultVariable = variableMapping.get(patternMatchCounter.getResultVariable());
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(patternMatchCounter, new PatternMatchCounter(body, variablesTuple,
+                patternMatchCounter.getReferredQuery(), mappedResultVariable));
+    }
+
+    /**
+     * @since 1.4
+     */
+    protected void copyAggregatorConstraint(AggregatorConstraint constraint) {
+        PVariable[] mappedVariables = extractMappedVariables(constraint);
+        PVariable mappedResultVariable = variableMapping.get(constraint.getResultVariable());
+        Tuple variablesTuple = Tuples.flatTupleOf((Object[]) mappedVariables);
+        addTrace(constraint, new AggregatorConstraint(constraint.getAggregator(), body, variablesTuple,
+                constraint.getReferredQuery(), mappedResultVariable, constraint.getAggregatedColumn()));
+    }
+
+    protected void copyExpressionEvaluationConstraint(ExpressionEvaluation expressionEvaluation) {
+        PVariable mappedOutputVariable = variableMapping.get(expressionEvaluation.getOutputVariable());
+        addTrace(expressionEvaluation, new ExpressionEvaluation(body,
+                new VariableMappingExpressionEvaluatorWrapper(expressionEvaluation.getEvaluator(), variableMapping),
+                mappedOutputVariable, expressionEvaluation.isUnwinding()));
+    }
+
+    /**
+     * For positive pattern calls
+     *
+     * @param positivePatternCall
+     * @return the mapped variables to the pattern's parameters
+     */
+    protected PVariable[] extractMappedVariables(EnumerablePConstraint enumerablePConstraint) {
+        Object[] pVariables = enumerablePConstraint.getVariablesTuple().getElements();
+        return mapVariableList(pVariables);
+    }
+
+    /**
+     * For negative and count pattern calls.
+     *
+     * @param patternMatchCounter
+     * @return the mapped variables to the pattern's parameters
+     */
+    private PVariable[] extractMappedVariables(PatternCallBasedDeferred patternCallBasedDeferred) {
+        Object[] pVariables = patternCallBasedDeferred.getActualParametersTuple().getElements();
+        return mapVariableList(pVariables);
+    }
+
+    /**
+     * For type filters.
+     */
+    private PVariable[] extractMappedVariables(TypeFilterConstraint typeFilterConstraint) {
+        Object[] pVariables = typeFilterConstraint.getVariablesTuple().getElements();
+        return mapVariableList(pVariables);
+    }
+
+    private PVariable[] mapVariableList(Object[] pVariables) {
+        List<PVariable> list = new ArrayList<PVariable>();
+        for (int i = 0; i < pVariables.length; i++) {
+            PVariable mappedVariable = variableMapping.get(pVariables[i]);
+            list.add(mappedVariable);
+        }
+        return list.toArray(new PVariable[0]);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyNormalizer.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyNormalizer.java
new file mode 100644
index 00000000..90943129
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyNormalizer.java
@@ -0,0 +1,310 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Queue;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.planning.QueryProcessingException;
+import tools.refinery.viatra.runtime.matchers.planning.helpers.TypeHelper;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.ITypeInfoProviderConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.TypeJudgement;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.Equality;
+import tools.refinery.viatra.runtime.matchers.psystem.basicdeferred.Inequality;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * A disjunction rewriter for creating a normalized form of specification, unifying variables and running basic sanity
+ * checks. This rewriter does not copy but modifies directly the original specification, requiring a mutable
+ * disjunction.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public class PBodyNormalizer extends PDisjunctionRewriter {
+
+    private IQueryMetaContext context;
+
+    public PBodyNormalizer(IQueryMetaContext context) {
+        this.context = context;
+    }
+
+    /**
+     * Returns whether unary constraint elimination is enabled. This behavior can be customized by creating a subclass
+     * with a custom implementation.
+     * 
+     * @since 1.6
+     */
+    protected boolean shouldCalculateImpliedTypes(PQuery query) {
+        return true;
+    }
+
+    /**
+     * Returns whether 'weakened alternative' suggestions of the context shall be expanded as additional PConstraints. 
+     * This behavior can be customized by creating a subclass
+     * with a custom implementation.
+     * 
+     * @since 1.6
+     */
+    protected boolean shouldExpandWeakenedAlternatives(PQuery query) {
+        return false;
+    }
+
+    @Override
+    public PDisjunction rewrite(PDisjunction disjunction) {
+        Set<PBody> normalizedBodies = new LinkedHashSet<>();
+        for (PBody body : disjunction.getBodies()) {
+            PBodyCopier copier = new PBodyCopier(body, getTraceCollector());
+            PBody modifiedBody = copier.getCopiedBody();
+            normalizeBody(modifiedBody);
+            normalizedBodies.add(modifiedBody);
+            modifiedBody.setStatus(PQueryStatus.OK);
+        }
+        return new PDisjunction(normalizedBodies);
+    }
+
+    public void setContext(IQueryMetaContext context) {
+        this.context = context;
+    }
+
+    /**
+     * Provides a normalized version of the pattern body. May return a different version than the original version if
+     * needed.
+     * 
+     * @param body
+     */
+    public PBody normalizeBody(PBody body) {
+        try {
+            return normalizeBodyInternal(body);
+        } catch (QueryProcessingException e) {
+            throw new RewriterException("Error during rewriting: {1}", new String[] { e.getMessage() },
+                    e.getShortMessage(), body.getPattern(), e);
+        }
+    }
+
+    PBody normalizeBodyInternal(PBody body) {
+        // UNIFICATION AND WEAK INEQUALITY ELIMINATION
+        unifyVariablesAlongEqualities(body);
+        eliminateWeakInequalities(body);
+        removeMootEqualities(body);
+
+        // ADDING WEAKENED ALTERNATIVES
+        if (shouldExpandWeakenedAlternatives(body.getPattern())) {
+            expandWeakenedAlternativeConstraints(body);
+        }
+        
+        // CONSTRAINT ELIMINATION WITH TYPE INFERENCE
+        if (shouldCalculateImpliedTypes(body.getPattern())) {
+            eliminateInferrableTypes(body, context);
+        } else {
+            // ELIMINATE DUPLICATE TYPE CONSTRAINTS
+            eliminateDuplicateTypeConstraints(body);
+        }
+
+        
+        // PREVENTIVE CHECKS
+        checkSanity(body);
+        return body;
+    }
+    
+    private void removeMootEqualities(PBody body) {
+        Set<Equality> equals = body.getConstraintsOfType(Equality.class);
+        for (Equality equality : equals) {
+            if (equality.isMoot()) {
+                equality.delete();
+                derivativeRemoved(equality, ConstraintRemovalReason.MOOT_EQUALITY);
+            }
+        }
+    }
+
+    /**
+     * Unifies allVariables along equalities so that they can be handled as one.
+     * 
+     * @param body
+     */
+    void unifyVariablesAlongEqualities(PBody body) {
+        Set<Equality> equals = body.getConstraintsOfType(Equality.class);
+        for (Equality equality : equals) {
+            if (!equality.isMoot()) {
+                equality.getWho().unifyInto(equality.getWithWhom());
+            }
+        }
+    }
+
+    /**
+     * Eliminates weak inequalities if they are not substantiated.
+     * 
+     * @param body
+     */
+    void eliminateWeakInequalities(PBody body) {
+        for (Inequality inequality : body.getConstraintsOfType(Inequality.class)){
+            if (inequality.isEliminable()){
+                inequality.eliminateWeak();
+                derivativeRemoved(inequality, ConstraintRemovalReason.WEAK_INEQUALITY_SELF_LOOP);
+            }
+        }
+    }
+
+    /**
+     * Eliminates all type constraints that are inferrable from other constraints.
+     */
+    void eliminateInferrableTypes(final PBody body, IQueryMetaContext context) {
+        Set<TypeJudgement> subsumedByRetainedConstraints = new HashSet<TypeJudgement>();
+        LinkedList<ITypeConstraint> allTypeConstraints = new LinkedList<ITypeConstraint>();
+        for (PConstraint pConstraint : body.getConstraints()) {
+            if (pConstraint instanceof ITypeConstraint) {
+                allTypeConstraints.add((ITypeConstraint) pConstraint);
+            } else if (pConstraint instanceof ITypeInfoProviderConstraint) {
+                // non-type constraints are all retained
+                final Set<TypeJudgement> directJudgements = ((ITypeInfoProviderConstraint) pConstraint)
+                        .getImpliedJudgements(context);
+                subsumedByRetainedConstraints = TypeHelper.typeClosure(subsumedByRetainedConstraints, directJudgements,
+                        context);
+            }
+        }
+        Comparator<ITypeConstraint> eliminationOrder = (o1, o2) -> {
+            IInputKey type1 = o1.getEquivalentJudgement().getInputKey();
+            IInputKey type2 = o2.getEquivalentJudgement().getInputKey();
+            
+            int result = context.getSuggestedEliminationOrdering().compare(type1, type2);
+            return (result == 0) 
+                    ? PConstraint.COMPARE_BY_MONOTONOUS_ID.compare(o1, o2) 
+                    : result;
+        }; 
+                
+        Collections.sort(allTypeConstraints, eliminationOrder);
+        Queue<ITypeConstraint> potentialConstraints = allTypeConstraints; // rename for better comprehension
+
+        while (!potentialConstraints.isEmpty()) {
+            ITypeConstraint candidate = potentialConstraints.poll();
+
+            boolean isSubsumed = subsumedByRetainedConstraints.contains(candidate.getEquivalentJudgement());
+            if (!isSubsumed) {
+                Set<TypeJudgement> typeClosure = subsumedByRetainedConstraints;
+                for (ITypeConstraint subsuming : potentialConstraints) { // the remaining ones
+                    final Set<TypeJudgement> directJudgements = subsuming.getImpliedJudgements(context);
+                    typeClosure = TypeHelper.typeClosure(typeClosure, directJudgements, context);
+
+                    if (typeClosure.contains(candidate.getEquivalentJudgement())) {
+                        isSubsumed = true;
+                        break;
+                    }
+                }
+            }
+            if (isSubsumed) { // eliminated
+                candidate.delete();
+                derivativeRemoved(candidate, ConstraintRemovalReason.TYPE_SUBSUMED);
+            } else { // retained
+                subsumedByRetainedConstraints = TypeHelper.typeClosure(subsumedByRetainedConstraints,
+                        candidate.getImpliedJudgements(context), context);
+            }
+        }
+    }
+
+    /**
+     * Inserts "weakened alternative" constraints suggested by the meta context that aid in coming up with a query plan.
+     */
+    void expandWeakenedAlternativeConstraints(PBody body) {
+        Set<TypeJudgement> allJudgements = new HashSet<TypeJudgement>();
+        Set<TypeJudgement> newJudgementsToAdd = new HashSet<TypeJudgement>();
+        Queue<TypeJudgement> judgementsToProcess = new LinkedList<TypeJudgement>();
+        Map<TypeJudgement, List<PConstraint>> traceability = CollectionsFactory.createMap();
+        
+        for (ITypeConstraint typeConstraint : body.getConstraintsOfType(ITypeConstraint.class)) {
+            TypeJudgement equivalentJudgement = typeConstraint.getEquivalentJudgement();
+            judgementsToProcess.add(equivalentJudgement);
+            allJudgements.add(equivalentJudgement);
+            traceability.computeIfAbsent(equivalentJudgement, k-> new ArrayList<>()).add(typeConstraint);
+        }
+        
+        while (!judgementsToProcess.isEmpty()) {
+            TypeJudgement judgement = judgementsToProcess.poll();
+            for (TypeJudgement alternativeJudgement : judgement.getWeakenedAlternativeJudgements(context)) {
+                if (allJudgements.add(alternativeJudgement)) {
+                    newJudgementsToAdd.add(alternativeJudgement);
+                    judgementsToProcess.add(alternativeJudgement);
+                    traceability.merge(
+                            alternativeJudgement, 
+                            traceability.getOrDefault(judgement, new ArrayList<>()),
+                            (old,further) -> {old.addAll(further); return old;}
+                    );
+                }
+            }
+        }
+        
+        for (TypeJudgement typeJudgement : newJudgementsToAdd) {
+            PConstraint newConstraint = typeJudgement.createConstraintFor(body);
+            for (PConstraint source : traceability.getOrDefault(typeJudgement, Collections.emptyList())) {
+                addTrace(source, newConstraint);
+            }
+        }        
+    }
+    
+    private Object getConstraintKey(PConstraint constraint) {
+        if (constraint instanceof ITypeConstraint) {
+            return ((ITypeConstraint) constraint).getEquivalentJudgement();
+        }
+        // Do not check duplication for any other types
+        return constraint;
+    }
+    
+    void eliminateDuplicateTypeConstraints(PBody body) {
+        Map<Object, PConstraint> constraints = new HashMap<>();
+        for (PConstraint constraint : body.getConstraints()) {
+            Object key = getConstraintKey(constraint);
+            // Retain first found instance of a constraint
+            if (!constraints.containsKey(key)) {
+                constraints.put(key, constraint);
+            }
+        }
+
+        // Retain collected constraints, remove everything else
+        Iterator<PConstraint> iterator = body.getConstraints().iterator();
+        Collection<PConstraint> toRetain = constraints.values(); 
+        while(iterator.hasNext()){
+            PConstraint next = iterator.next();
+            if (!toRetain.contains(next)){
+                derivativeRemoved(next, ConstraintRemovalReason.DUPLICATE);
+                iterator.remove();
+            }
+        }
+    }
+    
+    /**
+     * Verifies the sanity of all constraints. Should be issued as a preventive check before layouting.
+     * 
+     * @param body
+     * @throws RetePatternBuildException
+     */
+    void checkSanity(PBody body) {
+        for (PConstraint pConstraint : body.getConstraints())
+            pConstraint.checkSanity();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriter.java
new file mode 100644
index 00000000..c844ccf7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriter.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * An abstract base class for creating alternative representations for PDisjunctions.
+ * @author Zoltan Ujhelyi
+ *
+ */
+public abstract class PDisjunctionRewriter extends AbstractRewriterTraceSource{
+    
+    public abstract PDisjunction rewrite(PDisjunction disjunction);
+    
+    public PDisjunction rewrite(PQuery query) {
+        return rewrite(query.getDisjunctBodies());
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriterCacher.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriterCacher.java
new file mode 100644
index 00000000..eb5422ca
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriterCacher.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.WeakHashMap;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+
+/**
+ * A rewriter that stores the previously computed results of a rewriter or a rewriter chain.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.0
+ */
+public class PDisjunctionRewriterCacher extends PDisjunctionRewriter {
+
+    private final List<PDisjunctionRewriter> rewriterChain;
+    private WeakHashMap<PDisjunction, PDisjunction> cachedResults =
+            new WeakHashMap<PDisjunction, PDisjunction>();
+
+    private void setupTraceCollectorInChain(){
+        IRewriterTraceCollector collector = getTraceCollector();
+        for(PDisjunctionRewriter rewriter: rewriterChain){
+            rewriter.setTraceCollector(collector);
+        }
+    }
+    
+    public PDisjunctionRewriterCacher(PDisjunctionRewriter rewriter) {
+        rewriterChain = Collections.singletonList(rewriter);
+    }
+    
+    public PDisjunctionRewriterCacher(PDisjunctionRewriter... rewriters) {
+        rewriterChain = new ArrayList<>(Arrays.asList(rewriters));
+    }
+    
+    public PDisjunctionRewriterCacher(List<PDisjunctionRewriter> rewriterChain) {
+        this.rewriterChain = new ArrayList<>(rewriterChain);
+    }
+    
+    @Override
+    public PDisjunction rewrite(PDisjunction disjunction) {
+        if (!cachedResults.containsKey(disjunction)) {
+            PDisjunction rewritten = disjunction;
+            setupTraceCollectorInChain();
+            for (PDisjunctionRewriter rewriter : rewriterChain) {
+                rewritten = rewriter.rewrite(rewritten);
+            }
+            
+            cachedResults.put(disjunction, rewritten);
+        }
+        return cachedResults.get(disjunction);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PQueryFlattener.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PQueryFlattener.java
new file mode 100644
index 00000000..76311d8f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PQueryFlattener.java
@@ -0,0 +1,253 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Marton Bur, Akos Horvath, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IConstraintFilter.AllowAllFilter;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IConstraintFilter.ExportedParameterFilter;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IVariableRenamer.HierarchicalName;
+import tools.refinery.viatra.runtime.matchers.psystem.rewriters.IVariableRenamer.SameName;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import tools.refinery.viatra.runtime.matchers.util.Sets;
+
+/**
+ * This rewriter class holds the query flattening logic
+ * 
+ * @author Marton Bur
+ * 
+ */
+public class PQueryFlattener extends PDisjunctionRewriter {
+
+    /**
+     * Utility function to produce the permutation of every possible mapping of values.
+     * 
+     * @param values
+     * @return
+     */
+    private static <K, V> Set<Map<K, V>> permutation(Map<K, Set<V>> values) {
+        // An ordering of keys is defined here which will help restoring the appropriate values after the execution of
+        // the cartesian product
+        List<K> keyList = new ArrayList<>(values.keySet());
+
+        // Produce list of value sets with the ordering defined by keyList
+        List<Set<V>> valuesList = new ArrayList<Set<V>>(keyList.size());
+        for (K key : keyList) {
+            valuesList.add(values.get(key));
+        }
+
+        // Cartesian product will obey ordering of the list
+        Set<List<V>> valueMappings = Sets.cartesianProduct(valuesList);
+
+        // Build result
+        Set<Map<K, V>> result = new LinkedHashSet<>();
+        for (List<V> valueList : valueMappings) {
+            Map<K, V> map = new HashMap<>();
+            for (int i = 0; i < keyList.size(); i++) {
+                map.put(keyList.get(i), valueList.get(i));
+            }
+            result.add(map);
+        }
+
+        return result;
+    }
+
+    private IFlattenCallPredicate flattenCallPredicate;
+
+    public PQueryFlattener(IFlattenCallPredicate flattenCallPredicate) {
+        this.flattenCallPredicate = flattenCallPredicate;
+    }
+
+    @Override
+    public PDisjunction rewrite(PDisjunction disjunction) {
+        PQuery query = disjunction.getQuery();
+
+        // Check for recursion
+        Set<PQuery> allReferredQueries = disjunction.getAllReferredQueries();
+        for (PQuery referredQuery : allReferredQueries) {
+            if (referredQuery.getAllReferredQueries().contains(referredQuery)) {
+                throw new RewriterException("Recursive queries are not supported, can't flatten query named \"{1}\"",
+                        new String[] { query.getFullyQualifiedName() }, "Unsupported recursive query", query);
+            }
+        }
+
+        return this.doFlatten(disjunction);
+    }
+
+    /**
+     * Return the list of dependencies (including the root) in chronological order
+     * 
+     * @param rootDisjunction
+     * @return
+     */
+    private List<PDisjunction> disjunctionDependencies(PDisjunction rootDisjunction) {
+        // Disjunctions are first collected into a list usign a depth-first approach,
+        // which can be iterated backwards while removing duplicates
+        Deque<PDisjunction> stack = new ArrayDeque<>();
+        LinkedList<PDisjunction> list = new LinkedList<>();
+        stack.push(rootDisjunction);
+        list.add(rootDisjunction);
+
+        while (!stack.isEmpty()) {
+            PDisjunction disjunction = stack.pop();
+            // Collect dependencies
+            for (PBody pBody : disjunction.getBodies()) {
+                for (PConstraint constraint : pBody.getConstraints()) {
+                    if (constraint instanceof PositivePatternCall) {
+                        PositivePatternCall positivePatternCall = (PositivePatternCall) constraint;
+                        if (flattenCallPredicate.shouldFlatten(positivePatternCall)) {
+                            // If the above preconditions meet, the call should be flattened
+                            PDisjunction calledDisjunction = positivePatternCall.getReferredQuery().getDisjunctBodies();
+                            stack.push(calledDisjunction);
+                            list.add(calledDisjunction);
+                        }
+                    }
+                }
+            }
+        }
+
+        // Remove duplicates (keeping the last instance) and reverse order
+        Set<PDisjunction> visited = new HashSet<PDisjunction>();
+        List<PDisjunction> result = new ArrayList<PDisjunction>(list.size());
+        
+        list.descendingIterator().forEachRemaining(item -> {
+            if (!visited.contains(item)) {
+                result.add(item);
+                visited.add(item);
+            }
+            
+        });
+
+        return result;
+    }
+
+    /**
+     * This function holds the actual flattening logic for a PQuery
+     * 
+     * @param rootDisjunction
+     *            to be flattened
+     * @return the flattened bodies of the pQuery
+     */
+    private PDisjunction doFlatten(PDisjunction rootDisjunction) {
+
+        Map<PDisjunction, Set<PBody>> flatBodyMapping = new HashMap<>();
+
+        List<PDisjunction> dependencies = disjunctionDependencies(rootDisjunction);
+
+        for (PDisjunction disjunction : dependencies) {
+            Set<PBody> flatBodies = new LinkedHashSet<>();
+            for (PBody body : disjunction.getBodies()) {
+                if (isFlatteningNeeded(body)) {
+                    Map<PositivePatternCall, Set<PBody>> flattenedBodies = new HashMap<>();
+                    for (PConstraint pConstraint : body.getConstraints()) {
+
+                        if (pConstraint instanceof PositivePatternCall) {
+                            PositivePatternCall positivePatternCall = (PositivePatternCall) pConstraint;
+                            if (flattenCallPredicate.shouldFlatten(positivePatternCall)) {
+                                // If the above preconditions meet, do the flattening and return the disjoint bodies
+                                PDisjunction calledDisjunction = positivePatternCall.getReferredQuery()
+                                        .getDisjunctBodies();
+
+                                Set<PBody> flattenedBodySet = flatBodyMapping.get(calledDisjunction);
+                                Preconditions.checkArgument(!flattenedBodySet.isEmpty());
+                                flattenedBodies.put(positivePatternCall, flattenedBodySet);
+                            }
+                        }
+                    }
+                    flatBodies.addAll(createSetOfFlatPBodies(body, flattenedBodies));
+                } else {
+                    flatBodies.add(prepareFlatPBody(body));
+                }
+            }
+            flatBodyMapping.put(disjunction, flatBodies);
+        }
+
+        return new PDisjunction(rootDisjunction.getQuery(), flatBodyMapping.get(rootDisjunction));
+    }
+
+    /**
+     * Creates the flattened bodies based on the caller body and the called (and already flattened) disjunctions
+     * 
+     * @param pBody
+     *            the body to flatten
+     * @param flattenedDisjunctions
+     *            the
+     * @param flattenedCalls
+     * @return
+     */
+    private Set<PBody> createSetOfFlatPBodies(PBody pBody, Map<PositivePatternCall, Set<PBody>> flattenedCalls) {
+        PQuery pQuery = pBody.getPattern();
+
+        Set<Map<PositivePatternCall, PBody>> conjunctedCalls = permutation(flattenedCalls);
+
+        // The result set containing the merged conjuncted bodies
+        Set<PBody> conjunctedBodies = new HashSet<>();
+
+        for (Map<PositivePatternCall, PBody> calledBodies : conjunctedCalls) {
+            FlattenerCopier copier = createBodyCopier(pQuery, calledBodies);
+
+            int i = 0;
+            HierarchicalName hierarchicalNamingTool = new HierarchicalName();
+            for (PositivePatternCall patternCall : calledBodies.keySet()) {
+                // Merge each called body
+                hierarchicalNamingTool.setCallCount(i++);
+                copier.mergeBody(patternCall, hierarchicalNamingTool, new ExportedParameterFilter());
+            }
+
+            // Merge the caller's constraints to the conjunct body
+            copier.mergeBody(pBody);
+
+            PBody copiedBody = copier.getCopiedBody();
+            copiedBody.setStatus(PQueryStatus.OK);
+            conjunctedBodies.add(copiedBody);
+        }
+
+        return conjunctedBodies;
+    }
+
+    private FlattenerCopier createBodyCopier(PQuery query, Map<PositivePatternCall, PBody> calledBodies) {
+        FlattenerCopier flattenerCopier = new FlattenerCopier(query, calledBodies);
+        flattenerCopier.setTraceCollector(getTraceCollector());
+        return flattenerCopier;
+    }
+
+    private PBody prepareFlatPBody(PBody pBody) {
+        PBodyCopier copier = createBodyCopier(pBody.getPattern(), Collections.<PositivePatternCall, PBody> emptyMap());
+        copier.mergeBody(pBody, new SameName(), new AllowAllFilter());
+        // the copying of the body here is necessary for only one containing PDisjunction can be assigned to a PBody
+        return copier.getCopiedBody();
+    }
+
+    private boolean isFlatteningNeeded(PBody pBody) {
+        // Check if the body contains positive pattern call AND if it should be flattened
+        for (PConstraint pConstraint : pBody.getConstraints()) {
+            if (pConstraint instanceof PositivePatternCall) {
+                return flattenCallPredicate.shouldFlatten((PositivePatternCall) pConstraint);
+            }
+        }
+        return false;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/RewriterException.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/RewriterException.java
new file mode 100644
index 00000000..d0fc286b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/RewriterException.java
@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.QueryInitializationException;
+
+/**
+ * An exception to wrap various issues during PDisjunction rewriting.
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class RewriterException extends QueryInitializationException {
+
+    private static final long serialVersionUID = -4703825954995497932L;
+
+    public RewriterException(String message, String[] context, String shortMessage, Object patternDescription,
+            Throwable cause) {
+        super(message, context, shortMessage, patternDescription, cause);
+    }
+
+    public RewriterException(String message, String[] context, String shortMessage, Object patternDescription) {
+        super(message, context, shortMessage, patternDescription);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/SurrogateQueryRewriter.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/SurrogateQueryRewriter.java
new file mode 100644
index 00000000..71459558
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/SurrogateQueryRewriter.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.LinkedHashSet;
+import java.util.Set;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.surrogate.SurrogateQueryRegistry;
+import tools.refinery.viatra.runtime.matchers.psystem.PBody;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import tools.refinery.viatra.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PDisjunction;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery.PQueryStatus;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuples;
+
+/**
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class SurrogateQueryRewriter extends PDisjunctionRewriter {
+
+    @Override
+    public PDisjunction rewrite(PDisjunction disjunction) {
+        Set<PBody> replacedBodies = new LinkedHashSet<>();
+        for (PBody body : disjunction.getBodies()) {
+            PBodyCopier copier = new PBodyCopier(body, getTraceCollector()) {
+                
+                @Override
+                protected void copyTypeConstraint(TypeConstraint typeConstraint) {
+                    PVariable[] mappedVariables = extractMappedVariables(typeConstraint);
+                    Tuple variablesTuple = Tuples.flatTupleOf((Object[])mappedVariables);       
+                    final IInputKey supplierKey = typeConstraint.getSupplierKey();
+                    if(SurrogateQueryRegistry.instance().hasSurrogateQueryFQN(supplierKey)) {
+                        PQuery surrogateQuery = SurrogateQueryRegistry.instance().getSurrogateQuery(supplierKey);
+                        if (surrogateQuery == null) {
+                            throw new IllegalStateException(
+                                        String.format("Surrogate query for feature %s not found", 
+                                                        supplierKey.getPrettyPrintableName()));
+                        }
+                        addTrace(typeConstraint, new PositivePatternCall(getCopiedBody(), variablesTuple, surrogateQuery));
+                    } else {
+                        addTrace(typeConstraint, new TypeConstraint(getCopiedBody(), variablesTuple, supplierKey));
+                    }
+                }
+            };
+            PBody modifiedBody = copier.getCopiedBody();
+            replacedBodies.add(modifiedBody);
+            modifiedBody.setStatus(PQueryStatus.OK);
+        }
+        return new PDisjunction(replacedBodies);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/VariableMappingExpressionEvaluatorWrapper.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/VariableMappingExpressionEvaluatorWrapper.java
new file mode 100644
index 00000000..10337979
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/VariableMappingExpressionEvaluatorWrapper.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.psystem.rewriters;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.psystem.IExpressionEvaluator;
+import tools.refinery.viatra.runtime.matchers.psystem.IValueProvider;
+import tools.refinery.viatra.runtime.matchers.psystem.PVariable;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * A wrapper for {@link IExpressionEvaluator} which is capable of correctly mapping variable names used by the
+ * expression.
+ * 
+ * @author Grill Balázs
+ *
+ */
+class VariableMappingExpressionEvaluatorWrapper implements IExpressionEvaluator {
+
+    private final IExpressionEvaluator wrapped;
+    private final Map<String, String> variableMapping;
+    
+    public VariableMappingExpressionEvaluatorWrapper(IExpressionEvaluator wrapped,
+            Map<PVariable, PVariable> variableMapping) {
+        
+        // Support to rewrap an already wrapped expression.
+        boolean rewrap = wrapped instanceof VariableMappingExpressionEvaluatorWrapper;
+        this.wrapped = rewrap ? ((VariableMappingExpressionEvaluatorWrapper)wrapped).wrapped : wrapped;
+
+        // Instead of just saving the reference of the mapping, save the actual (trimmed) state of the mapping as it
+        // may change during copying (especially during flattening). A LinkedHashMap is used to retain ordering of
+        // original parameter names iterator.
+        this.variableMapping = new LinkedHashMap<>();
+
+        // Index map by variable names
+        Map<String, PVariable> names = new HashMap<>();
+        for (PVariable originalVar : variableMapping.keySet()) {
+            names.put(originalVar.getName(), originalVar);
+        }
+        
+        // In case of rewrapping, current names are contained by the previous mapping
+        Map<String, String> previousMapping = null;
+        if (rewrap){
+            previousMapping = ((VariableMappingExpressionEvaluatorWrapper)wrapped).variableMapping;
+        }
+
+        // Populate mapping
+        for (String inputParameterName : this.wrapped.getInputParameterNames()) {
+            String parameterName = rewrap ? previousMapping.get(inputParameterName) : inputParameterName;
+            Preconditions.checkArgument(parameterName != null);
+            PVariable original = names.get(parameterName);
+            Preconditions.checkArgument(original != null);
+            PVariable mapped = variableMapping.get(original);
+            if (mapped != null){
+                this.variableMapping.put(inputParameterName, mapped.getName());
+            }
+        }
+    }
+
+    @Override
+    public String getShortDescription() {
+        return wrapped.getShortDescription();
+    }
+
+    @Override
+    public Iterable<String> getInputParameterNames() {
+        return variableMapping.values();
+    }
+
+    @Override
+    public Object evaluateExpression(final IValueProvider provider) throws Exception {
+        return wrapped.evaluateExpression(variableName -> {
+            String mappedVariableName = variableMapping.get(variableName);
+            Preconditions.checkArgument(mappedVariableName != null, "Could not find variable %s", variableName);
+            return provider.getValue(mappedVariableName);
+        });
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/AbstractTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/AbstractTuple.java
new file mode 100644
index 00000000..a26d9193
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/AbstractTuple.java
@@ -0,0 +1,136 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+
+/**
+ * Common implementation methods for immutable and volatile tuples. The class should not be used directly in client
+ * code, except for the definition of new tuple implementations.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public abstract class AbstractTuple implements ITuple {
+
+    /**
+     * As the tuple is supposed to be immutable, do not modify the returned array.
+     * 
+     * @return the array containing all elements of this Tuple
+     */
+    @Override
+    public Object[] getElements() {
+        Object[] allElements = new Object[getSize()];
+        for (int i = 0; i < allElements.length; ++i)
+            allElements[i] = get(i);
+        return allElements;
+    }
+
+    /**
+     * @return the set containing all distinct elements of this Tuple, cast as type T
+     */
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> Set<T> getDistinctElements() {
+        Set<T> result = new HashSet<T>();
+        Object[] elements = getElements();
+        for (Object object : elements) {
+            result.add((T) object);
+        }
+        return result;
+    }
+
+    /**
+     * Calculates an inverted index of the elements of this pattern. For each element, the index of the (last)
+     * occurrence is calculated.
+     * 
+     * @return the inverted index mapping each element of this pattern to its index in the array
+     */
+    @Override
+    public Map<Object, Integer> invertIndex() {
+        Map<Object, Integer> result = new HashMap<Object, Integer>();
+        for (int i = 0; i < getSize(); i++)
+            result.put(get(i), i);
+        return result;
+    }
+
+    /**
+     * Calculates an inverted index of the elements of this pattern. For each element, the index of all of its
+     * occurrences is calculated.
+     * 
+     * @return the inverted index mapping each element of this pattern to its index in the array
+     */
+    @Override
+    public Map<Object, List<Integer>> invertIndexWithMupliplicity() {
+        Map<Object, List<Integer>> result = new HashMap<Object, List<Integer>>();
+        for (int i = 0; i < getSize(); i++) {
+            Object value = get(i);
+            List<Integer> indices = result.computeIfAbsent(value, v -> new ArrayList<>());
+            indices.add(i);
+        }
+        return result;
+    }
+
+    /**
+     * @since 1.7
+     */
+    protected IndexOutOfBoundsException raiseIndexingError(int index) {
+        return new IndexOutOfBoundsException(
+                String.format("No value at position %d for %s instance %s", index, getClass().getSimpleName(), this));
+    }
+
+    /**
+     * Compares the elements stored in this tuple to another tuple
+     */
+    protected boolean internalEquals(ITuple other) {
+        if (getSize() != other.getSize())
+            return false;
+        boolean result = true;
+        for (int i = 0; result && i < getSize(); ++i) {
+            Object ours = get(i);
+            Object theirs = other.get(i);
+            result = result && Objects.equals(ours, theirs);
+        }
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        s.append("T(");
+        for (Object o : getElements()) {
+            s.append(o == null ? "null" : o.toString());
+            s.append(';');
+        }
+        s.append(')');
+        return s.toString();
+    }
+
+    /**
+     * @since 1.7
+     */
+    protected int doCalcHash() {
+        final int PRIME = 31;
+        int hash = 1;
+        for (int i = 0; i < getSize(); i++) {
+            hash = PRIME * hash;
+            Object element = get(i);
+            if (element != null)
+                hash += element.hashCode();
+        }
+        return hash;
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseFlatTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseFlatTuple.java
new file mode 100644
index 00000000..6f46b763
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseFlatTuple.java
@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Base class for all flat tuple implementations.
+ * Flat tuples store all elements locally (do not reference other tuples).
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public abstract class BaseFlatTuple extends Tuple {
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseLeftInheritanceTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseLeftInheritanceTuple.java
new file mode 100644
index 00000000..03f9ea89
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseLeftInheritanceTuple.java
@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Common functionality of left inheritance tuple implementations.
+ * 
+ * <p>Left inheritance tuples inherit their first few elements from another tuple, 
+ * and extend it with additional "local" elements.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public abstract class BaseLeftInheritanceTuple extends Tuple {
+
+    /**
+     * The number of elements that aren't stored locally, but inherited from an ancestor Tuple instead.
+     */
+    protected final int inheritedIndex;
+    /**
+     * This object contains the same elements as the ancestor on the first inheritedIndex positions
+     */
+    protected final Tuple ancestor;
+    
+    /**
+     * @param ancestor
+     */
+    public BaseLeftInheritanceTuple(Tuple ancestor) {
+        super();
+        this.ancestor = ancestor;
+        this.inheritedIndex = ancestor.getSize();
+    }
+
+    /**
+     * @return the number of local (non-inherited) elements
+     */
+    public abstract int getLocalSize();
+    
+    /**
+     * Optimized equals calculation (prediction: true, since hash values match)
+     */    
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        if (other instanceof BaseLeftInheritanceTuple) {
+            BaseLeftInheritanceTuple blit = (BaseLeftInheritanceTuple) other;
+            if (blit.inheritedIndex == this.inheritedIndex) {
+                if (this.ancestor.equals(blit.ancestor)) {
+                    return localEquals(blit);
+                } else return false;
+            }
+        }
+        return super.internalEquals(other);
+    }
+
+    /**
+     * Checks the equivalence of local elements only, after ancestor tuple has been determined to be equal.
+     */
+    protected abstract boolean localEquals(BaseLeftInheritanceTuple other);
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple.java
new file mode 100644
index 00000000..8bbb0ac2
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Arrays;
+
+/**
+ * Default Tuple implementation, with statically unknown arity.
+ * @author Gabor Bergmann 
+ */
+public final class FlatTuple extends BaseFlatTuple {
+
+    /**
+     * Array of substituted values. DO NOT MODIFY! Use Constructor to build a new instance instead.
+     */
+    private final Object[] elements;
+
+    /**
+     * Creates a FlatTuple instance, fills it with the given array.
+     * <p> Users should consider calling {@link Tuples#flatTupleOf(Object...)} instead to save memory on low-arity tuples.
+     * 
+     * @param elements
+     *            array of substitution values 
+     */
+    protected FlatTuple(Object... elements) {
+        this.elements = Arrays.copyOf(elements, elements.length);
+        calcHash();
+    }
+
+    @Override
+    public Object get(int index) {
+        return elements[index];
+    }
+
+    @Override
+    public int getSize() {
+        return elements.length;
+    }
+
+    @Override
+    public Object[] getElements() {
+        return elements;
+    }
+
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        if (other instanceof FlatTuple) {
+            return Arrays.equals(elements, ((FlatTuple) other).elements);
+        } else
+            return super.internalEquals(other);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple0.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple0.java
new file mode 100644
index 00000000..93f412b7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple0.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Flat tuple with statically known arity of 0.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ *
+ */
+public final class FlatTuple0 extends BaseFlatTuple {
+    protected static final FlatTuple0 INSTANCE = new FlatTuple0();
+
+    private FlatTuple0() {
+        calcHash();
+    }
+    
+    @Override
+    public int getSize() {
+        return 0;
+    }
+
+    @Override
+    public Object get(int index) {
+        throw raiseIndexingError(index);
+    }
+
+    private static final Object[] NULLARY_ARRAY = new Object[0];
+    
+    @Override
+    public Object[] getElements() {
+        return NULLARY_ARRAY;
+    }
+    
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        return 0 == other.getSize();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple1.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple1.java
new file mode 100644
index 00000000..b3b1c312
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple1.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * Flat tuple with statically known arity of 1.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ *
+ */
+public final class FlatTuple1 extends BaseFlatTuple {
+    private final Object element0;
+
+    protected FlatTuple1(Object element0) {
+        this.element0 = element0;
+        calcHash();
+    }
+
+    @Override
+    public int getSize() {
+        return 1;
+    }
+
+    @Override
+    public Object get(int index) {
+        if (index == 0) return element0;
+        else throw raiseIndexingError(index);
+    }
+
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        return 1 == other.getSize() &&
+                Objects.equals(element0, other.get(0));
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple2.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple2.java
new file mode 100644
index 00000000..2dcfd718
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple2.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * Flat tuple with statically known arity of 2.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ *
+ */
+public final class FlatTuple2 extends BaseFlatTuple {
+    private final Object element0;
+    private final Object element1;
+
+    protected FlatTuple2(Object element0, Object element1) {
+        this.element0 = element0;
+        this.element1 = element1;
+        calcHash();
+   }
+
+    @Override
+    public int getSize() {
+        return 2;
+    }
+
+    @Override
+    public Object get(int index) {
+        switch(index) {
+        case 0 : return element0;
+        case 1 : return element1;
+        default: throw raiseIndexingError(index);
+        }
+    }
+    
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        return 2 == other.getSize() &&
+                Objects.equals(element0, other.get(0)) &&
+                Objects.equals(element1, other.get(1));
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple3.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple3.java
new file mode 100644
index 00000000..50cee57e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple3.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * Flat tuple with statically known arity of 3.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ *
+ */
+public final class FlatTuple3 extends BaseFlatTuple {
+    private final Object element0;
+    private final Object element1;
+    private final Object element2;
+    
+    protected FlatTuple3(Object element0, Object element1, Object element2) {
+        this.element0 = element0;
+        this.element1 = element1;
+        this.element2 = element2;
+        calcHash();
+    }
+
+    @Override
+    public int getSize() {
+        return 3;
+    }
+
+    @Override
+    public Object get(int index) {
+        switch (index) {
+        case 0: return element0;
+        case 1: return element1;
+        case 2: return element2;
+        default: throw raiseIndexingError(index);
+        }
+    }
+    
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        return 3 == other.getSize() &&
+                Objects.equals(element0, other.get(0)) &&
+                Objects.equals(element1, other.get(1)) &&
+                Objects.equals(element2, other.get(2));
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple4.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple4.java
new file mode 100644
index 00000000..024c94f4
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple4.java
@@ -0,0 +1,59 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * Flat tuple with statically known arity of 4.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ *
+ */
+public final class FlatTuple4 extends BaseFlatTuple {
+    private final Object element0;
+    private final Object element1;
+    private final Object element2;
+    private final Object element3;
+
+    protected FlatTuple4(Object element0, Object element1, Object element2, Object element3) {
+        this.element0 = element0;
+        this.element1 = element1;
+        this.element2 = element2;
+        this.element3 = element3;
+        calcHash();
+    }
+    
+    @Override
+    public int getSize() {
+        return 4;
+    }
+
+    @Override
+    public Object get(int index) {
+        switch(index) {
+        case 0: return element0;
+        case 1: return element1;
+        case 2: return element2;
+        case 3: return element3;
+        default: throw raiseIndexingError(index);
+        }
+    }
+    
+    @Override
+    protected boolean internalEquals(ITuple other) {
+        return 4 == other.getSize() &&
+                Objects.equals(element0, other.get(0)) &&
+                Objects.equals(element1, other.get(1)) &&
+                Objects.equals(element2, other.get(2)) &&
+                Objects.equals(element3, other.get(3));
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/IModifiableTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/IModifiableTuple.java
new file mode 100644
index 00000000..f5dab2a5
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/IModifiableTuple.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * A tuple that allows modifying the underlying value. Should not be used for non-volatile tuples.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public interface IModifiableTuple extends ITuple {
+
+    /**
+     * Sets the selected value for a tuple
+     * 
+     * @pre: 0 <= index < getSize()
+     * 
+     */
+    void set(int index, Object value);
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/ITuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/ITuple.java
new file mode 100644
index 00000000..92014781
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/ITuple.java
@@ -0,0 +1,64 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Represents both mutable and immutable tuples
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public interface ITuple {
+
+    /**
+     * @pre: 0 <= index < getSize()
+     * 
+     * @return the element at the specified index
+     */
+    Object get(int index);
+
+    /**
+     * As the tuple is supposed to be immutable, do not modify the returned array.
+     * @return the array containing all elements of this Tuple
+     */
+    Object[] getElements();
+
+    /**
+     * @return the set containing all distinct elements of this Tuple, cast as type T
+     */
+    <T> Set<T> getDistinctElements();
+
+    /**
+     * @return number of elements
+     */
+    int getSize();
+    
+    /**
+     * Calculates an inverted index of the elements of this pattern. For each element, the index of the (last)
+     * occurrence is calculated.
+     * 
+     * @return the inverted index mapping each element of this pattern to its index in the array
+     */
+    Map<Object, Integer> invertIndex();
+
+    /**
+     * Calculates an inverted index of the elements of this pattern. For each element, the index of all of its
+     * occurrences is calculated.
+     * 
+     * @return the inverted index mapping each element of this pattern to its index in the array
+     */
+    Map<Object, List<Integer>> invertIndexWithMupliplicity();
+
+    Tuple toImmutable();
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple.java
new file mode 100644
index 00000000..dcdfc376
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple.java
@@ -0,0 +1,172 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * 
+ * Tuple that inherits another tuple on the left.
+ * 
+ * @author Gabor Bergmann
+ * 
+ */
+public final class LeftInheritanceTuple extends BaseLeftInheritanceTuple {
+    /**
+     * Array of substituted values above inheritedIndex. DO NOT MODIFY! Use Constructor to build a new instance instead.
+     */
+    private final Object[] localElements;
+
+    //
+    // /**
+    // * Creates a Tuple instance, fills it with the given array.
+    // * @pre: no elements are null
+    // * @param elements array of substitution values
+    // */
+    // public Tuple(Object[] elements)
+    // {
+    // this.localElements = elements;
+    // this.ancestor=null;
+    // this.inheritedIndex = 0;
+    // calcHash();
+    // }
+
+    
+    
+    /**
+     * Creates a Tuple instance, lets it inherit from an ancestor, extends it with a given array. @pre: no elements are
+     * null
+     * 
+     * @param localElements
+     *            array of substitution values 
+     */
+    LeftInheritanceTuple(Tuple ancestor, Object[] localElements) {
+        super(ancestor);
+        this.localElements = localElements;
+        calcHash();
+    }
+
+    //
+    // /**
+    // * Creates a Tuple instance of size one, fills it with the given object.
+    // * @pre: o!=null
+    // * @param o the single substitution
+    // */
+    // public Tuple(Object o)
+    // {
+    // localElements = new Object [1];
+    // localElements[0] = o;
+    // this.ancestor=null;
+    // this.inheritedIndex = 0;
+    // calcHash();
+    // }
+    //
+    // /**
+    // * Creates a Tuple instance of size two, fills it with the given objects.
+    // * @pre: o1!=null, o2!=null
+    // */
+    // public Tuple(Object o1, Object o2)
+    // {
+    // localElements = new Object [2];
+    // localElements[0] = o1;
+    // localElements[1] = o2;
+    // this.ancestor=null;
+    // this.inheritedIndex = 0;
+    // calcHash();
+    // }
+    //
+    // /**
+    // * Creates a Tuple instance of size three, fills it with the given
+    // objects.
+    // * @pre: o1!=null, o2!=null, o3!=null
+    // */
+    // public Tuple(Object o1, Object o2, Object o3)
+    // {
+    // localElements = new Object [3];
+    // localElements[0] = o1;
+    // localElements[1] = o2;
+    // localElements[2] = o3;
+    // this.ancestor=null;
+    // this.inheritedIndex = 0;
+    // calcHash();
+    // }
+
+    /**
+     * @return number of elements
+     */
+    public int getSize() {
+        return inheritedIndex + localElements.length;
+    }
+    
+    @Override
+    public int getLocalSize() {
+        return localElements.length;
+    }
+
+    /**
+     * @pre: 0 <= index < getSize()
+     * 
+     * @return the element at the specified index
+     */
+    public Object get(int index) {
+        return (index < inheritedIndex) ? ancestor.get(index) : localElements[index - inheritedIndex];
+    }
+
+    /**
+     * Optimized hash calculation
+     */
+    @Override
+    void calcHash() {
+        final int PRIME = 31;
+        cachedHash = ancestor.hashCode();
+        for (int i = 0; i < localElements.length; i++) {
+            cachedHash = PRIME * cachedHash;
+            Object element = localElements[i];
+            if (element != null)
+                cachedHash += element.hashCode();
+        }
+    }
+
+    /**
+     * Optimized equals calculation (prediction: true, since hash values match)
+     */    
+    @Override
+    protected boolean localEquals(BaseLeftInheritanceTuple other) {
+        if (other instanceof LeftInheritanceTuple) {
+            LeftInheritanceTuple lit = (LeftInheritanceTuple)other;
+            return Arrays.equals(this.localElements, lit.localElements);
+        } else {
+            if (localElements.length != other.getLocalSize())
+                return false;
+            int index = inheritedIndex;
+            for (int i = 0; i<localElements.length; ++i) {
+                if (! Objects.equals(localElements[i], other.get(index++))) 
+                    return false;
+            }
+            return true;
+        }
+    }
+
+    // public int compareTo(Object arg0) {
+    // Tuple other = (Tuple) arg0;
+    //
+    // int retVal = cachedHash - other.cachedHash;
+    // if (retVal==0) retVal = elements.length - other.elements.length;
+    // for (int i=0; retVal==0 && i<elements.length; ++i)
+    // {
+    // if (elements[i] == null && other.elements[i] != null) retVal = -1;
+    // else if (other.elements[i] == null) retVal = 1;
+    // else retVal = elements[i].compareTo(other.elements[i]);
+    // }
+    // return retVal;
+    // }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple1.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple1.java
new file mode 100644
index 00000000..61123176
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple1.java
@@ -0,0 +1,83 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class LeftInheritanceTuple1 extends BaseLeftInheritanceTuple {
+    /**
+     * A single substituted value after inheritedIndex. 
+     */
+    private final Object localElement;
+
+    /**
+     * @param ancestor
+     * @param localElement
+     */
+    protected LeftInheritanceTuple1(Tuple ancestor, Object localElement) {
+        super(ancestor);
+        this.localElement = localElement;
+        calcHash();
+    }
+    
+    /**
+     * @return number of elements
+     */
+    public int getSize() {
+        return inheritedIndex + 1;
+    }
+
+    @Override
+    public int getLocalSize() {
+        return 1;
+    }
+
+    /**
+     * @pre: 0 <= index < getSize()
+     * 
+     * @return the element at the specified index
+     */
+    public Object get(int index) {
+        int local = index - inheritedIndex;
+        if (local < 0) 
+            return ancestor.get(index);
+        else if (local == 0) return localElement;
+        else throw raiseIndexingError(index);
+    }
+
+    /**
+     * Optimized hash calculation
+     */
+    @Override
+    void calcHash() {
+        final int PRIME = 31;
+        cachedHash = ancestor.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement != null) cachedHash += localElement.hashCode();
+    }
+
+    /**
+     * Optimized equals calculation (prediction: true, since hash values match)
+     */    
+    @Override
+    protected boolean localEquals(BaseLeftInheritanceTuple other) {
+        if (other instanceof LeftInheritanceTuple1) {
+            LeftInheritanceTuple1 lit = (LeftInheritanceTuple1)other;
+            return Objects.equals(this.localElement, lit.localElement);
+        } else {
+            return (1 == other.getLocalSize()) && 
+                    Objects.equals(localElement, other.get(inheritedIndex));
+        }
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple2.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple2.java
new file mode 100644
index 00000000..e9fb98e8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple2.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class LeftInheritanceTuple2 extends BaseLeftInheritanceTuple {
+    private final Object localElement0;
+    private final Object localElement1;
+    
+    protected LeftInheritanceTuple2(Tuple ancestor, Object localElement0, Object localElement1) {
+        super(ancestor);
+        this.localElement0 = localElement0;
+        this.localElement1 = localElement1;
+        calcHash();
+    }
+
+    @Override
+    public int getLocalSize() {
+        return 2;
+    }
+    
+    @Override
+    public int getSize() {
+        return inheritedIndex + 2;
+    }
+
+    @Override
+    public Object get(int index) {
+        int local = index - inheritedIndex;
+        if (local < 0) 
+            return ancestor.get(index);
+        else if (local == 0) return localElement0;
+        else if (local == 1) return localElement1;
+        else throw raiseIndexingError(index);
+    }
+
+    /**
+     * Optimized hash calculation
+     */
+    @Override
+    void calcHash() {
+        final int PRIME = 31;
+        cachedHash = ancestor.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement0 != null) cachedHash += localElement0.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement1 != null) cachedHash += localElement1.hashCode();
+    }
+
+    @Override
+    protected boolean localEquals(BaseLeftInheritanceTuple other) {
+        if (other instanceof LeftInheritanceTuple2) {
+            LeftInheritanceTuple2 lit = (LeftInheritanceTuple2)other;
+            return Objects.equals(this.localElement0, lit.localElement0) &&
+                    Objects.equals(this.localElement1, lit.localElement1);
+        } else {
+            return (2 == other.getLocalSize()) && 
+                    Objects.equals(localElement0, other.get(inheritedIndex)) && 
+                    Objects.equals(localElement1, other.get(inheritedIndex + 1));
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple3.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple3.java
new file mode 100644
index 00000000..e61d196f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple3.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class LeftInheritanceTuple3 extends BaseLeftInheritanceTuple {
+    private final Object localElement0;
+    private final Object localElement1;
+    private final Object localElement2;
+
+    protected LeftInheritanceTuple3(Tuple ancestor, Object localElement0, Object localElement1, Object localElement2) {
+        super(ancestor);
+        this.localElement0 = localElement0;
+        this.localElement1 = localElement1;
+        this.localElement2 = localElement2;
+        calcHash();
+    }
+    
+    @Override
+    public int getLocalSize() {
+        return 3;
+    }
+    
+    @Override
+    public int getSize() {
+        return inheritedIndex + 3;
+    }
+
+    @Override
+    public Object get(int index) {
+        int local = index - inheritedIndex;
+        if (local < 0) 
+            return ancestor.get(index);
+        else if (local == 0) return localElement0;
+        else if (local == 1) return localElement1;
+        else if (local == 2) return localElement2;
+        else throw raiseIndexingError(index);
+    }
+
+    /**
+     * Optimized hash calculation
+     */
+    @Override
+    void calcHash() {
+        final int PRIME = 31;
+        cachedHash = ancestor.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement0 != null) cachedHash += localElement0.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement1 != null) cachedHash += localElement1.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement2 != null) cachedHash += localElement2.hashCode();
+    }
+
+    @Override
+    protected boolean localEquals(BaseLeftInheritanceTuple other) {
+        if (other instanceof LeftInheritanceTuple3) {
+            LeftInheritanceTuple3 lit = (LeftInheritanceTuple3)other;
+            return Objects.equals(this.localElement0, lit.localElement0) &&
+                    Objects.equals(this.localElement1, lit.localElement1) &&
+                    Objects.equals(this.localElement2, lit.localElement2);
+        } else {
+            return (3 == other.getLocalSize()) && 
+                    Objects.equals(localElement0, other.get(inheritedIndex)) && 
+                    Objects.equals(localElement1, other.get(inheritedIndex + 1)) && 
+                    Objects.equals(localElement2, other.get(inheritedIndex + 2));
+        }
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple4.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple4.java
new file mode 100644
index 00000000..4e50f1e1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple4.java
@@ -0,0 +1,88 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Objects;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class LeftInheritanceTuple4 extends BaseLeftInheritanceTuple {
+    private final Object localElement0;
+    private final Object localElement1;
+    private final Object localElement2;
+    private final Object localElement3;
+
+    protected LeftInheritanceTuple4(Tuple ancestor, Object localElement0, Object localElement1, Object localElement2,
+            Object localElement3) {
+        super(ancestor);
+        this.localElement0 = localElement0;
+        this.localElement1 = localElement1;
+        this.localElement2 = localElement2;
+        this.localElement3 = localElement3;
+        calcHash();
+    }
+
+    @Override
+    public int getLocalSize() {
+        return 4;
+    }
+    
+    @Override
+    public int getSize() {
+        return inheritedIndex + 4;
+    }
+
+    @Override
+    public Object get(int index) {
+        int local = index - inheritedIndex;
+        if (local < 0) 
+            return ancestor.get(index);
+        else if (local == 0) return localElement0;
+        else if (local == 1) return localElement1;
+        else if (local == 2) return localElement2;
+        else if (local == 3) return localElement3;
+        else throw raiseIndexingError(index);
+    }
+
+    /**
+     * Optimized hash calculation
+     */
+    @Override
+    void calcHash() {
+        final int PRIME = 31;
+        cachedHash = ancestor.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement0 != null) cachedHash += localElement0.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement1 != null) cachedHash += localElement1.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement2 != null) cachedHash += localElement2.hashCode();
+        cachedHash = PRIME * cachedHash;
+        if (localElement3 != null) cachedHash += localElement3.hashCode();
+    }
+
+    @Override
+    protected boolean localEquals(BaseLeftInheritanceTuple other) {
+        if (other instanceof LeftInheritanceTuple4) {
+            LeftInheritanceTuple4 lit = (LeftInheritanceTuple4)other;
+            return Objects.equals(this.localElement0, lit.localElement0) &&
+                    Objects.equals(this.localElement1, lit.localElement1) &&
+                    Objects.equals(this.localElement2, lit.localElement2) &&
+                    Objects.equals(this.localElement3, lit.localElement3);
+        } else {
+            return (4 == other.getLocalSize()) && 
+                    Objects.equals(localElement0, other.get(inheritedIndex)) && 
+                    Objects.equals(localElement1, other.get(inheritedIndex + 1)) && 
+                    Objects.equals(localElement2, other.get(inheritedIndex + 2)) && 
+                    Objects.equals(localElement3, other.get(inheritedIndex + 3));
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/MaskedTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/MaskedTuple.java
new file mode 100644
index 00000000..a5d1991c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/MaskedTuple.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2009 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * A tuple that transparently provides a masked (transformed) view of another tuple.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ * 
+ */
+public class MaskedTuple extends Tuple {
+
+    Tuple wrapped;
+    TupleMask mask;
+
+    public MaskedTuple(Tuple wrapped, TupleMask mask) {
+        super();
+        // if (wrapped instanceof MaskedTuple) {
+        // MaskedTuple parent = (MaskedTuple)wrapped;
+        // this.wrapped = parent.wrapped;
+        // this.mask = mask.transform(parent.mask);
+        // }
+        // else
+        //{
+            this.wrapped = wrapped;
+            this.mask = mask;
+        //}
+    }
+
+    @Override
+    public Object get(int index) {
+        return wrapped.get(mask.indices[index]);
+    }
+
+    @Override
+    public int getSize() {
+        return mask.indices.length;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuple.java
new file mode 100644
index 00000000..d94f545f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuple.java
@@ -0,0 +1,69 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Immutable tuple. Obtain instances via utility class {@link Tuples}.
+ * @author Gabor Bergmann
+ * 
+ */
+public abstract class Tuple extends AbstractTuple {
+
+    /**
+     * Caches precalculated hash value
+     */
+    protected int cachedHash;
+
+    /**
+     * Creates a Tuple instance Derivatives should call calcHash()
+     */
+    protected Tuple() {
+        // calcHash();
+    }
+
+    /**
+     * Hash calculation. Overrides should keep semantics.
+     */
+    void calcHash() {
+        cachedHash = doCalcHash();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj instanceof ITuple) {
+            final ITuple other = (ITuple) obj;
+            return cachedHash == other.hashCode() && internalEquals(other);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        // Calculated by #calcHash
+        return cachedHash;
+    }
+
+    public Tuple replaceAll(Object obsolete, Object replacement) {
+        Object[] oldElements = getElements();
+        Object[] newElements = new Object[oldElements.length];
+        for (int i = 0; i < oldElements.length; ++i) {
+            newElements[i] = obsolete.equals(oldElements[i]) ? replacement : oldElements[i];
+        }
+        return Tuples.flatTupleOf(newElements);
+    }
+
+    @Override
+    public Tuple toImmutable() {
+        return this;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask.java
new file mode 100644
index 00000000..49c55fef
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask.java
@@ -0,0 +1,560 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.Set;
+
+/**
+ * 
+ * Specifies select indices of a tuple. If viewed through this mask (see {@link #transform(ITuple)}), the signature of the pattern will consist of its
+ * individual substitutions at the given positions, in the exact same order as they appear in indices[].
+ * 
+ * @author Gabor Bergmann
+ */
+public class TupleMask {
+    /**
+     * indices[i] specifies the index of the substitution in the original tuple that occupies the i-th place in the
+     * masked signature.
+     */
+    public final int[] indices;
+    /**
+     * the size of the tuple this mask is applied to
+     */
+    public int sourceWidth;
+    /**
+     * indicesSorted is indices, sorted in ascending order. 
+     * null by default, call {@link #ensureIndicesSorted()} before using
+     */
+    int[] indicesSorted;
+    
+    /**
+     * true if no index occurs twice; computed on demand by {@link #isNonrepeating()}
+     */
+    Boolean isNonrepeating;
+
+    /**
+     * Creates a TupleMask instance with the given indices array
+     * <p> indicesSorted and isNonrepeating may be OPTIONALLY given if known.
+     * @since 2.0
+     */
+    protected TupleMask(int[] indices, int sourceWidth, int[] indicesSorted, Boolean isNonrepeating) {
+        this.indices = indices;
+        this.sourceWidth = sourceWidth;
+        this.indicesSorted = indicesSorted;
+        this.isNonrepeating = isNonrepeating;
+    }
+    
+    /**
+     * Creates a TupleMask instance that selects given positions.
+     * The mask takes ownership of the array selectedIndices, the client must not modify it afterwards.
+     * 
+     * <p> indicesSorted and isNonrepeating may be OPTIONALLY given if known.
+     * @since 2.0
+     */
+    protected static TupleMask fromSelectedIndicesInternal(
+            int[] selectedIndices, int sourceArity,
+            int[] indicesSorted, Boolean isNonrepeating) 
+    {
+        if (selectedIndices.length == 0) // is it nullary?
+            return new TupleMask0(sourceArity);
+        
+        // is it identity?
+        boolean identity = sourceArity == selectedIndices.length;
+        if (identity) {
+            for (int k=0; k < sourceArity; ++k) {
+                if (selectedIndices[k] != k) {
+                    identity = false;
+                    break;
+                }
+            }            
+        }
+        if (identity)
+            return new TupleMaskIdentity(selectedIndices, sourceArity);
+         
+        // generic case
+        return new TupleMask(selectedIndices, sourceArity, indicesSorted, isNonrepeating);
+    }
+    
+    /**
+     * Creates a TupleMask instance that selects given positions in monotonically increasing order.
+     * The mask takes ownership of the array selectedIndices, the client must not modify it afterwards.
+     * @since 2.0
+     */
+    protected static TupleMask fromSelectedMonotonicIndicesInternal(int[] selectedIndices, int sourceArity)
+    {
+        return fromSelectedIndicesInternal(selectedIndices, sourceArity, selectedIndices /* also sorted */, true);
+    }
+
+    /**
+     * Creates a TupleMask instance of the given size that maps the first 'size' elements intact
+     */
+    public static TupleMask linear(int size, int sourceWidth) {
+        if (size == sourceWidth) return new TupleMaskIdentity(sourceWidth);
+        int[] indices = constructLinearSequence(size);
+        return fromSelectedMonotonicIndicesInternal(indices, sourceWidth);
+    }
+
+    /**
+     * An array containing the first {@link size} nonnegative integers in order
+     * @since 2.0
+     */
+    protected static int[] constructLinearSequence(int size) {
+        int[] indices = new int[size];
+        for (int i = 0; i < size; i++)
+            indices[i] = i;
+        return indices;
+    }
+
+    /**
+     * Creates a TupleMask instance of the given size that maps every single element intact
+     */
+    public static TupleMask identity(int size) {
+        return new TupleMaskIdentity(size);   
+    }
+
+    /**
+     * Creates a TupleMask instance of the given size that does not emit output.
+     */
+    public static TupleMask empty(int sourceWidth) {
+        return linear(0, sourceWidth);
+    }
+
+    /**
+     * Creates a TupleMask instance that maps the tuple intact save for a single element at the specified index which is
+     * omitted
+     */
+    public static TupleMask omit(int omission, int sourceWidth) {
+        int size = sourceWidth - 1;
+        int[] indices = new int[size];
+        for (int i = 0; i < omission; i++)
+            indices[i] = i;
+        for (int i = omission; i < size; i++)
+            indices[i] = i + 1;
+        return fromSelectedMonotonicIndicesInternal(indices, sourceWidth);
+    }
+
+    
+    /**
+     * Creates a TupleMask instance that selects positions where keep is true
+     * @since 1.7
+     */
+    public static TupleMask fromKeepIndicators(boolean[] keep) {
+        int size = 0;
+        for (int k = 0; k < keep.length; ++k)
+            if (keep[k])
+                size++;
+        if (size == keep.length) return new TupleMaskIdentity(size);
+        int[] indices = new int[size];
+        int l = 0;
+        for (int k = 0; k < keep.length; ++k)
+            if (keep[k])
+                indices[l++] = k;
+        return fromSelectedMonotonicIndicesInternal(indices, keep.length);
+    }
+    
+    /**
+     * Creates a TupleMask instance that selects given positions.
+     * @since 1.7
+     */
+    public static TupleMask fromSelectedIndices(int sourceArity, Collection<Integer> selectedIndices) {
+        int[] selected = integersToIntArray(selectedIndices);
+        return fromSelectedIndicesInternal(selected, sourceArity, null, null);
+    }
+    /**
+     * Creates a TupleMask instance that selects given positions.
+     * @since 1.7
+     */
+    public static TupleMask fromSelectedIndices(int sourceArity, int[] selectedIndices) {
+        return fromSelectedIndicesInternal(Arrays.copyOf(selectedIndices, selectedIndices.length), sourceArity, null, null);
+    }
+    /**
+     * Creates a TupleMask instance that selects non-null positions of a given tuple
+     * @since 1.7
+     */
+    public static TupleMask fromNonNullIndices(ITuple tuple) {
+        List<Integer> indices = new ArrayList<>();
+        for (int i=0; i < tuple.getSize(); i++) {
+            if (tuple.get(i) != null) {
+                indices.add(i);
+            }
+        }
+        if (indices.size() == tuple.getSize()) return new TupleMaskIdentity(indices.size());
+        return fromSelectedMonotonicIndicesInternal(integersToIntArray(indices), tuple.getSize());
+    }
+    /**
+     * @since 1.7
+     */
+    public static int[] integersToIntArray(Collection<Integer> selectedIndices) {
+        int[] selected = new int[selectedIndices.size()];
+        int k=0;
+        for (Integer integer : selectedIndices) {
+            selected[k++] = integer;
+        }
+        return selected;
+    }
+
+
+    /**
+     * Creates a TupleMask instance that moves an element from one index to other, shifting the others if neccessary.
+     */
+    public static TupleMask displace(int from, int to, int sourceWidth) {
+        if (from == to) return new TupleMaskIdentity(sourceWidth);
+        int[] indices = new int[sourceWidth];
+        for (int i = 0; i < sourceWidth; i++)
+            if (i == to)
+                indices[i] = from;
+            else if (i >= from && i < to)
+                indices[i] = i + 1;
+            else if (i > to && i <= from)
+                indices[i] = i - 1;
+            else
+                indices[i] = i;
+        return fromSelectedIndicesInternal(indices, sourceWidth, null, true);
+    }
+
+    /**
+     * Creates a TupleMask instance that selects a single element of the tuple.
+     */
+    public static TupleMask selectSingle(int selected, int sourceWidth) {
+        int[] indices = { selected };
+        return fromSelectedMonotonicIndicesInternal(indices, sourceWidth);
+    }
+
+    /**
+     * Creates a TupleMask instance that selects whatever is selected by left, and appends whatever is selected by
+     * right. PRE: left and right have the same sourcewidth
+     */
+    public static TupleMask append(TupleMask left, TupleMask right) {
+        int leftLength = left.indices.length;
+        int rightLength = right.indices.length;
+        int[] indices = new int[leftLength + rightLength];
+        for (int i = 0; i < leftLength; ++i)
+            indices[i] = left.indices[i];
+        for (int i = 0; i < rightLength; ++i)
+            indices[i + leftLength] = right.indices[i];
+        return fromSelectedIndicesInternal(indices, left.sourceWidth, null, null);
+    }
+
+    /**
+     * Generates indicesSorted from indices on demand
+     */
+    void ensureIndicesSorted() {
+        if (indicesSorted == null) {
+            indicesSorted = new int[indices.length];
+            List<Integer> list = new LinkedList<Integer>();
+            for (int i = 0; i < indices.length; ++i)
+                list.add(indices[i]);
+            java.util.Collections.sort(list);
+            int i = 0;
+            for (Integer a : list)
+                indicesSorted[i++] = a;
+        }
+    }
+    
+    
+    
+    /**
+     * Returns the first index of the source that is not selected by the mask, or empty if all indices are selected.
+     * <p> PRE: mask indices are all different
+     * @since 2.0
+     */
+    public OptionalInt getFirstOmittedIndex() {
+        ensureIndicesSorted();
+        int column = 0; 
+        while (column < getSize() && indicesSorted[column] == column) column++;
+        if (column < getSourceWidth()) return OptionalInt.of(column);
+        else return OptionalInt.empty();
+    }
+
+
+    /**
+     * Returns a selected masked value from the selected tuple.
+     * @pre: 0 <= index < getSize() 
+     * @since 1.7
+     */
+    public Object getValue(ITuple original, int index) {
+        return original.get(indices[index]);
+    }
+    
+    /**
+     * Sets the selected value in the original tuple based on the mask definition
+     * 
+     * @pre: 0 <= index < getSize()
+     * @since 1.7
+     */
+    public void set(IModifiableTuple tuple, int index, Object value) {
+        tuple.set(indices[index], value);
+    }
+    
+    /**
+     * Generates an immutable, masked view of the original tuple.
+     * <p> The new tuple will have arity {@link #getSize()}, 
+     *  and will consist of the elements of the original tuple, at positions indicated by this mask.
+     * @since 1.7
+     */
+    public Tuple transform(ITuple original) {
+        switch (indices.length) {
+        case 0:
+            return FlatTuple0.INSTANCE;
+        case 1:
+            return new FlatTuple1(original.get(indices[0]));
+        case 2:
+            return new FlatTuple2(original.get(indices[0]), original.get(indices[1]));
+        case 3:
+            return new FlatTuple3(original.get(indices[0]), original.get(indices[1]), original.get(indices[2]));
+        case 4:
+            return new FlatTuple4(original.get(indices[0]), original.get(indices[1]), original.get(indices[2]), original.get(indices[3]));
+        default:
+            Object signature[] = new Object[indices.length];
+            for (int i = 0; i < indices.length; ++i)
+                signature[i] = original.get(indices[i]);
+            return new FlatTuple(signature);
+        }
+    }
+    
+    /**
+     * @return true iff no two selected indices are the same
+     * @since 2.0
+     */
+    public boolean isNonrepeating() {
+        if (isNonrepeating == null) {
+            ensureIndicesSorted();
+            int previous = -1;
+            int i;
+            for (i = 0; i < sourceWidth && previous != indicesSorted[i]; ++i) {
+                previous = indicesSorted[i];
+            }
+            isNonrepeating = (i == sourceWidth); // if not, stopped due to detected repetition
+        }
+        return isNonrepeating;
+    }
+    
+    /**
+     * Returns a tuple `result` that satisfies `this.transform(result).equals(masked)`. Positions of the result tuple
+     * that are not determined this way will be filled with null.
+     * 
+     * @pre: all indices of the mask must be different, i.e {@link #isNonrepeating()} must return true
+     * @since 1.7
+     */
+    public Tuple revertFrom(ITuple masked) {
+        Object[] signature = new Object[sourceWidth];
+        for (int i = 0; i < indices.length; ++i)
+            signature[indices[i]] = masked.get(i);
+        return Tuples.flatTupleOf(signature);
+    }
+    
+    /**
+     * Returns a tuple `result`, same arity as the original tuple, that satisfies 
+     *   `this.transform(result).equals(this.transform(tuple))`. 
+     * Positions of the result tuple that are not determined this way will be filled with null. 
+     * <p> In other words, a copy of the original tuple is returned, 
+     *   with null substituted at each position that is <em>not</em> selected by this mask.
+     * 
+     * @pre: all indices of the mask must be different, i.e {@link #isNonrepeating()} must return true
+     * @since 2.1
+     */
+    public Tuple keepSelectedIndices(ITuple original) {
+        Object[] signature = new Object[sourceWidth];
+        for (int i = 0; i < indices.length; ++i)
+            signature[indices[i]] = original.get(indices[i]);
+        return Tuples.flatTupleOf(signature);
+    }
+
+    /**
+     * Generates an immutable, masked view of the original tuple.
+     * <p> The list will have arity {@link #getSize()}, 
+     *  and will consist of the elements of the original tuple, at positions indicated by this mask.
+     */
+    public <T> List<T> transform(List<T> original) {
+        List<T> signature = new ArrayList<T>(indices.length);
+        for (int i = 0; i < indices.length; ++i)
+            signature.add(original.get(indices[i]));
+        return signature;
+    }
+
+    /**
+     * Transforms a given mask directly, instead of transforming tuples that were transformed by the other mask.
+     * 
+     * @return a mask that cascades the effects this mask after the mask provided as parameter.
+     */
+    public TupleMask transform(TupleMask mask) {
+        int[] cascadeIndices = new int[indices.length];
+        for (int i = 0; i < indices.length; ++i)
+            cascadeIndices[i] = mask.indices[indices[i]];
+        return fromSelectedIndicesInternal(cascadeIndices, mask.sourceWidth, null, null);
+    }
+
+    // /**
+    // * Generates a complementer mask that maps those elements that were
+    // untouched by the original mask.
+    // * Ordering is left intact.
+    // * A Tuple is used for reference concerning possible equalities among
+    // elements.
+    // */
+    // public TupleMask complementer(Tuple reference)
+    // {
+    // HashSet<Object> touched = new HashSet<Object>();
+    // LinkedList<Integer> untouched = new LinkedList<Integer>();
+    //
+    // for (int index : indices) touched.add(reference.get(index));
+    // for (int index=0; index<reference.getSize(); ++index)
+    // {
+    // if (touched.add(reference.get(index))) untouched.addLast(index);
+    // }
+    //
+    // int[] complementer = new int[untouched.size()];
+    // int k = 0;
+    // for (Integer integer : untouched) complementer[k++] = integer;
+    // return new TupleMask(complementer, reference.getSize());
+    // }
+
+    /**
+     * Combines two substitutions. The new pattern will contain all substitutions of masked and unmasked, assuming that
+     * the elements of masked indicated by this mask are already matched against unmasked.
+     * 
+     * POST: the result will start with an exact copy of unmasked
+     * 
+     * @param unmasked
+     *            primary pattern substitution that is left intact.
+     * @param masked
+     *            secondary pattern substitution that is transformed to the end of the result.
+     * @param useInheritance
+     *            whether to use inheritance or copy umasked into result instead.
+     * @param asComplementer
+     *            whether this mask maps from the masked Tuple to the tail of the result or to the unmasked one.
+     * @return new pattern that is a combination of unmasked and masked.
+     */
+    public Tuple combine(Tuple unmasked, Tuple masked, boolean useInheritance, boolean asComplementer) {
+
+        int combinedLength = asComplementer ? indices.length : masked.getSize() - indices.length;
+        if (!useInheritance)
+            combinedLength += unmasked.getSize();
+        Object combined[] = new Object[combinedLength];
+
+        int cPos = 0;
+        if (!useInheritance) {
+            for (int i = 0; i < unmasked.getSize(); ++i)
+                combined[cPos++] = unmasked.get(i);
+        }
+
+        if (asComplementer) {
+            for (int i = 0; i < indices.length; ++i)
+                combined[cPos++] = masked.get(indices[i]);
+        } else {
+            ensureIndicesSorted();
+            int mPos = 0;
+            for (int i = 0; i < masked.getSize(); ++i)
+                if (mPos < indicesSorted.length && i == indicesSorted[mPos])
+                    mPos++;
+                else
+                    combined[cPos++] = masked.get(i);
+        }
+
+        return useInheritance ? Tuples.leftInheritanceTupleOf(unmasked, combined) : Tuples.flatTupleOf(combined);
+    }
+
+    @Override
+    public int hashCode() {
+        final int PRIME = 31;
+        int result = sourceWidth;
+        for (int i : indices)
+            result = PRIME * result + i;
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        final TupleMask other = (TupleMask) obj;
+        if (sourceWidth != other.sourceWidth)
+            return false;
+        if (indices.length != other.indices.length)
+            return false;
+        for (int k = 0; k < indices.length; k++)
+            if (indices[k] != other.indices[k])
+                return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder s = new StringBuilder();
+        s.append("M(" + sourceWidth + "->");
+        for (int i : indices) {
+            s.append(i);
+            s.append(',');
+        }
+        s.append(')');
+        return s.toString();
+    }
+    
+    /**
+     * Returns the size of the masked tuples described by this mask
+     * @since 1.7 
+     */
+    public int getSize() {
+        return indices.length;
+    }
+
+    /**
+     * Returns the size of the original tuples handled by this mask
+     * @since 1.7
+     */
+    public int getSourceWidth() {
+        return sourceWidth;
+    }
+    
+    
+    /**
+     * @return true iff this mask is a no-op
+     * @since 2.0
+     */
+    public boolean isIdentity() {
+        // Contract: if identity mask, a specialized subclass is constructed instead 
+        return false;
+    }
+    
+    /**
+     * Transforms the given list by applying the mask and putting all results into a set; keeping only a single element
+     * in case of the mapping result in duplicate values.
+     * 
+     * @since 1.7
+     */
+    public <T> Set<T> transformUnique(List<T> original) {
+        Set<T> signature = new HashSet<>();
+        for (int i = 0; i < indices.length; ++i)
+            signature.add(original.get(indices[i]));
+        return signature;
+    }
+
+    /**
+     * @return the list of selected indices
+     * @since 2.1
+     */
+    public List<Integer> getIndicesAsList() {
+        List<Integer> result = new ArrayList<Integer>(indices.length);
+        for (int i = 0; i < indices.length; ++i)
+            result.add(indices[i]);
+        return result;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask0.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask0.java
new file mode 100644
index 00000000..5a0c79ff
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask0.java
@@ -0,0 +1,56 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class TupleMask0 extends TupleMask {
+    
+    private final static int[] EMPTY_ARRAY = {};
+
+    /**
+     * PRE: indices.length == 0
+     */
+    TupleMask0(int sourceWidth) {
+        super(EMPTY_ARRAY, sourceWidth, EMPTY_ARRAY, true);
+    }
+    
+    @Override
+    public <T> List<T> transform(List<T> original) {
+        return Collections.emptyList();
+    }
+    
+    @Override
+    public Tuple transform(ITuple original) {
+        return Tuples.staticArityFlatTupleOf();
+    }
+
+    @Override
+    public TupleMask transform(TupleMask mask) {
+        return new TupleMask0(mask.sourceWidth);
+    }
+
+    @Override
+    public Tuple combine(Tuple unmasked, Tuple masked, boolean useInheritance, boolean asComplementer) {
+        if (asComplementer)
+            return unmasked;
+        else
+            return super.combine(unmasked, masked, useInheritance, asComplementer);
+    }
+    
+    @Override
+    public boolean isIdentity() {
+        return 0 == sourceWidth;
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMaskIdentity.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMaskIdentity.java
new file mode 100644
index 00000000..62746587
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMaskIdentity.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.List;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public final class TupleMaskIdentity extends TupleMask {
+
+    TupleMaskIdentity(int sourceWidth) {
+        this(constructLinearSequence(sourceWidth), sourceWidth);
+    }
+    TupleMaskIdentity(int[] indices, int sourceWidth) {
+        super(indices, sourceWidth, indices, true);
+    }
+
+    @Override
+    public <T> List<T> transform(List<T> original) {
+        return original;
+    }
+    
+    @Override
+    public Tuple transform(ITuple original) {
+        return original.toImmutable();
+    }
+    
+    @Override
+    public TupleMask transform(TupleMask mask) {
+        return mask;
+    }
+
+    @Override
+    public Tuple revertFrom(ITuple masked) {
+        return masked.toImmutable();
+    }
+    
+    @Override
+    public boolean isIdentity() {
+        return true;
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleValueProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleValueProvider.java
new file mode 100644
index 00000000..79193516
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleValueProvider.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.psystem.IValueProvider;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ */
+public class TupleValueProvider implements IValueProvider {
+
+    final ITuple tuple;
+    final Map<String, Integer> indexMapping;
+    
+    /**
+     * Wraps a tuple with an index mapping
+     * @param tuple
+     * @param indexMapping
+     */
+    public TupleValueProvider(ITuple tuple, Map<String, Integer> indexMapping) {
+        super();
+        this.tuple = tuple;
+        this.indexMapping = indexMapping;
+    }
+
+    @Override
+    public Object getValue(String variableName) {
+        Integer index = indexMapping.get(variableName);
+        if (index == null) {
+            throw new IllegalArgumentException(String.format("Variable %s is not present in mapping.", variableName));
+        }
+        Object value = tuple.get(index);
+        if (value == null) {
+            throw new IllegalArgumentException(String.format("Variable %s is not found using index %d.", variableName, index));
+        }
+        return value;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuples.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuples.java
new file mode 100644
index 00000000..5e41d7d8
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuples.java
@@ -0,0 +1,157 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Common static factory utilities for tuples.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public class Tuples {
+
+    private Tuples() {
+        // Empty utility class constructor
+    }
+    
+    /**
+     * Creates a flat tuple consisting of the given elements. 
+     * For low-arity tuples, specialized implementations 
+     * (such as {@link FlatTuple2}) will be instantiated.
+     * 
+     * <p> In case the exact arity is <i>statically</i> known, 
+     * it may be more efficient for the client to instantiate 
+     * the appropriate specialized implementation 
+     * (via {@link #staticArityFlatTupleOf(Object, Object)} etc.
+     * or {@link #wideFlatTupleOf(Object...)}),
+     * instead of invoking this method. 
+     * This method does a runtime arity check, and therefore 
+     * also appropriate if the arity is determined at runtime. 
+     */
+    public static Tuple flatTupleOf(Object... elements) {
+        switch (elements.length) {
+        case 0:
+            return FlatTuple0.INSTANCE;
+        case 1:
+            return new FlatTuple1(elements[0]);
+        case 2:
+            return new FlatTuple2(elements[0], elements[1]);
+        case 3:
+            return new FlatTuple3(elements[0], elements[1], elements[2]);
+        case 4:
+            return new FlatTuple4(elements[0], elements[1], elements[2], elements[3]);
+        default:
+            return new FlatTuple(elements);
+        }
+    }
+    /**
+     * Creates a left inheritance tuple that extends an ancestor tuple 
+     *  by the given "local" elements. 
+     * For locally low-arity tuples, specialized implementations 
+     * (such as {@link LeftInheritanceTuple2}) will be instantiated.
+     * 
+     * <p> In case the exact arity is <i>statically</i> known, 
+     * it may be more efficient for the client to instantiate 
+     * the appropriate specialized implementation 
+     * (via {@link #staticArityLeftInheritanceTupleOf(Object, Object)} etc.
+     * or {@link #wideLeftInheritanceTupleOf(Object...)}),
+     * instead of invoking this method. 
+     * This method does a runtime arity check, and therefore 
+     * also appropriate if the arity is determined at runtime. 
+     */
+    public static Tuple leftInheritanceTupleOf(Tuple ancestor, Object... localElements) {
+        switch (localElements.length) {
+        case 0:
+            return ancestor;
+        case 1:
+            return new LeftInheritanceTuple1(ancestor, localElements[0]);
+        case 2:
+            return new LeftInheritanceTuple2(ancestor, localElements[0], localElements[1]);
+        case 3:
+            return new LeftInheritanceTuple3(ancestor, localElements[0], localElements[1], localElements[2]);
+        case 4:
+            return new LeftInheritanceTuple4(ancestor, localElements[0], localElements[1], localElements[2], localElements[3]);
+        default:
+            return new LeftInheritanceTuple(ancestor, localElements);
+        }
+    }
+
+    /**
+     * Creates a flat tuple consisting of no elements. 
+     */
+    public static Tuple staticArityFlatTupleOf() {
+        return FlatTuple0.INSTANCE;
+    }
+    /**
+     * Creates a flat tuple consisting of the given single element. 
+     */
+    public static Tuple staticArityFlatTupleOf(Object element) {
+        return new FlatTuple1(element);
+    }
+    /**
+     * Creates a flat tuple consisting of the given elements. 
+     */
+    public static Tuple staticArityFlatTupleOf(Object element0, Object element1) {
+        return new FlatTuple2(element0, element1);
+    }
+    /**
+     * Creates a flat tuple consisting of the given elements. 
+     */
+    public static Tuple staticArityFlatTupleOf(Object element0, Object element1, Object element2) {
+        return new FlatTuple3(element0, element1, element2);
+    }
+    /**
+     * Creates a flat tuple consisting of the given elements. 
+     */
+    public static Tuple staticArityFlatTupleOf(Object element0, Object element1, Object element2, Object element3) {
+        return new FlatTuple4(element0, element1, element2, element3);
+    }
+    /**
+     * Creates a flat tuple consisting of the given elements. 
+     * <p> Invoke this only if it is statically known that the tuple will be wide. 
+     * Otherwise, use {@link #flatTupleOf(Object...)}.
+     */
+    public static Tuple wideFlatTupleOf(Object... elements) {
+        return new FlatTuple(elements);
+    }
+    
+    /**
+     * Creates a left inheritance tuple consisting of the given single local element. 
+     */
+    public static Tuple staticArityLeftInheritanceTupleOf(Tuple ancestor, Object element) {
+        return new LeftInheritanceTuple1(ancestor, element);
+    }
+    /**
+     * Creates a left inheritance tuple consisting of the given local elements. 
+     */
+    public static Tuple staticArityLeftInheritanceTupleOf(Tuple ancestor, Object element0, Object element1) {
+        return new LeftInheritanceTuple2(ancestor, element0, element1);
+    }
+    /**
+     * Creates a left inheritance tuple consisting of the given local elements. 
+     */
+    public static Tuple staticArityLeftInheritanceTupleOf(Tuple ancestor, Object element0, Object element1, Object element2) {
+        return new LeftInheritanceTuple3(ancestor, element0, element1, element2);
+    }
+    /**
+     * Creates a left inheritance tuple consisting of the given local elements. 
+     */
+    public static Tuple staticArityLeftInheritanceTupleOf(Tuple ancestor, Object element0, Object element1, Object element2, Object element3) {
+        return new LeftInheritanceTuple4(ancestor, element0, element1, element2, element3);
+    }
+    /**
+     * Creates a left inheritance tuple consisting of the given local elements. 
+     * <p> Invoke this only if it is statically known that the tuple will be wide. 
+     * Otherwise, use {@link #leftInheritanceTupleOf(Tuple, Object...)}.
+     */
+    public static Tuple wideLeftInheritanceTupleOf(Tuple ancestor, Object... elements) {
+        return new LeftInheritanceTuple(ancestor, elements);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileMaskedTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileMaskedTuple.java
new file mode 100644
index 00000000..f683d544
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileMaskedTuple.java
@@ -0,0 +1,50 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * This class provides a volatile tuple view with a given mask of a given tuple instance. If the masked tuple changes,
+ * the view updates as well.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public class VolatileMaskedTuple extends VolatileTuple {
+
+    protected final TupleMask mask;
+    protected ITuple source;
+
+    public VolatileMaskedTuple(ITuple source, TupleMask mask) {
+        this.source = source;
+        this.mask = mask;
+    }
+
+    public VolatileMaskedTuple(TupleMask mask) {
+        this(null, mask);
+    }
+    
+    public void updateTuple(ITuple newSource) {
+        source = newSource;
+    }
+    
+    @Override
+    public Object get(int index) {
+        Preconditions.checkState(source != null, "Source tuple is not set."); 
+        return mask.getValue(source, index);
+    }
+
+    @Override
+    public int getSize() {
+        return mask.getSize();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileModifiableMaskedTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileModifiableMaskedTuple.java
new file mode 100644
index 00000000..92306c6e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileModifiableMaskedTuple.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+
+/**
+ * A masked tuple implementation that allows modifying the backing tuple.
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ *
+ */
+public class VolatileModifiableMaskedTuple extends VolatileMaskedTuple implements IModifiableTuple {
+
+    private IModifiableTuple modifiableTuple;
+
+    public VolatileModifiableMaskedTuple(IModifiableTuple source, TupleMask mask) {
+        super(source, mask);
+        modifiableTuple = source;
+    }
+
+    public VolatileModifiableMaskedTuple(TupleMask mask) {
+        this(null, mask);
+    }
+    
+    @Override
+    public void updateTuple(ITuple newSource) {
+        Preconditions.checkArgument(newSource instanceof IModifiableTuple, "Provided tuple does not support updates");
+        this.updateTuple((IModifiableTuple)newSource);
+    }
+    
+    public void updateTuple(IModifiableTuple newSource) {
+        super.updateTuple(newSource);
+        modifiableTuple = newSource;
+    }
+
+    @Override
+    public void set(int index, Object value) {
+        mask.set(modifiableTuple, index, value);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileTuple.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileTuple.java
new file mode 100644
index 00000000..699105a5
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileTuple.java
@@ -0,0 +1,47 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017 Zoltan Ujhelyi, IncQuery Labs
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.tuple;
+
+/**
+ * Mutable tuple without explicit modification commands. In practical terms, the values stored in a volatile tuple can
+ * be changed without any notification.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * 
+ */
+public abstract class VolatileTuple extends AbstractTuple {
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof ITuple))
+            return false;
+        final ITuple other = (ITuple) obj;
+        return internalEquals(other);
+    }
+
+    @Override
+    public int hashCode() {
+        return doCalcHash();
+    }
+
+    /**
+     * Creates an immutable tuple from the values stored in the tuple. The created tuple will not be updated when the
+     * current tuple changes.
+     */
+    @Override
+    public Tuple toImmutable() {
+        return Tuples.flatTupleOf(getElements());
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Accuracy.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Accuracy.java
new file mode 100644
index 00000000..338990ab
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Accuracy.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * The degree of accuracy of a cardinality estimate
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public enum Accuracy {
+    EXACT_COUNT,
+    BEST_UPPER_BOUND,
+    BEST_LOWER_BOUND,
+    APPROXIMATION;
+    
+    /**
+     * Partial order comparison.
+     */
+    public boolean atLeastAsPreciseAs(Accuracy other) {
+        switch (this) {
+        case EXACT_COUNT: return true;
+        case APPROXIMATION: return APPROXIMATION == other;
+        case BEST_UPPER_BOUND: return BEST_UPPER_BOUND == other || APPROXIMATION == other; 
+        case BEST_LOWER_BOUND: return BEST_LOWER_BOUND == other || APPROXIMATION == other; 
+        default: throw new IllegalArgumentException();
+        }
+    }
+    
+    /**
+     * @return another accuracy value that is anti-monotonic to this one, 
+     * i.e. an accuracy that should be used in the denominator to obtain a fraction with this accuracy
+     */
+    public Accuracy reciprocal() {
+        switch(this) {
+        case APPROXIMATION: return APPROXIMATION;
+        case BEST_UPPER_BOUND: return BEST_LOWER_BOUND;
+        case BEST_LOWER_BOUND: return BEST_UPPER_BOUND;
+        case EXACT_COUNT: return EXACT_COUNT;
+        default: throw new IllegalArgumentException();
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Clearable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Clearable.java
new file mode 100644
index 00000000..1b09aec6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Clearable.java
@@ -0,0 +1,23 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ *         An instance of clearable pattern memory.
+ */
+public interface Clearable {
+    /**
+     * Clear all partial matchings stored in memory
+     * 
+     */
+    void clear();
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/CollectionsFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/CollectionsFactory.java
new file mode 100644
index 00000000..590a1ec3
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/CollectionsFactory.java
@@ -0,0 +1,188 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.function.Function;
+
+/**
+ * Factory class used as an accessor to Collections implementations. 
+ * @author istvanrath
+ */
+public final class CollectionsFactory
+{
+    
+    /**
+     * Instantiates a new empty map.
+     * @since 1.7
+     */
+    public static <K, V> Map<K, V> createMap() {
+        return FRAMEWORK.createMap();
+    }
+
+    /**
+     * Instantiates a new map with the given initial contents.
+     * @since 1.7
+     */
+    public static <K, V> Map<K, V> createMap(Map<K, V> initial) {
+        return FRAMEWORK.createMap(initial);
+    }
+    
+    /**
+     * Instantiates a new tree map. 
+     * @since 2.3
+     */
+    public static <K, V> TreeMap<K, V> createTreeMap() {
+        return FRAMEWORK.createTreeMap();
+    }
+    
+    /**
+     * Instantiates a new empty set.
+     * @since 1.7
+     */
+    public static <E> Set<E> createSet() {
+        return FRAMEWORK.createSet();
+    }
+
+    /**
+     * Instantiates a new set with the given initial contents.
+     * @since 1.7
+     */
+    public static <E> Set<E> createSet(Collection<E> initial) {
+        return FRAMEWORK.createSet(initial);
+    }
+
+    /**
+     * Instantiates an empty set; the key parameter is used to allow using this as a method reference as a
+     * {@link Function}, e.g. in {@link Map#computeIfAbsent(Object, Function)}.
+     * 
+     * @param key
+     *            the value of this parameter is ignored
+     * @since 2.0
+     */
+    public static <T> Set<T> emptySet(Object key) {
+        return FRAMEWORK.createSet();
+    }
+
+    /**
+     * Instantiates a new empty multiset.
+     * @since 1.7
+     */
+    public static <T> IMultiset<T> createMultiset() {
+        return FRAMEWORK.createMultiset();
+    }
+
+    /**
+     * Instantiates an empty multiset; the key parameter is used to allow using this as a method reference as a
+     * {@link Function}, e.g. in {@link Map#computeIfAbsent(Object, Function)}.
+     * 
+     * @param key
+     *            the value of this parameter is ignored
+     * @since 2.0
+     */
+    public static <T> IMultiset<T> emptyMultiset(Object key) {
+        return FRAMEWORK.createMultiset();
+    }
+    
+    /**
+     * Instantiates a new empty delta bag.
+     * @since 1.7
+     */
+    public static <T> IDeltaBag<T> createDeltaBag() {
+        return FRAMEWORK.createDeltaBag();
+    }
+
+    /**
+     * Instantiates a new list that is optimized for registering observers / callbacks.
+     * @since 1.7
+     */
+    public static <O> List<O> createObserverList() {
+        return FRAMEWORK.createObserverList();
+    }
+    
+    /**
+     * Instantiates a size-optimized multimap from keys to sets of values.
+     * <p>For a single key, many values can be associated according to the given bucket semantics.
+     * <p>The keys and values are stored as type fromKeys resp. ofValues; 
+     *  currently Object.class and Long.class are supported.
+     * @since 2.0
+     */
+    public static <K, V> IMultiLookup<K, V> createMultiLookup(
+            Class<? super K> fromKeys, MemoryType toBuckets, Class<? super V> ofValues) {
+        return FRAMEWORK.createMultiLookup(fromKeys, toBuckets, ofValues);
+    }
+    
+    /**
+     * Instantiates a memory storing values.
+     * <p>For a single key, many values can be associated according to the given memory semantics.
+     * <p>The values are stored as type 'values'; 
+     *  currently Object.class and Long.class are supported.
+     * @since 2.0
+     */
+    public static <T> IMemory<T> createMemory(
+            Class<? super T> values, MemoryType memoryType) {
+        return FRAMEWORK.createMemory(values, memoryType);
+    }
+    
+   /**
+    * The type of {@link IMemory}
+     * @since 2.0
+     * TODO add delta as type
+     */
+   public enum MemoryType {
+       /**
+        * A single key-value pair is stored at most once
+        */
+       SETS,
+       /**
+        * Duplicate key-value pairs allowed
+        */
+       MULTISETS
+   }
+   
+    /**
+     * The collections framework of the current configuration.
+     * @since 1.7
+     */
+    private static final ICollectionsFramework FRAMEWORK = new EclipseCollectionsFactory();
+    
+    /**
+     * Interface abstracting over a collections technology that provides custom collection implementations.
+     * @since 1.7
+     */
+    public static interface ICollectionsFramework {
+        
+        public abstract <K,V> Map<K,V> createMap();
+        public abstract <K,V> Map<K,V> createMap(Map<K,V> initial);
+        /**
+         * @since 2.3
+         */
+        public abstract <K, V> TreeMap<K, V> createTreeMap();
+        public abstract <E> Set<E> createSet();
+        public abstract <E> Set<E> createSet(Collection<E> initial);
+        public abstract <T> IMultiset<T> createMultiset();
+        public abstract <T> IDeltaBag<T> createDeltaBag();
+        public abstract <O> List<O> createObserverList();
+        
+        /**
+         * @since 2.0
+         */
+        public abstract <K, V> IMultiLookup<K, V> createMultiLookup(
+                Class<? super K> fromKeys, MemoryType toBuckets, Class<? super V> ofValues);
+        /**
+         * @since 2.0
+         */
+        public abstract <T> IMemory<T> createMemory(Class<? super T> values, MemoryType memoryType);
+    }
+                
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Direction.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Direction.java
new file mode 100644
index 00000000..88f7ec00
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Direction.java
@@ -0,0 +1,61 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * Indicates whether a propagated update event signals the insertion or deletion of an element
+ * 
+ * @author Gabor Bergmann
+ */
+public enum Direction {
+    INSERT, DELETE;
+
+    /**
+     * @since 2.4
+     */
+    public Direction opposite() {
+        switch (this) {
+        case INSERT:
+            return DELETE;
+        default:
+            return INSERT;
+        }
+    }
+
+    /**
+     * @since 2.4
+     */
+    public char asSign() {
+        switch (this) {
+        case INSERT:
+            return '+';
+        default:
+            return '-';
+        }
+    }
+    
+    /**
+     * Returns the direction that is the product of this direction and the other direction.
+     *  
+     * DELETE x DELETE = INSERT
+     * DELETE x INSERT = DELETE
+     * INSERT x DELETE = DELETE
+     * INSERT x INSERT = INSERT 
+     * @since 2.4
+     */
+    public Direction multiply(final Direction other) {
+        switch (this) {
+        case DELETE:
+            return other.opposite();
+        default:
+            return other;
+        }
+    }
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsBagMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsBagMemory.java
new file mode 100644
index 00000000..e24b2448
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsBagMemory.java
@@ -0,0 +1,86 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2008 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.function.BiConsumer;
+
+import org.eclipse.collections.impl.map.mutable.primitive.ObjectIntHashMap;
+
+/**
+ * Eclipse Collections-based multiset for tuples. Can contain duplicate occurrences of the same matching.
+ * 
+ * <p>Inherits Eclipse Collections' Object-to-Int primitive hashmap and counts the number of occurrences of each value. 
+ * Element is deleted if # of occurences drops to 0.
+ * 
+ * @author Gabor Bergmann.
+ * @since 1.7
+ * @noreference
+ */
+public abstract class EclipseCollectionsBagMemory<T> extends ObjectIntHashMap<T> implements IMemory<T> {
+
+    public EclipseCollectionsBagMemory() {
+        super();
+    }
+
+    @Override
+    public int getCount(T value) {
+        return super.getIfAbsent(value, 0);
+    }
+    @Override
+    public int getCountUnsafe(Object value) {
+        return super.getIfAbsent(value, 0);
+    }
+    @Override
+    public boolean containsNonZero(T value) {
+        return super.containsKey(value);
+    }
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return super.containsKey(value);
+    }
+
+    @Override
+    public void clearAllOf(T value) {
+        super.remove(value);
+    }
+
+
+    @Override
+    public Iterator<T> iterator() {
+        return super.keySet().iterator();
+    }
+
+    @Override
+    public String toString() {
+        return "TM" + super.toString();
+    }
+    
+    @Override
+    public Set<T> distinctValues() {
+        return super.keySet();
+    }
+
+    @Override
+    public void forEachEntryWithMultiplicities(BiConsumer<T, Integer> entryConsumer) {
+        super.forEachKeyValue(entryConsumer::accept);
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsDeltaBag.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsDeltaBag.java
new file mode 100644
index 00000000..94ec33cd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsDeltaBag.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public class EclipseCollectionsDeltaBag<T> extends EclipseCollectionsBagMemory<T> implements IDeltaBag<T> {
+    
+    @Override
+    public boolean addOne(T value) {
+        return addSigned(value, +1);
+    }
+    
+    @Override
+    public boolean addSigned(T value, int count) {
+        int oldCount = super.getIfAbsent(value, 0);
+        int newCount = oldCount + count;
+        
+        boolean becomesZero = newCount == 0;
+        if (becomesZero)
+            super.removeKey(value);
+        else 
+            super.put(value, newCount);
+       
+        return becomesZero || oldCount == 0;
+    }
+    
+    
+    @Override
+    public boolean removeOne(T value) {
+        return addSigned(value, -1);
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsFactory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsFactory.java
new file mode 100644
index 00000000..5a623c9b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsFactory.java
@@ -0,0 +1,159 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+import org.eclipse.collections.api.map.MutableMap;
+import org.eclipse.collections.impl.factory.Maps;
+import org.eclipse.collections.impl.factory.Sets;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.ICollectionsFramework;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class EclipseCollectionsFactory implements ICollectionsFramework {
+
+    @Override
+    public <K, V> Map<K, V> createMap() {
+        return Maps.mutable.empty();
+    }
+    
+    @Override
+    public <K, V> Map<K, V> createMap(Map<K, V> initial) {
+        MutableMap<K, V> result = Maps.mutable.ofInitialCapacity(initial.size());
+        result.putAll(initial);
+        return result;
+    }
+    
+    @Override
+    public <K, V> TreeMap<K, V> createTreeMap() {
+        // eclipse collections is doing the same
+        return new TreeMap<>();
+    }
+
+    @Override
+    public <E> Set<E> createSet() {
+        return Sets.mutable.empty();
+    }
+
+    @Override
+    public <E> Set<E> createSet(Collection<E> initial) {
+        return Sets.mutable.ofAll(initial);
+    }
+    
+    @Override
+    public <T> IMultiset<T> createMultiset() {
+        return new EclipseCollectionsMultiset<T>();
+    }
+    
+    @Override
+    public <T> IDeltaBag<T> createDeltaBag() {
+        return new EclipseCollectionsDeltaBag<T>();
+    }
+    
+    @Override
+    public <O> List<O> createObserverList() {
+        return new ArrayList<O>(1); // keep concurrent modification exceptions for error detection
+        // Lists.mutable.empty
+
+    }
+    
+    @Override
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public <K, V> IMultiLookup<K, V> createMultiLookup(
+            Class<? super K> fromKeys, 
+            MemoryType toBuckets,
+            Class<? super V> ofValues) 
+    {
+        boolean longKeys = Long.class.equals(fromKeys);
+        boolean objectKeys = Object.class.equals(fromKeys);
+        if (! (longKeys || objectKeys)) throw new IllegalArgumentException(fromKeys.getName());
+        boolean longValues = Long.class.equals(ofValues);
+        boolean objectValues = Object.class.equals(ofValues);
+        if (! (longValues || objectValues)) throw new IllegalArgumentException(ofValues.getName());
+        
+        if (longKeys) { // K == java.lang.Long
+            if (longValues) { // V == java.lang.Long
+                switch(toBuckets) {
+                case MULTISETS:
+                    return (IMultiLookup<K, V>) new EclipseCollectionsMultiLookup.FromLongs.ToMultisets.OfLongs();
+                case SETS:
+                    return (IMultiLookup<K, V>) new EclipseCollectionsMultiLookup.FromLongs.ToSets.OfLongs();
+                default:
+                    throw new IllegalArgumentException(toBuckets.toString());
+                }
+            } else { // objectValues
+                switch(toBuckets) {
+                case MULTISETS:
+                    return new EclipseCollectionsMultiLookup.FromLongs.ToMultisets.OfObjects();
+                case SETS:
+                    return new EclipseCollectionsMultiLookup.FromLongs.ToSets.OfObjects();
+                default:
+                    throw new IllegalArgumentException(toBuckets.toString());
+                }
+            }
+        } else { // objectKeys
+            if (longValues) { // V == java.lang.Long
+                switch(toBuckets) {
+                case MULTISETS:
+                    return new EclipseCollectionsMultiLookup.FromObjects.ToMultisets.OfLongs();
+                case SETS:
+                    return new EclipseCollectionsMultiLookup.FromObjects.ToSets.OfLongs();
+                default:
+                    throw new IllegalArgumentException(toBuckets.toString());
+                }
+            } else { // objectValues
+                switch(toBuckets) {
+                case MULTISETS:
+                    return new EclipseCollectionsMultiLookup.FromObjects.ToMultisets.OfObjects();
+                case SETS:
+                    return new EclipseCollectionsMultiLookup.FromObjects.ToSets.OfObjects();
+                default:
+                    throw new IllegalArgumentException(toBuckets.toString());
+                }
+            }
+        }
+    }
+    
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> IMemory<T> createMemory(Class<? super T> values, MemoryType memoryType) {
+        if (Long.class.equals(values)) { // T == java.lang.Long
+            switch(memoryType) {
+            case MULTISETS:
+                return (IMemory<T>) new EclipseCollectionsLongMultiset();
+            case SETS:
+                return (IMemory<T>) new EclipseCollectionsLongSetMemory();
+            default:
+                throw new IllegalArgumentException(memoryType.toString());
+            }
+        } else { // objectValues
+            switch(memoryType) {
+            case MULTISETS:
+                return new EclipseCollectionsMultiset<>();
+            case SETS:
+                return new EclipseCollectionsSetMemory<>();
+            default:
+                throw new IllegalArgumentException(memoryType.toString());
+            }
+        }
+    }
+    
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongMultiset.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongMultiset.java
new file mode 100644
index 00000000..88773c5d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongMultiset.java
@@ -0,0 +1,150 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.function.BiConsumer;
+
+import org.eclipse.collections.impl.map.mutable.primitive.LongIntHashMap;
+
+/**
+ * @author Gabor Bergmann
+ * @since 2.0
+ * <p> TODO refactor common methods with {@link EclipseCollectionsMultiset}
+ * <p> TODO refactor into LongBagMemory etc.
+ */
+public class EclipseCollectionsLongMultiset extends LongIntHashMap implements IMultiset<Long> {
+
+    @Override
+    public boolean addOne(Long value) {
+        int oldCount = super.getIfAbsent(value, 0);
+
+        super.put(value, oldCount + 1);
+
+        return oldCount == 0;
+    }
+
+    @Override
+    public boolean addSigned(Long value, int count) {
+        int oldCount = super.getIfAbsent(value, 0);
+        int newCount = oldCount + count;
+        
+        boolean becomesZero = newCount == 0;
+        if (newCount < 0)
+            throw new IllegalStateException(String.format(
+                    "Cannot remove %d occurrences of value '%s' as only %d would remain in %s", 
+                    count, value, newCount, this));
+        else if (becomesZero)
+            super.removeKey(value);
+        else // (newCount > 0)
+            super.put(value, newCount);
+       
+        return becomesZero || oldCount == 0;
+    }
+
+    @Override
+    public boolean removeOne(Long value) {
+        return removeOneInternal(value, true);
+    }
+    /**
+     * @since 2.3
+     */
+    @Override
+    public boolean removeOneOrNop(Long value) {
+        return removeOneInternal(value, false);
+    }
+    
+    
+    /**
+     * @since 2.3
+     */
+    protected boolean removeOneInternal(Long value, boolean throwIfImpossible) {
+        int oldCount = super.getIfAbsent(value, 0);
+        if (oldCount == 0) {
+            if (throwIfImpossible) throw new IllegalStateException(String.format(
+                    "Cannot remove value '%s' that is not contained in %s", 
+                    value, this));
+            else return false;
+        }
+        
+        int rest = oldCount - 1;
+        boolean empty = rest == 0;
+
+        if (!empty) {
+            super.put(value, rest);
+        } else {
+            super.remove(value);
+        }
+
+        return empty;
+    }
+
+    @Override
+    public void clearAllOf(Long value) {
+        super.remove(value);
+    }
+
+    @Override
+    public int getCount(Long value) {
+        return super.getIfAbsent(value, 0);
+    }
+    @Override
+    public int getCountUnsafe(Object value) {
+        return value instanceof Long ? getCount((Long) value) : 0;
+    }
+
+    @Override
+    public boolean containsNonZero(Long value) {
+        return super.containsKey(value);
+    }
+    
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return value instanceof Long && containsNonZero((Long) value);
+    }
+
+    @Override
+    public Iterator<Long> iterator() {
+        return EclipseCollectionsLongSetMemory.iteratorOf(super.keySet());
+    }
+
+    @Override
+    public boolean addPositive(Long value, int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("The count value must be positive!");
+        }
+
+        int oldCount = super.getIfAbsent(value, 0);
+
+        super.put(value, oldCount + count);
+
+        return oldCount == 0;
+    }
+
+    @Override
+    public Set<Long> distinctValues() {
+        return new EclipseCollectionsLongSetMemory.SetWrapper(super.keySet());
+    }
+
+    @Override
+    public void forEachEntryWithMultiplicities(BiConsumer<Long, Integer> entryConsumer) {
+        super.forEachKeyValue(entryConsumer::accept);
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongSetMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongSetMemory.java
new file mode 100644
index 00000000..fceb54fc
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongSetMemory.java
@@ -0,0 +1,212 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Set;
+
+import org.eclipse.collections.api.LongIterable;
+import org.eclipse.collections.api.iterator.LongIterator;
+import org.eclipse.collections.api.set.primitive.LongSet;
+import org.eclipse.collections.impl.set.mutable.primitive.LongHashSet;
+
+/**
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public class EclipseCollectionsLongSetMemory extends LongHashSet implements ISetMemory<Long> {
+
+    @Override
+    public boolean addOne(Long value) {
+        return super.add(value);
+    }
+
+    @Override
+    public boolean addSigned(Long value, int count) {
+        if (count == 1) return addOne(value);
+        else if (count == -1) return removeOne(value); 
+        else throw new IllegalStateException();
+    }
+
+    @Override
+    public boolean removeOne(Long value) {
+        // Kept for binary compatibility
+        return ISetMemory.super.removeOne(value);
+    }
+    
+    /**
+     * @since 2.3
+     */
+    @Override
+    public boolean removeOneOrNop(Long value) {
+        return super.remove(value);
+    }
+
+    @Override
+    public void clearAllOf(Long value) {
+        super.remove(value);
+    }
+
+    @Override
+    public int getCount(Long value) {
+        return super.contains(value) ? 1 : 0;
+    }
+    
+    @Override
+    public int getCountUnsafe(Object value) {
+        return value instanceof Long ? getCount((Long) value) : 0;
+    }
+
+    @Override
+    public boolean containsNonZero(Long value) {
+        return super.contains(value);
+    }
+    
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return value instanceof Long && containsNonZero((Long) value);
+    }
+
+    @Override
+    public Iterator<Long> iterator() {
+        return iteratorOf(this);
+    }
+
+    @Override
+    public Set<Long> distinctValues() {
+        return new SetWrapper(this);
+    }
+    
+    @Override
+    public boolean isEmpty() {
+        return super.isEmpty();
+    }
+    
+    /**
+     * Helper for iterating a LongIterable
+     */
+    public static Iterator<Long> iteratorOf(LongIterable wrapped) {
+        return new Iterator<Long>() {
+            LongIterator longIterator = wrapped.longIterator();
+
+            @Override
+            public boolean hasNext() {
+                return longIterator.hasNext();
+            }
+
+            @Override
+            public Long next() {
+                return longIterator.next();
+            }
+        };
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+
+    
+    /**
+     * Helper that presents a primitive collection as a Set view
+     * @author Gabor Bergmann
+     */
+    public static final class SetWrapper implements Set<Long> {
+        private LongSet wrapped;
+
+        /**
+         * @param wrapped
+         */
+        public SetWrapper(LongSet wrapped) {
+            this.wrapped = wrapped;
+        }
+
+        @Override
+        public int size() {
+            return wrapped.size();
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return wrapped.isEmpty();
+        }
+
+        @Override
+        public boolean contains(Object o) {
+            return o instanceof Long &&  wrapped.contains((Long)o);
+        }
+
+        @Override
+        public Iterator<Long> iterator() {
+            return iteratorOf(wrapped);
+        }
+
+        @Override
+        public boolean containsAll(Collection<?> c) {
+            for (Object object : c) {
+                if (contains(object))
+                    return true;
+            }
+            return false;
+        }
+
+        @Override
+        public Object[] toArray() {
+            return toArray(new Long[wrapped.size()]);
+        }
+
+        @Override
+        @SuppressWarnings("unchecked")
+        public <T> T[] toArray(T[] a) {
+            int k = 0;
+            LongIterator iterator = wrapped.longIterator();
+            while (iterator.hasNext()) 
+                a[k++] = (T) Long.valueOf(iterator.next());
+            return a;
+        }
+
+        @Override
+        public boolean add(Long e) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean remove(Object o) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean addAll(Collection<? extends Long> c) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean retainAll(Collection<?> c) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean removeAll(Collection<?> c) {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public void clear() {
+            throw new UnsupportedOperationException();
+        }
+        
+        
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiLookup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiLookup.java
new file mode 100644
index 00000000..394135c9
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiLookup.java
@@ -0,0 +1,226 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import org.eclipse.collections.impl.map.mutable.UnifiedMap;
+import org.eclipse.collections.impl.map.mutable.primitive.LongObjectHashMap;
+import tools.refinery.viatra.runtime.matchers.util.MarkedMemory.MarkedMultiset;
+import tools.refinery.viatra.runtime.matchers.util.MarkedMemory.MarkedSet;
+
+import java.util.Set;
+import java.util.stream.Stream;
+
+
+
+/**
+ * Eclipse Collections-based realizations of {@link IMultiLookup}
+ *
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+class EclipseCollectionsMultiLookup {
+
+    private EclipseCollectionsMultiLookup() {/* Hidden utility class constructor */}
+
+    private static class MarkedSetImpl<Value> extends EclipseCollectionsSetMemory<Value> implements MarkedMemory.MarkedSet<Value> {}
+    private static class MarkedMultisetImpl<Value> extends EclipseCollectionsMultiset<Value> implements MarkedMemory.MarkedMultiset<Value> {}
+    private static class MarkedLongSetImpl extends EclipseCollectionsLongSetMemory implements MarkedMemory.MarkedSet<Long> {}
+    private static class MarkedLongMultisetImpl extends EclipseCollectionsLongMultiset implements MarkedMemory.MarkedMultiset<Long> {}
+
+    public abstract static class FromObjects<Key, Value, Bucket extends MarkedMemory<Value>>
+        extends UnifiedMap<Key, Object> implements IMultiLookupAbstract<Key, Value, Bucket> {
+
+        @Override
+        public boolean equals(Object obj) {
+            return IMultiLookup.equals(this, obj);
+        }
+        @Override
+        public int hashCode() {
+            return IMultiLookup.hashCode(this);
+        }
+
+
+        @Override
+        public Object lowLevelPutIfAbsent(Key key, Value value) {
+            return super.putIfAbsent(key, value);
+        }
+
+        @Override
+        public Object lowLevelGet(Key key) {
+            return super.get(key);
+        }
+
+        @Override
+        public Object lowLevelGetUnsafe(Object key) {
+            return super.get(key);
+        }
+
+        @Override
+        public Object lowLevelRemove(Key key) {
+            return super.remove(key);
+        }
+
+        @Override
+        public void lowLevelPut(Key key, Object valueOrBucket) {
+            super.put(key, valueOrBucket);
+        }
+        @Override
+        public Iterable<Object> lowLevelValues() {
+            return super.values();
+        }
+        @Override
+        public Set<Key> lowLevelKeySet() {
+            return super.keySet();
+        }
+        @Override
+        public int lowLevelSize() {
+            return super.size();
+        }
+
+        @Override
+        public Stream<Key> distinctKeysStream() {
+            // may be more efficient than the default spliterator
+            return super.keySet().stream();
+        }
+
+        public abstract static class ToSets<Key, Value> extends FromObjects<Key, Value, MarkedSet<Value>>
+            implements IMultiLookupAbstract.ToSetsAbstract<Key, Value>
+        {
+            public static class OfObjects<Key, Value> extends ToSets<Key, Value> {
+                @Override
+                public MarkedSet<Value> createMarkedSet() {
+                    return new MarkedSetImpl<Value>();
+                }
+            }
+
+            public static class OfLongs<Key> extends ToSets<Key, Long> {
+                @Override
+                public MarkedSet<Long> createMarkedSet() {
+                    return new MarkedLongSetImpl();
+                }
+            }
+
+        }
+
+        public abstract static class ToMultisets<Key, Value> extends FromObjects<Key, Value, MarkedMultiset<Value>>
+            implements IMultiLookupAbstract.ToMultisetsAbstract<Key, Value>
+        {
+            public static class OfObjects<Key, Value> extends ToMultisets<Key, Value> {
+                @Override
+                public MarkedMultiset<Value> createMarkedMultiset() {
+                    return new MarkedMultisetImpl<Value>();
+                }
+            }
+
+            public static class OfLongs<Key> extends ToMultisets<Key, Long> {
+                @Override
+                public MarkedMultiset<Long> createMarkedMultiset() {
+                    return new MarkedLongMultisetImpl();
+                }
+            }
+
+        }
+
+    }
+
+    public abstract static class FromLongs<Value, Bucket extends MarkedMemory<Value>>
+    extends LongObjectHashMap<Object> implements IMultiLookupAbstract<Long, Value, Bucket> {
+
+        @Override
+        public boolean equals(Object obj) {
+            return IMultiLookup.equals(this, obj);
+        }
+        @Override
+        public int hashCode() {
+            return IMultiLookup.hashCode(this);
+        }
+
+        @Override
+        public Object lowLevelPutIfAbsent(Long key, Value value) {
+            Object old = super.get(key);
+            if (old == null) super.put(key, value);
+            return old;
+        }
+
+        @Override
+        public Object lowLevelGet(Long key) {
+            return super.get(key);
+        }
+
+        @Override
+        public Object lowLevelGetUnsafe(Object key) {
+            return key instanceof Long ? super.get((Long)key) : null;
+        }
+
+        @Override
+        public Object lowLevelRemove(Long key) {
+            return super.remove(key);
+        }
+
+        @Override
+        public void lowLevelPut(Long key, Object valueOrBucket) {
+            super.put(key, valueOrBucket);
+        }
+        @Override
+        public Iterable<Object> lowLevelValues() {
+            return super.values();
+        }
+        @Override
+        public int lowLevelSize() {
+            return super.size();
+        }
+        @Override
+        public Iterable<Long> lowLevelKeySet() {
+            return () -> EclipseCollectionsLongSetMemory.iteratorOf(FromLongs.super.keysView());
+        }
+
+    public abstract static class ToSets<Value> extends FromLongs<Value, MarkedSet<Value>>
+        implements IMultiLookupAbstract.ToSetsAbstract<Long, Value>
+    {
+        public static class OfObjects<Value> extends ToSets<Value> {
+            @Override
+            public MarkedSet<Value> createMarkedSet() {
+                return new MarkedSetImpl<Value>();
+            }
+        }
+
+        public static class OfLongs extends ToSets<Long> {
+            @Override
+            public MarkedSet<Long> createMarkedSet() {
+                return new MarkedLongSetImpl();
+            }
+        }
+
+    }
+
+    public abstract static class ToMultisets<Value> extends FromLongs<Value, MarkedMultiset<Value>>
+        implements IMultiLookupAbstract.ToMultisetsAbstract<Long, Value>
+    {
+        public static class OfObjects<Value> extends ToMultisets<Value> {
+            @Override
+            public MarkedMultiset<Value> createMarkedMultiset() {
+                return new MarkedMultisetImpl<Value>();
+            }
+        }
+
+        public static class OfLongs extends ToMultisets<Long> {
+            @Override
+            public MarkedMultiset<Long> createMarkedMultiset() {
+                return new MarkedLongMultisetImpl();
+            }
+        }
+
+    }
+
+    }
+
+
+}
+
+
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiset.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiset.java
new file mode 100644
index 00000000..46977c8b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiset.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public class EclipseCollectionsMultiset<T> extends EclipseCollectionsBagMemory<T> implements IMultiset<T> {
+
+    @Override
+    public boolean addOne(T value) {
+        int oldCount = super.getIfAbsent(value, 0);
+
+        super.put(value, oldCount + 1);
+
+        return oldCount == 0;
+    }
+
+    @Override
+    public boolean addPositive(T value, int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException("The count value must be positive!");
+        }
+
+        int oldCount = super.getIfAbsent(value, 0);
+
+        super.put(value, oldCount + count);
+
+        return oldCount == 0;
+    }
+    
+    @Override
+    public boolean addSigned(T value, int count) {
+        int oldCount = super.getIfAbsent(value, 0);
+        int newCount = oldCount + count;
+        
+        boolean becomesZero = newCount == 0;
+        if (newCount < 0)
+            throw new IllegalStateException(String.format(
+                    "Cannot remove %d occurrences of value '%s' as only %d would remain in %s", 
+                    count, value, newCount, this));
+        else if (becomesZero)
+            super.removeKey(value);
+        else // (newCount > 0)
+            super.put(value, newCount);
+       
+        return becomesZero || oldCount == 0;
+    }
+    
+    
+    @Override
+    public boolean removeOne(T value) {
+        return removeOneInternal(value, true);
+    }
+    
+    @Override
+    public boolean removeOneOrNop(T value) {
+        return removeOneInternal(value, false);
+    }
+
+    /**
+     * @since 2.3
+     */
+    protected boolean removeOneInternal(T value, boolean throwIfImpossible) {
+        int oldCount = super.getIfAbsent(value, 0);
+        if (oldCount == 0) {
+            if (throwIfImpossible) throw new IllegalStateException(String.format(
+                    "Cannot remove value '%s' that is not contained in %s", 
+                    value, this));
+            else return false;
+        }
+        
+        int rest = oldCount - 1;
+        boolean empty = rest == 0;
+
+        if (!empty) {
+            super.put(value, rest);
+        } else {
+            super.remove(value);
+        }
+
+        return empty;
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsSetMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsSetMemory.java
new file mode 100644
index 00000000..92f65246
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsSetMemory.java
@@ -0,0 +1,94 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Set;
+
+import org.eclipse.collections.impl.set.mutable.UnifiedSet;
+
+/**
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public class EclipseCollectionsSetMemory<Value> extends UnifiedSet<Value> implements ISetMemory<Value> {
+    @Override
+    public int getCount(Value value) {
+        return super.contains(value) ? 1 : 0;
+    }
+    @Override
+    public int getCountUnsafe(Object value) {
+        return super.contains(value) ? 1 : 0;
+    }
+    @Override
+    public boolean containsNonZero(Value value) {
+        return super.contains(value);
+    }
+    
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return super.contains(value);
+    }
+
+    @Override
+    public boolean addOne(Value value) {
+        return super.add(value);
+    }
+
+    @Override
+    public boolean addSigned(Value value, int count) {
+        if (count == 1) return addOne(value);
+        else if (count == -1) return removeOne(value); 
+        else throw new IllegalStateException();
+    }
+    
+    @Override
+    public boolean removeOne(Value value) {
+        // Kept for binary compatibility
+        return ISetMemory.super.removeOne(value);
+    }
+    
+    @Override
+    public boolean removeOneOrNop(Value value) {
+        return super.remove(value);
+    }
+
+    @Override
+    public void clearAllOf(Value value) {
+        super.remove(value);
+    }
+
+    @Override
+    public Set<Value> distinctValues() {
+        return this;
+    }
+    
+    @Override
+    public Value theContainedVersionOf(Value value) {
+        return super.get(value);
+    }
+    
+    @Override
+    @SuppressWarnings("unchecked")
+    public Value theContainedVersionOfUnsafe(Object value) {
+        if (super.contains(value)) 
+            return super.get((Value)value);
+        else return null;
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EmptyMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EmptyMemory.java
new file mode 100644
index 00000000..a17b3a3f
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/EmptyMemory.java
@@ -0,0 +1,93 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.Set;
+
+/**
+ * A singleton immutable empty memory. 
+ * @author Gabor Bergmann
+ * @since 2.0
+ *
+ */
+public class EmptyMemory<T> implements IMemoryView<T> {
+
+    @SuppressWarnings("rawtypes")
+    private static final EmptyMemory INSTANCE = new EmptyMemory();
+    
+    @SuppressWarnings("unchecked")
+    public static <T> EmptyMemory<T> instance() {
+        return INSTANCE;
+    }
+    
+    
+    
+    /**
+     * Singleton; hidden constructor
+     */
+    private EmptyMemory() {
+        super();
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return Collections.<T>emptySet().iterator();
+    }
+
+    @Override
+    public int getCount(T value) {
+        return 0;
+    }
+
+    @Override
+    public int getCountUnsafe(Object value) {
+        return 0;
+    }
+
+    @Override
+    public boolean containsNonZero(T value) {
+        return false;
+    }
+
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return false;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override
+    public Set<T> distinctValues() {
+        return Collections.emptySet();
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+
+    @Override
+    public String toString() {
+        return "{}";
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ICache.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ICache.java
new file mode 100644
index 00000000..8c2e54ad
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ICache.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.function.Supplier;
+
+/**
+ * A cache is a simple key-value pair that stores calculated values for specific key objects
+ * 
+ * <p>
+ * <b>NOTE</b> These caches are not expected to be used outside query backend implementations 
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * @noreference This interface is not intended to be referenced by clients.
+ */
+public interface ICache {
+
+    /**
+     * Return a selected value for the key object. If the value is not available in the cache yet, the given provider is
+     * called once
+     * @since 2.0
+     */
+    <T> T getValue(Object key, Class<? extends T> clazz, Supplier<T> valueProvider);
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IDeltaBag.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IDeltaBag.java
new file mode 100644
index 00000000..99a4cb3b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IDeltaBag.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * An {@link IMemory} that represents the difference between two states of a set or {@link IMultiset}, and therefore
+ *  may contain values with a negative multiplicity.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public interface IDeltaBag<T> extends IMemory<T> {
+    
+    @Override
+    default boolean removeOneOrNop(T value) {
+        // makes no difference for delta bags
+        return removeOne(value);
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemory.java
new file mode 100644
index 00000000..ea788e53
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemory.java
@@ -0,0 +1,81 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * A memory containing a positive or negative number of equal() copies for some values.
+ * During iterations, each distinct value is iterated only once.
+ * 
+ * <p> Refined by: <ul> 
+ *  <li>{@link IMultiset}, which always contains values with a nonnegative multiplicity. </li>
+ *  <li>{@link IDeltaBag}, which may contain values with negative multiplicity. </li>
+ *  <li>{@link ISetMemory}, which is just a set (allowed multiplicities: 0 and 1). </li>
+ * </ul>
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IMemory<T> extends IMemoryView<T>, Clearable {
+
+    /**
+     * Adds one value occurrence to the memory.
+     * 
+     * @return true if the tuple was not present before in the memory, or
+     *      (in case of {@link IDeltaBag}) is no longer present in the memory 
+     */
+    boolean addOne(T value);
+
+    /**
+     * Adds the given number of occurrences to the memory. The count value may or may not be negative.
+     * <p> Precondition if {@link IMultiset}: at least the given amount of occurrences exist, if count is negative.
+     * <p> Precondition if {@link ISetMemory}: count is +1 or -1, the latter is only allowed if the set contains the value.
+     * 
+     * @param count
+     *            the number of occurrences
+     * @return true if the tuple was not present before in the memory, or is no longer present in the memory
+     * @throws IllegalStateException if {@link IMultiset} or {@link ISetMemory} and the number of occurrences in the memory would underflow to negative
+     */
+    boolean addSigned(T value, int count);
+
+    /**
+     * Removes one occurrence of the given value from the memory.
+     * <p> Precondition if {@link IMultiset} or {@link ISetMemory}: the value must have a positive amount of occurrences in the memory.
+     * 
+     * @return true if this was the the last occurrence of the value, or
+     *      (in case of {@link IDeltaBag}) is the first negative occurrence of the value 
+     * @throws IllegalStateException if {@link IMultiset} or {@link ISetMemory} and value had no occurrences in the memory
+     */
+    boolean removeOne(T value);
+    
+    /**
+     * Removes one occurrence of the given value from the memory, if possible.
+     * 
+     * <p> Memory is unchanged and false is returned if 
+     *   {@link IMultiset} or {@link ISetMemory} and value had no occurrences in the memory
+     * 
+     * @return true if this was the the last occurrence of the value, or
+     *      (in case of {@link IDeltaBag}) is the first negative occurrence of the value 
+     *      
+     * @since 2.3
+     */
+    boolean removeOneOrNop(T value);
+
+    /**
+     * Removes all occurrences of the given value from the memory.
+     */
+    void clearAllOf(T value);
+
+    /**
+     * Empties out the memory. 
+     */
+    @Override
+    void clear();
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemoryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemoryView.java
new file mode 100644
index 00000000..add575c6
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemoryView.java
@@ -0,0 +1,205 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.function.BiConsumer;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+/**
+ * A read-only view on a memory containing a positive or negative number of equal() copies for some values.
+ * During iterations, each distinct value is iterated only once.
+ * 
+ * <p> See {@link IMemory}.
+ * 
+ * <p> Implementors must provide semantic (not identity-based) hashCode() and equals() using the static helpers {@link #hashCode(IMemoryView)} and {@link #equals(IMemoryView, Object)} here.
+ * 
+ * @author Gabor Bergmann
+ *
+ * @since 2.0
+ */
+public interface IMemoryView<T> extends Iterable<T> {
+
+    /**
+     * Returns the number of occurrences of the given value.
+     * 
+     * @return the number of occurrences
+     */
+    int getCount(T value);
+
+    /**
+     * Returns the number of occurrences of the given value (which may be of any type).
+     * 
+     * @return the number of occurrences
+     */
+    int getCountUnsafe(Object value);
+
+    /**
+     * @return true if the given value is contained with a nonzero multiplicity
+     */
+    boolean containsNonZero(T value);
+
+    /**
+     * @return true if the given value (which may be of any type) is contained with a nonzero multiplicity
+     */
+    boolean containsNonZeroUnsafe(Object value);
+        
+    /**
+     * @return the number of distinct values 
+     */
+    int size();
+
+    /**
+     * 
+     * @return iff contains at least one value with non-zero occurrences
+     */
+    boolean isEmpty();
+
+    /**
+     * The set of distinct values
+     */
+    Set<T> distinctValues();
+    
+
+    /**
+     * Where supported, returns the stored element that is equal to the given value, or null if none.
+     * Useful for canonicalization in case of non-identity equals(). 
+     * 
+     * <p> For collections that do not support canonicalization, simply returns the argument if contained, null if none.
+     * 
+     * @return a value equal to the argument if such a value is stored, or null if none
+     */
+    default T theContainedVersionOf(T value) {
+        if (containsNonZero(value)) return value; else return null;
+    }
+
+    /**
+     * Where supported, returns the stored element that is equal to the given value (of any type), 
+     * or null if none. 
+     * Useful for canonicalization in case of non-identity equals(). 
+     * 
+     * <p> For collections that do not support canonicalization, simply returns the argument if contained, null if none.
+     *
+     * @return a value equal to the argument if such a value is stored, or null if none
+     */
+    @SuppressWarnings("unchecked")
+    default T theContainedVersionOfUnsafe(Object value) {
+        if (containsNonZeroUnsafe(value)) return (T) value; else return null;
+    }
+    
+
+    /**
+     * @return an unmodifiable view of contained values with their multiplicities
+     */
+    default Iterable<Map.Entry<T, Integer>> entriesWithMultiplicities() {
+        return () -> {
+            Iterator<T> wrapped = distinctValues().iterator();
+            return new Iterator<Map.Entry<T, Integer>> () {
+                @Override
+                public boolean hasNext() {
+                    return wrapped.hasNext();
+                }
+
+                @Override
+                public Map.Entry<T, Integer> next() {
+                    T key = wrapped.next();
+                    int count = getCount(key);
+                    return new Map.Entry<T, Integer>(){
+                        @Override
+                        public T getKey() {
+                            return key;
+                        }
+
+                        @Override
+                        public Integer getValue() {
+                            return count;
+                        }
+
+                        @Override
+                        public Integer setValue(Integer value) {
+                            throw new UnsupportedOperationException();
+                        }
+                        
+                        @Override
+                        public String toString() {
+                            return String.format("%d of %s", count, key);
+                        }
+                        
+                    };
+                }
+                
+            };
+        };
+    }
+    
+    /**
+     * Process contained values with their multiplicities
+     */
+    default void forEachEntryWithMultiplicities(BiConsumer<T, Integer> entryConsumer) {
+        for (T value : distinctValues()) {
+            entryConsumer.accept(value, getCount(value));
+        }
+    }
+    
+    
+    /**
+     * For compatibility with legacy code relying on element-to-integer maps. 
+     * @return an unmodifiable view of contained values with their multiplicities
+     */
+    public default Map<T, Integer> asMap() {
+        return new MemoryViewBackedMapView<>(this);
+    }
+    
+    /**
+     * For compatibility with legacy code relying on element-to-integer maps. 
+     * @return an unmodifiable view of contained values with their multiplicities
+     */
+    public static <T> IMemoryView<T> fromMap(Map<T, Integer> wrapped) {
+        return new MapBackedMemoryView<>(wrapped);
+    }
+    
+    /**
+     * @return a stream of values, iterable once
+     * @since 2.1
+     */
+    public default Stream<T> asStream() {
+        return StreamSupport.stream(spliterator(), false);
+    }
+    
+    /**
+     * Provides semantic equality comparison.
+     */
+    public static <T> boolean equals(IMemoryView<T> self, Object obj) {
+        if (obj instanceof IMemoryView<?>) {
+            IMemoryView<?> other = (IMemoryView<?>) obj;
+            if (other.size() != self.size()) return false;
+            for (Entry<?, Integer> entry : other.entriesWithMultiplicities()) {
+                if ( !entry.getValue().equals(self.getCountUnsafe(entry.getKey())))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Provides semantic hashCode() comparison.
+     */
+    public static <T> int hashCode(IMemoryView<T> memory) {
+        int hashCode = 0;
+        for (T value : memory.distinctValues()) {
+            hashCode += value.hashCode() ^ Integer.hashCode(memory.getCount(value));
+        }
+        return hashCode;
+    }
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookup.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookup.java
new file mode 100644
index 00000000..1ce1d2c9
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookup.java
@@ -0,0 +1,216 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+
+/**
+ * A multi-map that associates sets / multisets / delta sets of values to each key.
+ * 
+ * <p> Implementors must provide semantic (not identity-based) hashCode() and equals() using the static helpers {@link #hashCode(IMultiLookup)} and {@link #equals(IMultiLookup, Object)} here.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ * @noimplement This interface is not intended to be implemented by clients.
+ */
+public interface IMultiLookup<Key, Value> {
+    
+    /**
+     * Returns true if this collection is empty, false otherwise.
+     * @since 2.2
+     */
+    boolean isEmpty();
+    
+    
+    /**
+     * Returns true if there are any values associated with the given key.
+     * @param key a key for which associated values are sought
+     * @since 2.3
+     */
+    boolean lookupExists(Key key);
+
+    /**
+     * Returns a (read-only) bucket of values associated with the given key.
+     * Clients must not modify the returned bucket.
+     * @param key a key for which associated values are sought
+     * @return null if key not found, a bucket of values otherwise
+     */
+    IMemoryView<Value> lookup(Key key);
+    
+    /**
+     * Returns a (read-only) bucket of values associated with the given key.
+     * Clients must not modify the returned bucket.
+     * @param key a key for which associated values are sought
+     * @return a bucket of values, never null
+     */
+    default IMemoryView<Value> lookupOrEmpty(Key key) {
+        IMemoryView<Value> bucket = lookup(key);
+        return bucket == null ? EmptyMemory.instance() : bucket;
+    }
+    
+    /**
+     * Returns a (read-only) bucket of values associated with the given key, while simultaneously removing them.
+     * Clients must not modify the returned bucket.
+     * @param key a key for which associated values are sought
+     * @return a bucket of values, never null
+     * @since 2.3
+     */
+    IMemoryView<Value> lookupAndRemoveAll(Key key);
+    
+    /**
+     * Returns a (read-only) bucket of values associated with the given key, which can be of any type.
+     * Clients must not modify the returned bucket.
+     * @param key a key for which associated values are sought (may or may not be of Key type)
+     * @return null if key not found, a bucket of values otherwise
+     */
+    IMemoryView<Value> lookupUnsafe(Object key);
+    
+    /**
+     * Returns a (read-only) bucket of values associated with the given key.
+     * Clients must not modify the returned bucket.
+     * @param key a key for which associated values are sought (may or may not be of Key type)
+     * @return a bucket of values, never null
+     */
+    default IMemoryView<Value> lookupUnsafeOrEmpty(Object key) {
+        IMemoryView<Value> bucket = lookupUnsafe(key);
+        return bucket == null ? EmptyMemory.instance() : bucket;
+    }
+    
+    
+    
+    /**
+     * @return the set of distinct keys that have values associated.
+     */
+    Iterable<Key> distinctKeys();
+    
+    /**
+     * @return the set of distinct keys that have values associated.
+     * @since 2.3
+     */
+    Stream<Key> distinctKeysStream();
+    
+    /**
+     * @return the number of distinct keys that have values associated.
+     */
+    int countKeys();
+    
+    /**
+     * Iterates once over each distinct value.
+     */
+    Iterable<Value> distinctValues();
+    
+    /**
+     * Iterates once over each distinct value.
+     * @since 2.3
+     */
+    Stream<Value> distinctValuesStream();
+
+    
+    
+    /**
+     * How significant was the change?     * 
+     * @author Gabor Bergmann
+     */
+    public enum ChangeGranularity {
+        /**
+         * First key-value pair with given key inserted, or last pair with given key deleted.
+         * (In case of delta maps, also if last negative key-value pair with given key neutralized.)
+         */
+        KEY, 
+        /**
+         * First occurrence of given key-value pair inserted, or last occurrence of the pair deleted, while key still has values associated.
+         * (In case of delta maps, also if last negative occurrence of key-value pair neutralized.)
+         */
+        VALUE, 
+        /**
+         * Duplicate key-value pair inserted or deleted.
+         */
+        DUPLICATE
+    }
+    
+    /**
+     * Adds key-value pair to the lookup structure, or fails if not possible.
+     * <p> If the addition would cause duplicates but the bucket type does not allow it ({@link MemoryType#SETS}), 
+     *   the operation throws an {@link IllegalStateException}.
+     * @return the granularity of the change
+     * @throws IllegalStateException if addition would cause duplication that is not permitted 
+     */
+    public ChangeGranularity addPair(Key key, Value value);
+    /**
+     * Adds key-value pair to the lookup structure. 
+     * <p> If the addition would cause duplicates but the bucket type does not allow it ({@link MemoryType#SETS}), 
+     *   the operation is silently ignored and {@link ChangeGranularity#DUPLICATE} is returned.
+     * @return the granularity of the change, or {@link ChangeGranularity#DUPLICATE} if addition would result in a duplicate and therefore ignored
+     * @since 2.3
+     */
+    public ChangeGranularity addPairOrNop(Key key, Value value);
+    /**
+     * Removes key-value pair from the lookup structure, or fails if not possible.
+     * <p> When attempting to remove a key-value pair with zero multiplicity from a non-delta bucket type 
+     * ({@link MemoryType#SETS} or {@link MemoryType#MULTISETS}}), an {@link IllegalStateException} is thrown. 
+     * @return the granularity of the change
+     * @throws IllegalStateException if removing non-existing element that is not permitted 
+     */
+    public ChangeGranularity removePair(Key key, Value value);
+    /**
+     * Removes key-value pair from the lookup structure.
+     * <p> When attempting to remove a key-value pair with zero multiplicity from a non-delta bucket type 
+     * ({@link MemoryType#SETS} or {@link MemoryType#MULTISETS}}), 
+     * the operation is silently ignored and {@link ChangeGranularity#DUPLICATE} is returned. 
+     * @return the granularity of the change
+     * @throws IllegalStateException if removing non-existing element that is not permitted 
+     * @since 2.3
+     */
+    public ChangeGranularity removePairOrNop(Key key, Value value);
+    
+    /**
+     * Updates multiplicity of key-value pair by a positive amount.
+     * 
+     * <p> PRE: count > 0
+     * 
+     * @return the granularity of the change
+     * @throws IllegalStateException if addition would cause duplication that is not permitted 
+     */
+    public ChangeGranularity addPairPositiveMultiplicity(Key key, Value value, int count);
+    
+    /**
+     * Empties out the lookup structure.
+     */
+    public void clear();
+    
+    /**
+     * Provides semantic equality comparison.
+     */
+    public static <Key, Value> boolean equals(IMultiLookup<Key, Value> self, Object obj) {
+        if (obj instanceof IMultiLookup<?, ?>) {
+            IMultiLookup<?, ?> other = (IMultiLookup<?, ?>) obj;
+            if (other.countKeys() != self.countKeys()) return false;
+            for (Object key : other.distinctKeys()) {
+                if (! other.lookupUnsafe(key).equals(self.lookupUnsafe(key)))
+                    return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    
+    /**
+     * Provides semantic hashCode() comparison.
+     */
+    public static <Key, Value> int hashCode(IMultiLookup<Key, Value> memory) {
+        int hashCode = 0;
+        for (Key key : memory.distinctKeys()) {
+            hashCode += key.hashCode() ^ memory.lookup(key).hashCode();
+        }
+        return hashCode;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookupAbstract.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookupAbstract.java
new file mode 100644
index 00000000..8b1944c1
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookupAbstract.java
@@ -0,0 +1,485 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Objects;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import tools.refinery.viatra.runtime.matchers.util.MarkedMemory.MarkedSet;
+
+/**
+ * Specialized multimap implementation that saves memory 
+ *  by storing singleton value objects (multiplicity 1) instead of multiset buckets 
+ *  whenever there is only one value associated with a key.
+ * 
+ * <p> See specialized {@link ToSetsAbstract}, {@link ToMultisetsAbstract} for various bucket types.
+ * 
+ * <p> Implemented as a Key->Object map with invariant: <ul>
+ * <li> key maps to null if associated with no values; 
+ * <li> key maps to a single Value iff it is associated with a single value of multiplicity +1;  
+ * <li> key maps to Bucket otherwise
+ * </ul>
+ * 
+ * Note that due to the above invariant, handling +1 and -1 are asymmetric in case of delta maps.
+ *
+ * <p> Not intended as an API, but rather as a 'base class' for implementors.
+ * Realized as an interface with default implementations, instead of an abstract class, 
+ *  to ensure that implementors can easily choose a base class such as UnifiedMap to augment. 
+ *  
+ *  <p> Implementor should inherit from a Map<Key, Object>-like class (primitive map possible) 
+ *      and bind the lowLevel* methods accordingly.
+ * 
+ * @noreference This interface is not intended to be referenced by clients.
+ * @noimplement This interface is not intended to be implemented by clients.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ *
+ * 
+ */
+public interface IMultiLookupAbstract<Key, Value, Bucket extends MarkedMemory<Value>> extends IMultiLookup<Key, Value> {
+
+    // the following methods must be bound to a concrete Map<Key,Object>-like structure (primitive implementation allowed)
+
+    /**
+     * Implementor shall bind to the low-level get() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Object lowLevelGet(Key key);
+
+    /**
+     * Implementor shall bind to the low-level get() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Object lowLevelGetUnsafe(Object key);
+    
+    /**
+     * Implementor shall bind to the low-level remove() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Object lowLevelRemove(Key key);
+    
+    /**
+     * Implementor shall bind to the low-level putIfAbsent() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Object lowLevelPutIfAbsent(Key key, Value value);
+
+    /**
+     * Implementor shall bind to the low-level put() or equivalent of the underlying Key-to-Object map
+     */
+    abstract void lowLevelPut(Key key, Object valueOrBucket);
+    
+    /**
+     * Implementor shall bind to the low-level values() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Iterable<Object> lowLevelValues();
+    
+    /**
+     * Implementor shall bind to the low-level keySet() or equivalent of the underlying Key-to-Object map
+     */
+    abstract Iterable<Key> lowLevelKeySet();
+    
+    /**
+     * Implementor shall bind to the low-level size() or equivalent of the underlying Key-to-Object map
+     */
+    abstract int lowLevelSize();
+
+    
+    // generic multi-lookup logic
+   
+    @Override
+    default boolean lookupExists(Key key) {
+        Object object = lowLevelGet(key);
+        return null != object;
+    }
+    
+    @Override
+    public default IMemoryView<Value> lookup(Key key) {
+        Object object = lowLevelGet(key);
+        if (object == null) return null;
+        if (object instanceof MarkedMemory) return (Bucket) object;
+        return yieldSingleton((Value)object);
+    }
+    
+    @Override
+    default IMemoryView<Value> lookupAndRemoveAll(Key key) {
+        Object object = lowLevelRemove(key);
+        if (object == null) return EmptyMemory.instance();
+        if (object instanceof MarkedMemory) return (Bucket) object;
+        return yieldSingleton((Value)object);
+    }
+    
+    @Override
+    public default IMemoryView<Value> lookupUnsafe(Object key) {
+        Object object = lowLevelGetUnsafe(key);
+        if (object == null) return null;
+        if (object instanceof MarkedMemory) return (Bucket) object;
+        return yieldSingleton((Value)object);
+    }
+
+    @Override
+    public default ChangeGranularity addPair(Key key, Value value) {
+        return addPairInternal(key, value, true);
+    }
+    
+    @Override
+    default ChangeGranularity addPairOrNop(Key key, Value value) {
+        return addPairInternal(key, value, false);
+    }
+
+    public default ChangeGranularity addPairInternal(Key key, Value value, boolean throwIfImpossible) {
+        Object old = lowLevelPutIfAbsent(key, value);
+        boolean keyChange = (old == null);
+
+        if (keyChange) { // key was not present
+            return ChangeGranularity.KEY;
+        } else { // key was already present
+            Bucket bucket;
+            if (old instanceof MarkedMemory) { // ... as collection
+                bucket = (Bucket) old;
+            } else { // ... as singleton
+                if (!this.duplicatesAllowed() && Objects.equals(value, old)) {
+                    if (throwIfImpossible) 
+                        throw new IllegalStateException(); 
+                    else 
+                        return ChangeGranularity.DUPLICATE;
+                }
+                bucket = createSingletonBucket((Value) old);
+                lowLevelPut(key, bucket);
+            }
+            // will throw if forbidden duplicate, return false if allowed duplicate
+            if (addToBucket(bucket, value, throwIfImpossible)) {
+                // deltas may become empty or a singleton after addition!
+                if (negativesAllowed()) {
+                    if (bucket.isEmpty()) { 
+                        lowLevelRemove(key);
+                        return ChangeGranularity.KEY;
+                    } else {
+                        handleSingleton(key, bucket);                    
+                        return ChangeGranularity.VALUE;
+                    }                    
+                } else return ChangeGranularity.VALUE; 
+            } else return ChangeGranularity.DUPLICATE;
+        }
+    }
+    
+    @Override
+    // TODO deltas not supproted yet
+    default ChangeGranularity addPairPositiveMultiplicity(Key key, Value value, int count) {
+        if (count == 1) return addPair(key, value);
+        // count > 1, always end up with non-singleton bucket
+        
+        Object old = lowLevelGet(key);
+        boolean keyChange = (old == null);
+        
+        Bucket bucket;
+        if (keyChange) { // ... nothing associated to key yet
+            bucket = createSingletonBucket(value);
+            lowLevelPut(key, bucket);
+            --count; // one less to increment later
+        } else if (old instanceof MarkedMemory) { // ... as collection
+            bucket = (Bucket) old;
+        } else { // ... as singleton
+            bucket = createSingletonBucket((Value) old);
+            lowLevelPut(key, bucket);
+        }
+        
+        boolean newValue = bucket.addSigned(value, count);
+        
+        if (keyChange) return ChangeGranularity.KEY;
+        else if (newValue) return ChangeGranularity.VALUE;
+        else return ChangeGranularity.DUPLICATE;
+    }
+
+    @Override
+    public default ChangeGranularity removePair(Key key, Value value) {
+        return removePairInternal(key, value, true);
+    }
+    
+    @Override
+    default ChangeGranularity removePairOrNop(Key key, Value value) {
+        return removePairInternal(key, value, false);
+    }
+
+    public default ChangeGranularity removePairInternal(Key key, Value value, boolean throwIfImpossible) {
+        Object old = lowLevelGet(key);
+        if (old instanceof MarkedMemory) { // ... as collection
+            @SuppressWarnings("unchecked")
+            Bucket bucket = (Bucket) old;
+            // will throw if removing non-existent, return false if removing duplicate
+            boolean valueChange = removeFromBucket(bucket, value, throwIfImpossible);            
+            handleSingleton(key, bucket);
+            if (valueChange) 
+                return ChangeGranularity.VALUE;
+            else 
+                return ChangeGranularity.DUPLICATE;
+        } else if (value.equals(old)) { // matching singleton
+            lowLevelRemove(key);
+            return ChangeGranularity.KEY;
+        } else { // different singleton, will produce a delta if possible
+            if (negativesAllowed()) {
+                Bucket deltaBucket = createDeltaBucket((Value) old, value); // will throw if no deltas supported
+                lowLevelPut(key, deltaBucket);
+                return ChangeGranularity.VALUE; // no key change                
+            } else {
+                if (throwIfImpossible) 
+                    throw new IllegalStateException(); 
+                else 
+                    return ChangeGranularity.DUPLICATE;
+            }
+        }
+    }
+
+    public default void handleSingleton(Key key, Bucket bucket) {
+        Value remainingSingleton = asSingleton(bucket);
+        if (remainingSingleton != null) { // only one remains
+            lowLevelPut(key, remainingSingleton);
+        }
+    }
+
+    @Override
+    public default Iterable<Value> distinctValues() {
+        return new Iterable<Value>() {
+            private final Iterator<Value> EMPTY_ITERATOR = Collections.<Value>emptySet().iterator(); 
+            @Override
+            public Iterator<Value> iterator() {
+                return new Iterator<Value>() {
+                    Iterator<Object> bucketIterator = lowLevelValues().iterator();
+                    Iterator<Value> elementIterator = EMPTY_ITERATOR;
+                    
+                    @Override
+                    public boolean hasNext() {
+                        return (elementIterator.hasNext() || bucketIterator.hasNext());
+                    }
+                    
+                    @Override
+                    public Value next() {
+                        if (elementIterator.hasNext())
+                            return elementIterator.next();
+                        else if (bucketIterator.hasNext()) {
+                            Object bucket = bucketIterator.next();
+                            if (bucket instanceof MarkedMemory) {
+                                elementIterator = 
+                                        ((MarkedMemory) bucket).distinctValues().iterator();
+                                return elementIterator.next();
+                            } else {
+                                elementIterator = EMPTY_ITERATOR;
+                                return (Value) bucket;
+                            }
+                        } else
+                            throw new NoSuchElementException();
+                    }
+
+                    /**
+                     * Not implemented
+                     */
+                    @Override
+                    public void remove() {
+                        throw new UnsupportedOperationException();
+                    }
+
+                };
+            }
+        };
+    }
+    
+    @Override
+    default Stream<Value> distinctValuesStream() {
+        return StreamSupport.stream(distinctValues().spliterator(), false);
+    }
+    
+    @Override
+    default Iterable<Key> distinctKeys() {
+        return lowLevelKeySet();
+    }
+    
+    @Override
+    default Stream<Key> distinctKeysStream() {
+        return StreamSupport.stream(distinctKeys().spliterator(), false);
+    }
+    
+    @Override
+    default int countKeys() {
+        return lowLevelSize();
+    }
+    
+    // the following methods are customized for bucket type
+
+    /**
+     * @return iff negative multiplicites are allowed
+     */
+    abstract boolean negativesAllowed();
+
+    /**
+     * @return iff larger-than-1 multiplicites are allowed
+     * @since 2.3
+     */
+    abstract boolean duplicatesAllowed();
+    
+    /**
+     * Increases the multiplicity of the value in the bucket.
+     * @return true iff non-duplicate
+     * @throws IllegalStateException if disallowed duplication and throwIfImpossible is specified 
+     */
+    abstract boolean addToBucket(Bucket bucket, Value value, boolean throwIfImpossible);
+
+    /**
+     * Decreases the multiplicity of the value in the bucket.
+     * @return false if removing duplicate value
+     * @throws IllegalStateException if removing non-existing value (unless delta map) and throwIfImpossible is specified
+     */
+    abstract boolean removeFromBucket(Bucket bucket, Value value, boolean throwIfImpossible);
+
+    /**
+     * Checks whether the bucket is a singleton, i.e. it contains a single value with multiplicity +1
+     * @return the singleton value, or null if the bucket is not singleton
+     */
+    abstract Value asSingleton(Bucket bucket);
+
+    /**
+     * @return a new bucket consisting of a sole value
+     */
+    abstract Bucket createSingletonBucket(Value value);
+    /**
+     * @return a read-only bucket consisting of a sole value, to be returned to the user
+     */
+    default IMemoryView<Value> yieldSingleton(Value value) {
+        return new SingletonMemoryView<>(value);
+    }
+
+   /**
+    *  @param positive the previously existing value, or null if the delta is to contain a single negative tuple
+     * @return a new bucket consisting of a delta of two values
+     * @throws IllegalStateException if deltas not supported
+     */
+    abstract Bucket createDeltaBucket(Value positive, Value negative);
+    
+    /**
+     * A multi-lookup whose buckets are sets.
+     * 
+     * <p> Not intended as an API, but rather as a 'base class' for implementors.
+     * Realized as an interface with default implementations, instead of an abstract class, 
+     *  to ensure that implementors can easily choose a base class such as UnifiedMap to augment. 
+     *  
+     *  <p> Implementor should inherit from a Map<Key, Object>-like class (primitive map possible) 
+     *      and bind the lowLevel* methods accordingly.
+     * 
+     * @noreference This interface is not intended to be referenced by clients.
+     * @noimplement This interface is not intended to be implemented by clients.
+     * @author Gabor Bergmann
+     */
+    public static interface ToSetsAbstract<Key, Value> extends IMultiLookupAbstract<Key, Value, MarkedMemory.MarkedSet<Value>> {
+        /**
+         * @return a fresh, empty marked set
+         */
+        public MarkedSet<Value> createMarkedSet();
+
+        @Override
+        public default boolean negativesAllowed() {
+            return false;
+        }
+        @Override
+        default boolean duplicatesAllowed() {
+            return false;
+        }
+
+        @Override
+        public default boolean addToBucket(MarkedSet<Value> bucket, Value value, boolean throwIfImpossible) {
+            if (bucket.addOne(value)) return true; 
+            else if (throwIfImpossible) throw new IllegalStateException();
+            else return false;
+        }
+
+        @Override
+        public default boolean removeFromBucket(MarkedSet<Value> bucket, Value value, boolean throwIfImpossible) {
+            return throwIfImpossible ? bucket.removeOne(value) : bucket.removeOneOrNop(value);
+        }
+
+        @Override
+        public default Value asSingleton(MarkedSet<Value> bucket) {
+            return bucket.size() == 1 ? bucket.iterator().next() : null;
+        }
+
+        @Override
+        public default MarkedSet<Value> createSingletonBucket(Value value) {
+            MarkedSet<Value> result = createMarkedSet();
+            result.addOne(value);
+            return result;
+        }
+
+        @Override
+        public default MarkedSet<Value> createDeltaBucket(Value positive, Value negative) {
+            throw new IllegalStateException();
+        }        
+    }
+    
+    /**
+     * A multi-lookup whose buckets are multisets.
+     * 
+     * <p> Not intended as an API, but rather as a 'base class' for implementors.
+     * Realized as an interface with default implementations, instead of an abstract class, 
+     *  to ensure that implementors can easily choose a base class such as UnifiedMap to augment. 
+     *  
+     *  <p> Implementor should inherit from a Map<Key, Object>-like class (primitive map possible) 
+     *      and bind the lowLevel* methods accordingly.
+     * 
+     * @noreference This interface is not intended to be referenced by clients.
+     * @noimplement This interface is not intended to be implemented by clients.
+     * @author Gabor Bergmann
+     */
+    public static interface ToMultisetsAbstract<Key, Value> extends IMultiLookupAbstract<Key, Value, MarkedMemory.MarkedMultiset<Value>> {
+        /**
+         * @return a fresh, empty marked multiset
+         */
+        public MarkedMemory.MarkedMultiset<Value> createMarkedMultiset();
+
+        @Override
+        public default boolean negativesAllowed() {
+            return false;
+        }
+        @Override
+        default boolean duplicatesAllowed() {
+            return true;
+        }
+
+        @Override
+        public default boolean addToBucket(MarkedMemory.MarkedMultiset<Value> bucket, Value value, boolean throwIfImpossible) {
+            return bucket.addOne(value); 
+        }
+
+        @Override
+        public default boolean removeFromBucket(MarkedMemory.MarkedMultiset<Value> bucket, Value value, boolean throwIfImpossible) {
+            return throwIfImpossible ? bucket.removeOne(value) : bucket.removeOneOrNop(value);
+        }
+
+        @Override
+        public default Value asSingleton(MarkedMemory.MarkedMultiset<Value> bucket) {
+            if (bucket.size() != 1) return null;
+            Value candidate = bucket.iterator().next();
+            return bucket.getCount(candidate) == 1 ? candidate : null;
+        }
+
+        @Override
+        public default MarkedMemory.MarkedMultiset<Value> createSingletonBucket(Value value) {
+            MarkedMemory.MarkedMultiset<Value> result = createMarkedMultiset();
+            result.addOne(value);
+            return result;
+        }
+
+        @Override
+        public default MarkedMemory.MarkedMultiset<Value> createDeltaBucket(Value positive, Value negative) {
+            throw new IllegalStateException();
+        }        
+    }
+    
+    
+    // TODO add ToDeltaBagsAbstract
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiset.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiset.java
new file mode 100644
index 00000000..bdd5d597
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiset.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * An {@link IMemory} that always contains values with a nonnegative multiplicity.
+ * 
+ * <p> In case a write operation caused underflow, an {@link IllegalStateException} is thrown.
+ * 
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public interface IMultiset<T> extends IMemory<T> {
+
+    /**
+     * Adds the given number of occurrences to the memory. The count value must be a positive number.
+     * 
+     * @param count
+     *            the number of occurrences
+     * @return true if the tuple was not present before in the memory
+     */
+    boolean addPositive(T value, int count);
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IProvider.java
new file mode 100644
index 00000000..cd25dc95
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/IProvider.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+import tools.refinery.viatra.runtime.matchers.psystem.queries.PQuery;
+
+/**
+ * A provider interface useful in various registry instances.
+ * 
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface IProvider<T> extends Supplier<T>{
+    
+    public final class ProvidedValueFunction implements Function<IProvider<PQuery>, PQuery> {
+        @Override
+        public PQuery apply(IProvider<PQuery> input) {
+            return (input == null) ? null : input.get();
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ISetMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ISetMemory.java
new file mode 100644
index 00000000..0c03da48
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/ISetMemory.java
@@ -0,0 +1,37 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.function.BiConsumer;
+
+/**
+ * An {@link IMemory} that always contains values with a 0 or +1 multiplicity.
+ * 
+ * <p> In case a write operation causes underflow or overflow, an {@link IllegalStateException} is thrown.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public interface ISetMemory<T> extends IMemory<T> {
+    
+    @Override
+    default void forEachEntryWithMultiplicities(BiConsumer<T, Integer> entryConsumer) {
+        for (T t : this.distinctValues()) entryConsumer.accept(t, 1);
+    }
+    
+
+    @Override
+    default boolean removeOne(T value) {
+        if (!removeOneOrNop(value))
+            throw new IllegalStateException();
+        return true;
+    }
+
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MapBackedMemoryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MapBackedMemoryView.java
new file mode 100644
index 00000000..3be078bd
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MapBackedMemoryView.java
@@ -0,0 +1,102 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.function.BiConsumer;
+
+/**
+ * Wraps a Map<T, Integer> (mapping elements to non-zero multiplicities) into an {@link IMemoryView}.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public class MapBackedMemoryView<T> implements IMemoryView<T> {
+
+    private Map<T, Integer> wrapped;
+
+    /**
+     * @param wrapped an equivalent map from contained objects to multiplicities
+     */
+    protected MapBackedMemoryView(Map<T, Integer> wrapped) {
+        super();
+        this.wrapped = wrapped;
+    }
+
+    @Override
+    public Iterator<T> iterator() {
+        return wrapped.keySet().iterator();
+    }
+
+    @Override
+    public int getCount(T value) {
+        return getCountUnsafe(value);
+    }
+
+    @Override
+    public int getCountUnsafe(Object value) {
+        Integer count = wrapped.get(value);
+        return count == null ? 0 : count;
+    }
+
+    @Override
+    public boolean containsNonZero(T value) {
+        return wrapped.containsKey(value);
+    }
+
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return wrapped.containsKey(value);
+    }
+
+    @Override
+    public int size() {
+        return wrapped.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return wrapped.isEmpty();
+    }
+
+    @Override
+    public Set<T> distinctValues() {
+        return wrapped.keySet();
+    }
+    
+    
+    @Override
+    public void forEachEntryWithMultiplicities(BiConsumer<T, Integer> entryConsumer) {
+        for (Entry<T, Integer> entry : wrapped.entrySet()) {
+            entryConsumer.accept(entry.getKey(), entry.getValue());
+        }
+    }
+    
+    @Override
+    public Iterable<Entry<T, Integer>> entriesWithMultiplicities() {
+        return wrapped.entrySet();
+    }
+    
+    @Override
+    public int hashCode() {
+        return IMemoryView.hashCode(this);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return IMemoryView.equals(this, obj);
+    }
+    
+    @Override
+    public String toString() {
+        return wrapped.toString();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MarkedMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MarkedMemory.java
new file mode 100644
index 00000000..d22dcbe7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MarkedMemory.java
@@ -0,0 +1,21 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQueryLabs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * Internal marker type, must only be instantiated inside implementors of IMultiLookupImpl
+ * @noimplement This interface is not intended to be implemented by clients.
+ * @since 2.0
+ */
+public interface MarkedMemory<Value> extends IMemory<Value> {
+    
+    static interface MarkedSet<Value> extends MarkedMemory<Value> {}
+    static interface MarkedMultiset<Value> extends MarkedMemory<Value> {}
+    static interface MarkedDeltaBag<Value> extends MarkedMemory<Value> {}
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MemoryViewBackedMapView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MemoryViewBackedMapView.java
new file mode 100644
index 00000000..49711a89
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/MemoryViewBackedMapView.java
@@ -0,0 +1,117 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A partial and read-only Map implementation, mapping elements to multiplicities backed by an {@link IMemoryView}.
+ * 
+ * <p> Not implemented: write methods.
+ * 
+ * <p> Inefficiently implemented: {@link #containsValue(Object)}, {@link #values()}, {@link #entrySet()}.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public class MemoryViewBackedMapView<T> implements Map<T, Integer> {
+    
+    private static final String READ_ONLY = "Read only";
+    private final IMemoryView<T> wrapped;
+    
+    /**
+     * @param wrapped a memory view whose contents are to be exposed as an element-to-integer map.
+     */
+    protected MemoryViewBackedMapView(IMemoryView<T> wrapped) {
+        super();
+        this.wrapped = wrapped;
+    }
+
+    @Override
+    public int size() {
+        return wrapped.size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return wrapped.isEmpty();
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return wrapped.containsNonZeroUnsafe(key);
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+        if (value instanceof Integer) {
+            for (Entry<T, Integer> entry : wrapped.entriesWithMultiplicities()) {
+                if (entry.getValue().equals(value)) return true;
+            }
+        }
+        return false;
+    }
+
+    @Override
+    public Integer put(T key, Integer value) {
+        throw new UnsupportedOperationException(READ_ONLY);
+    }
+
+    @Override
+    public Integer get(Object key) {
+        int count = wrapped.getCountUnsafe(key);
+        if (count == 0) return null; else return count;
+    }
+
+    @Override
+    public Integer remove(Object key) {
+        throw new UnsupportedOperationException(READ_ONLY);
+    }
+
+    @Override
+    public void putAll(Map<? extends T, ? extends Integer> m) {
+        throw new UnsupportedOperationException(READ_ONLY);
+    }
+
+    @Override
+    public void clear() {
+        throw new UnsupportedOperationException(READ_ONLY);
+    }
+
+    @Override
+    public Set<T> keySet() {
+        return wrapped.distinctValues();
+    }
+
+    @Override
+    public Collection<Integer> values() {
+        Collection<Integer> result = new ArrayList<>();
+        wrapped.forEachEntryWithMultiplicities((value, count) -> result.add(count));
+        return result;
+    }
+
+    @Override
+    public Set<Entry<T, Integer>> entrySet() {
+        Set<Entry<T, Integer>> result = new HashSet<>();
+        for (Entry<T, Integer> entry : wrapped.entriesWithMultiplicities()) {
+            result.add(entry);
+        }
+        return result;
+    }
+
+
+    @Override
+    public String toString() {
+        return wrapped.toString();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Preconditions.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Preconditions.java
new file mode 100644
index 00000000..e9e5e3a0
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Preconditions.java
@@ -0,0 +1,208 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.function.Supplier;
+
+/**
+ * This class was motivated by the similar Preconditions class from Guava to provide simple precondition checking
+ * functionality. However, as starting with version 2.0 the runtime of VIATRA Query should not depend on Guava, the
+ * relevant functionality of the Preconditions checking functionality will be implemented here.
+ * 
+ * @author Zoltan Ujhelyi
+ * @since 2.0
+ *
+ */
+public final class Preconditions {
+
+    private Preconditions() {
+        /* Utility class constructor */ }
+
+    /**
+     * Ensures the truth of an expression involving one or more parameters to the calling method.
+     *
+     * @param expression
+     *            a boolean expression
+     * @throws IllegalArgumentException
+     *             if {@code expression} is false
+     */
+    public static void checkArgument(boolean expression) {
+        if (!expression) {
+            throw new IllegalArgumentException();
+        }
+    }
+    
+    /**
+     * Ensures the truth of an expression involving one or more parameters to the calling method.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param errorMessage
+     *            the exception message to use if the check fails
+     * @throws IllegalArgumentException
+     *             if {@code expression} is false
+     */
+    public static void checkArgument(boolean expression, String errorMessage) {
+        if (!expression) {
+            throw new IllegalArgumentException(errorMessage);
+        }
+    }
+
+    /**
+     * Ensures the truth of an expression involving one or more parameters to the calling method.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param errorMessageTemplate
+     *            a template for the exception message should the check fail using the Java Formatter syntax; the same
+     *            as used by {@link String#format(String, Object...)}.
+     * @param errorMessageArgs
+     *            the arguments to be substituted into the message template.
+     * @throws IllegalArgumentException
+     *             if {@code expression} is false
+     * @throws NullPointerException
+     *             if the check fails and either {@code errorMessageTemplate} or {@code errorMessageArgs} is null (don't
+     *             let this happen)
+     */
+    public static void checkArgument(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) {
+        if (!expression) {
+            throw new IllegalArgumentException(String.format(errorMessageTemplate, errorMessageArgs));
+        }
+    }
+    
+    /**
+     * Ensures the truth of an expression involving one or more parameters to the calling method.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param messageSupplier a supplier that is called to calculate the error message if necessary
+     * @throws IllegalArgumentException
+     *             if {@code expression} is false
+     */
+    public static void checkArgument(boolean expression, Supplier<String> messageSupplier) {
+        if (!expression) {
+            throw new IllegalArgumentException(messageSupplier.get());
+        }
+    }
+    
+    /**
+     * Ensures the truth of an expression involving one or more fields of a class.
+     *
+     * @param expression
+     *            a boolean expression
+     * @throws IllegalStateException
+     *             if {@code expression} is false
+     */
+    public static void checkState(boolean expression) {
+        if (!expression) {
+            throw new IllegalStateException();
+        }
+    }
+    
+    /**
+     * Ensures the truth of an expression involving one or more fields of a class.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param errorMessage
+     *            the exception message to use if the check fails
+     * @throws IllegalStateException
+     *             if {@code expression} is false
+     */
+    public static void checkState(boolean expression, String errorMessage) {
+        if (!expression) {
+            throw new IllegalStateException(errorMessage);
+        }
+    }
+
+    /**
+     * Ensures the truth of an expression involving one or more fields of a class.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param errorMessageTemplate
+     *            a template for the exception message should the check fail using the Java Formatter syntax; the same
+     *            as used by {@link String#format(String, Object...)}.
+     * @param errorMessageArgs
+     *            the arguments to be substituted into the message template.
+     * @throws IllegalStateException
+     *             if {@code expression} is false
+     * @throws NullPointerException
+     *             if the check fails and either {@code errorMessageTemplate} or {@code errorMessageArgs} is null (don't
+     *             let this happen)
+     */
+    public static void checkState(boolean expression, String errorMessageTemplate, Object... errorMessageArgs) {
+        if (!expression) {
+            throw new IllegalStateException(String.format(errorMessageTemplate, errorMessageArgs));
+        }
+    }
+    
+    /**
+     * Ensures the truth of an expression involving one or more fields of a class.
+     *
+     * @param expression
+     *            a boolean expression
+     * @param messageSupplier a supplier that is called to calculate the error message if necessary
+     * @throws IllegalStateException
+     *             if {@code expression} is false
+     */
+    public static void checkState(boolean expression, Supplier<String> messageSupplier) {
+        if (!expression) {
+            throw new IllegalStateException(messageSupplier.get());
+        }
+    }
+    
+    /**
+     * Ensures that an index is appropriate for a list or array of given size.
+     * 
+     * @param index
+     * @param size
+     * @throws IndexOutOfBoundsException
+     *             if index is negative or is greater or equal to size
+     */
+    public static void checkElementIndex(int index, int size) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+    }
+    
+    /**
+     * Ensures that an index is appropriate for a list or array of given size.
+     * 
+     * @param index
+     * @param size
+     * @param errorMessageTemplate
+     *            a template for the exception message should the check fail using the Java Formatter syntax; the same
+     *            as used by {@link String#format(String, Object...)}.
+     * @param errorMessageArgs
+     *            the arguments to be substituted into the message template.
+     * @throws IndexOutOfBoundsException
+     *             if index is negative or is greater or equal to size
+     */
+    public static void checkElementIndex(int index, int size, String errorMessageTemplate, Object... errorMessageArgs) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(String.format(errorMessageTemplate, errorMessageArgs));
+        }
+    }
+    
+    /**
+     * Ensures that an index is appropriate for a list or array of given size.
+     * 
+     * @param index
+     * @param size
+     * @param messageSupplier a supplier that is called to calculate the error message if necessary
+     * @throws IndexOutOfBoundsException
+     *             if index is negative or is greater or equal to size
+     */
+    public static void checkElementIndex(int index, int size, Supplier<String> messageSupplier) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException(messageSupplier.get());
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/PurgableCache.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/PurgableCache.java
new file mode 100644
index 00000000..c4e6b5af
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/PurgableCache.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * @author Zoltan Ujhelyi
+ * @since 1.7
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public class PurgableCache implements ICache {
+
+    Map<Object, Object> storage = new HashMap<>();
+    
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T> T getValue(Object key, Class<? extends T> clazz, Supplier<T> valueProvider) {
+        if (storage.containsKey(key)) {
+            Object value = storage.get(key);
+            Preconditions.checkState(clazz.isInstance(value), "Cache stores for key %s a value of %s that is incompatible with the requested type %s", key, value, clazz);
+            return (T) value;
+        } else {
+            T value = valueProvider.get();
+            storage.put(key, value);
+            return value;
+        }
+    }
+    
+    /**
+     * Removes all values stored in the cache
+     */
+    public void purge() {
+        storage.clear();
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Sets.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Sets.java
new file mode 100644
index 00000000..3749fe06
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Sets.java
@@ -0,0 +1,90 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ *   Gabor Bergmann - initial API and implementation
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+/**
+ * This class was motivated by the similar Sets class from Guava to provide simple set manipulation
+ * functionality. However, as starting with version 2.3 the runtime of VIATRA Query should not depend on Guava, 
+ * not even internally, the relevant subset of Sets methods will be reimplemented here.
+ * 
+ * <p> The current approach is to delegate to Eclipse Collections wherever possible.
+ * Such glue methods are useful so that downstream clients can avoid directly depending on Eclipse Collections.
+ * 
+ * <p> Without an equivalent from Eclipse Collections, {@link #cartesianProduct(List)} is implemented here from scratch.
+ *  
+ * @author Gabor Bergmann
+ * @since 2.3
+ */
+public final class Sets {
+    
+    /**
+     * @since 2.4
+     */
+    public static <A> Set<A> newSet(Iterable<A> elements) {
+        return org.eclipse.collections.impl.factory.Sets.mutable.ofAll(elements);
+    }
+
+    public static <A> Set<A> intersection(Set<A> left, Set<A> right) {
+        return org.eclipse.collections.impl.factory.Sets.intersect(left, right);
+    }
+
+    public static <A> Set<A> difference(Set<A> left, Set<A> right) {
+        return org.eclipse.collections.impl.factory.Sets.difference(left, right);
+    }
+
+    public static <A> Set<A> union(Set<A> left, Set<A> right) {
+        return org.eclipse.collections.impl.factory.Sets.union(left, right);
+    }
+    
+    public static <A> Set<? extends Set<A>> powerSet(Set<A> set) {
+        return org.eclipse.collections.impl.factory.Sets.powerSet(set);
+    }
+
+    public static <A> Set<List<A>> cartesianProduct(List<? extends Set<? extends A>> setsList) {
+        
+        class Suffix { // simple immutable linked list
+            private A head;
+            private Suffix next;
+
+            public Suffix(A head, Suffix next) {
+                super();
+                this.head = head;
+                this.next = next;
+            }
+
+            public List<A> toList() {
+                ArrayList<A> result = new ArrayList<>();
+                for (Suffix cursor = this; cursor!=null; cursor = cursor.next)
+                    result.add(cursor.head);
+                return result;
+            }
+        }
+        
+        // build result lists from end to start, in the form of suffixes 
+        Stream<Suffix> suffixes = Stream.of((Suffix) null /* empty suffix*/); 
+        for (int i = setsList.size()-1; i>=0; --i) { // iterate sets in reverse order
+            Set<? extends A> set = setsList.get(i);
+            suffixes = suffixes.flatMap(suffix -> set.stream().map(newElement -> new Suffix(newElement, suffix)));
+        }
+        
+        
+        return suffixes.map(Suffix::toList).collect(Collectors.toSet());
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Signed.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Signed.java
new file mode 100644
index 00000000..8f8bc228
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/Signed.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Objects;
+
+/**
+ * A piece of data associated with a direction. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public class Signed<Payload extends Comparable<Payload>> {
+
+    private final Payload payload;
+    private final Direction direction;
+
+    public Signed(final Direction direction, final Payload payload) {
+        this.payload = payload;
+        this.direction = direction;
+    }
+
+    public Payload getPayload() {
+        return payload;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(direction, payload);
+    }
+
+    @Override
+    public boolean equals(final Object obj) {
+        if (this == obj) {
+            return true;
+        } else if (obj == null || this.getClass() != obj.getClass()) {
+            return false;
+        } else {
+            @SuppressWarnings("rawtypes")
+            final Signed other = (Signed) obj;
+            return direction == other.direction && Objects.equals(payload, other.payload);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return this.direction.asSign() + this.payload.toString();
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonInstanceProvider.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonInstanceProvider.java
new file mode 100644
index 00000000..cc5963f7
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonInstanceProvider.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2015, Zoltan Ujhelyi, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+/**
+ * A provider implementation that always returns the same object instance. 
+ * @author Zoltan Ujhelyi
+ */
+public class SingletonInstanceProvider<T> implements IProvider<T>{
+
+    private T instance;
+
+    public SingletonInstanceProvider(T instance) {
+        Preconditions.checkArgument(instance != null, "Instance parameter must not be null.");
+        this.instance = instance;
+    }
+    
+    @Override
+    public T get() {
+        return instance;
+    }
+    
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonMemoryView.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonMemoryView.java
new file mode 100644
index 00000000..b303f9ad
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonMemoryView.java
@@ -0,0 +1,105 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2018, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Set;
+
+/**
+ * An immutable memory view that consists of a single non-null element with multiplicity 1.
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public final class SingletonMemoryView<Value> implements IMemoryView<Value> {
+
+    private Value wrapped;
+    private static final int ONE_HASH = Integer.valueOf(1).hashCode();
+
+    public SingletonMemoryView(Value value) {
+        this.wrapped = value;
+    }
+
+    @Override
+    public Iterator<Value> iterator() {
+        return new Iterator<Value>() {
+            boolean hasNext = true;
+            
+            @Override
+            public boolean hasNext() {
+                return hasNext;
+            }
+
+            @Override
+            public Value next() {
+                if (hasNext) {
+                    hasNext = false;
+                    return wrapped;
+                } else throw new NoSuchElementException();
+            }
+        };
+    }
+
+    @Override
+    public int getCount(Value value) {
+        return wrapped.equals(value) ? 1 : 0;
+    }
+
+    @Override
+    public int getCountUnsafe(Object value) {
+        return wrapped.equals(value) ? 1 : 0;
+    }
+
+    @Override
+    public boolean containsNonZero(Value value) {
+        return wrapped.equals(value);
+    }
+
+    @Override
+    public boolean containsNonZeroUnsafe(Object value) {
+        return wrapped.equals(value);
+    }
+
+    @Override
+    public int size() {
+        return 1;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+    @Override
+    public Set<Value> distinctValues() {
+        return Collections.singleton(wrapped);
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof IMemoryView<?>) {
+            IMemoryView<?> other = (IMemoryView<?>) obj;
+            if (1 != other.size()) return false;
+            if (1 != other.getCountUnsafe(wrapped)) return false;
+            return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public int hashCode() {
+        return wrapped.hashCode() ^ ONE_HASH;
+    }
+
+    @Override
+    public String toString() {
+        return "{" + wrapped + "}";
+    }
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/TimelyMemory.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/TimelyMemory.java
new file mode 100644
index 00000000..90fcad4d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/TimelyMemory.java
@@ -0,0 +1,517 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.NavigableMap;
+import java.util.Set;
+import java.util.TreeMap;
+
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.resumable.Resumable;
+import tools.refinery.viatra.runtime.matchers.util.resumable.UnmaskedResumable;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timeline;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Timelines;
+
+/**
+ * A timely memory implementation that incrementally maintains the {@link Timeline}s of tuples. The memory is capable of
+ * lazy folding (see {@link Resumable}).
+ * 
+ * @author Tamas Szabo
+ * @since 2.3
+ */
+public class TimelyMemory<Timestamp extends Comparable<Timestamp>> implements Clearable, UnmaskedResumable<Timestamp> {
+
+    protected final Map<Tuple, TreeMap<Timestamp, CumulativeCounter>> counters;
+    protected final Map<Tuple, Timeline<Timestamp>> timelines;
+    public final TreeMap<Timestamp, Map<Tuple, FoldingState>> foldingState;
+    protected final Set<Tuple> presentAtInfinity;
+    protected final boolean isLazy;
+    protected final Diff<Timestamp> EMPTY_DIFF = new Diff<Timestamp>();
+
+    public TimelyMemory() {
+        this(false);
+    }
+
+    public TimelyMemory(final boolean isLazy) {
+        this.counters = CollectionsFactory.createMap();
+        this.timelines = CollectionsFactory.createMap();
+        this.presentAtInfinity = CollectionsFactory.createSet();
+        this.isLazy = isLazy;
+        if (isLazy) {
+            this.foldingState = CollectionsFactory.createTreeMap();
+        } else {
+            this.foldingState = null;
+        }
+    }
+
+    @Override
+    public Set<Tuple> getResumableTuples() {
+        if (this.foldingState == null || this.foldingState.isEmpty()) {
+            return Collections.emptySet();
+        } else {
+            return this.foldingState.firstEntry().getValue().keySet();
+        }
+    }
+
+    @Override
+    public Timestamp getResumableTimestamp() {
+        if (this.foldingState == null || this.foldingState.isEmpty()) {
+            return null;
+        } else {
+            return this.foldingState.firstKey();
+        }
+    }
+
+    /**
+     * Registers the given folding state for the specified timestamp and tuple. If there is already a state stored, the
+     * two states will be merged together.
+     */
+    protected void addFoldingState(final Tuple tuple, final FoldingState state, final Timestamp timestamp) {
+        assert state.diff != 0;
+        final Map<Tuple, FoldingState> tupleMap = this.foldingState.computeIfAbsent(timestamp,
+                k -> CollectionsFactory.createMap());
+        tupleMap.compute(tuple, (k, v) -> {
+            return v == null ? state : v.merge(state);
+        });
+    }
+
+    @Override
+    public Map<Tuple, Diff<Timestamp>> resumeAt(final Timestamp timestamp) {
+        Timestamp current = this.getResumableTimestamp();
+        if (current == null) {
+            throw new IllegalStateException("There is othing to fold!");
+        } else if (current.compareTo(timestamp) != 0) {
+            // It can happen that already registered folding states end up having zero diffs,
+            // and we are instructed to continue folding at a timestamp that is higher
+            // than the lowest timestamp with a folding state.
+            // However, we only do garbage collection in doFoldingState, so now it is time to
+            // first clean up those states with zero diffs.
+            while (current != null && current.compareTo(timestamp) < 0) {
+                final Map<Tuple, FoldingState> tupleMap = this.foldingState.remove(current);
+                for (final Entry<Tuple, FoldingState> entry : tupleMap.entrySet()) {
+                    final Tuple key = entry.getKey();
+                    final FoldingState value = entry.getValue();
+                    if (value.diff != 0) {
+                        throw new IllegalStateException("Expected zero diff during garbage collection at " + current
+                                + ", but the diff was " + value.diff + "!");
+                    }
+                    doFoldingStep(key, value, current);
+                }
+                current = this.getResumableTimestamp();
+            }
+            if (current == null || current.compareTo(timestamp) != 0) {
+                throw new IllegalStateException("Expected to continue folding at " + timestamp + "!");
+            }
+        }
+
+        final Map<Tuple, Diff<Timestamp>> diffMap = CollectionsFactory.createMap();
+        final Map<Tuple, FoldingState> tupleMap = this.foldingState.remove(timestamp);
+        for (final Entry<Tuple, FoldingState> entry : tupleMap.entrySet()) {
+            final Tuple key = entry.getKey();
+            final FoldingState value = entry.getValue();
+            diffMap.put(key, doFoldingStep(key, value, timestamp));
+        }
+
+        if (this.foldingState.get(timestamp) != null) {
+            throw new IllegalStateException(
+                    "Folding at " + timestamp + " produced more folding work at the same timestamp!");
+        }
+
+        return diffMap;
+    }
+
+    protected Diff<Timestamp> doFoldingStep(final Tuple tuple, final FoldingState state, final Timestamp timestamp) {
+        final CumulativeCounter counter = getCounter(tuple, timestamp);
+        if (state.diff == 0) {
+            gcCounters(counter, tuple, timestamp);
+            return EMPTY_DIFF;
+        } else {
+            final Diff<Timestamp> resultDiff = new Diff<>();
+            final Timestamp nextTimestamp = this.counters.get(tuple).higherKey(timestamp);
+
+            final int oldCumulative = counter.cumulative;
+
+            counter.cumulative += state.diff;
+
+            computeDiffsLazy(state.diff < 0 ? Direction.DELETE : Direction.INSERT, oldCumulative, counter.cumulative,
+                    timestamp, nextTimestamp, resultDiff);
+
+            gcCounters(counter, tuple, timestamp);
+            updateTimeline(tuple, resultDiff);
+
+            // prepare folding state for next timestamp
+            if (nextTimestamp != null) {
+                // propagate the incoming diff, not the diff stored in counter
+                addFoldingState(tuple, new FoldingState(state.diff), nextTimestamp);
+            }
+
+            return resultDiff;
+        }
+    }
+
+    /**
+     * On-demand initializes and returns the counter for the given tuple and timestamp.
+     */
+    protected CumulativeCounter getCounter(final Tuple tuple, final Timestamp timestamp) {
+        final TreeMap<Timestamp, CumulativeCounter> counterTimeline = this.counters.computeIfAbsent(tuple,
+                k -> CollectionsFactory.createTreeMap());
+
+        final CumulativeCounter counter = counterTimeline.computeIfAbsent(timestamp, k -> {
+            final Entry<Timestamp, CumulativeCounter> previousCounter = counterTimeline.lowerEntry(k);
+            final int previousCumulative = previousCounter == null ? 0 : previousCounter.getValue().cumulative;
+            return new CumulativeCounter(0, previousCumulative);
+        });
+
+        return counter;
+    }
+
+    /**
+     * Garbage collects the counter of the given tuple and timestamp if the new diff is zero.
+     */
+    protected void gcCounters(final CumulativeCounter counter, final Tuple tuple, final Timestamp timestamp) {
+        if (counter.diff == 0) {
+            final TreeMap<Timestamp, CumulativeCounter> counterMap = this.counters.get(tuple);
+            counterMap.remove(timestamp);
+            if (counterMap.isEmpty()) {
+                this.counters.remove(tuple);
+            }
+        }
+    }
+
+    /**
+     * Utility method that computes the timeline diffs in case of lazy memories. The diffs will be inserted into the
+     * input parameter. This method computes diffs for entire plateaus that spans from timestamp to nextTimestamp.
+     * 
+     * Compared to the eager version of this method, the lazy version makes use of both the old and the new cumulative
+     * values because it can happen that the cumulative is incremented by a value that is larger than 1 (as folding
+     * states are merged together). This means that we cant decide whether the cumulative became positive by comparing
+     * the new value to 1.
+     */
+    protected void computeDiffsLazy(final Direction direction, final int oldCumulative, final int newCumulative,
+            final Timestamp timestamp, final Timestamp nextTimestamp, final Diff<Timestamp> diffs) {
+        if (direction == Direction.INSERT) {
+            if (newCumulative == 0) {
+                throw new IllegalStateException("Cumulative count can never be negative!");
+            } else {
+                if (oldCumulative == 0 /* current became positive */) {
+                    // (1) either we sent out a DELETE before and now we need to cancel it,
+                    // (2) or we just INSERT this for the first time
+                    diffs.add(new Signed<>(Direction.INSERT, timestamp));
+                    if (nextTimestamp != null) {
+                        diffs.add(new Signed<>(Direction.DELETE, nextTimestamp));
+                    }
+                } else /* current stays positive */ {
+                    // nothing to do
+                }
+            }
+        } else {
+            if (newCumulative < 0) {
+                throw new IllegalStateException("Cumulative count can never be negative!");
+            } else {
+                if (newCumulative == 0 /* current became zero */) {
+                    diffs.add(new Signed<>(Direction.DELETE, timestamp));
+                    if (nextTimestamp != null) {
+                        diffs.add(new Signed<>(Direction.INSERT, nextTimestamp));
+                    }
+                } else /* current stays positive */ {
+                    // nothing to do
+                }
+            }
+        }
+    }
+
+    /**
+     * Utility method that computes the timeline diffs in case of eager memories. The diffs will be inserted into the
+     * input parameter. This method computes diffs that describe momentary changes instead of plateaus. Returns a
+     * {@link SignChange} that describes how the sign has changed at the given timestamp.
+     */
+    protected SignChange computeDiffsEager(final Direction direction, final CumulativeCounter counter,
+            final SignChange signChangeAtPrevious, final Timestamp timestamp, final Diff<Timestamp> diffs) {
+        if (direction == Direction.INSERT) {
+            if (counter.cumulative == 0) {
+                throw new IllegalStateException("Cumulative count can never be negative!");
+            } else {
+                if (counter.cumulative == 1 /* current became positive */) {
+                    if (signChangeAtPrevious != SignChange.BECAME_POSITIVE) {
+                        // (1) either we sent out a DELETE before and now we need to cancel it,
+                        // (2) or we just INSERT this for the first time
+                        diffs.add(new Signed<>(Direction.INSERT, timestamp));
+                    } else {
+                        // we have already emitted this at the previous timestamp
+                        // both previous and current became positive
+                        throw new IllegalStateException(
+                                "This would mean that the diff at current is 0 " + counter.diff);
+                    }
+
+                    // remember for next timestamp
+                    return SignChange.BECAME_POSITIVE;
+                } else /* current stays positive */ {
+                    if (signChangeAtPrevious == SignChange.BECAME_POSITIVE) {
+                        // we sent out an INSERT before and now the timeline is positive already starting at previous
+                        // we need to cancel the effect of this with a DELETE
+                        diffs.add(new Signed<>(Direction.DELETE, timestamp));
+                    } else {
+                        // this is normal, both previous and current was positive and stays positive
+                    }
+
+                    // remember for next timestamp
+                    return SignChange.IRRELEVANT;
+                }
+            }
+        } else {
+            if (counter.cumulative < 0) {
+                throw new IllegalStateException("Cumulative count can never be negative!");
+            } else {
+                if (counter.cumulative == 0 /* current became zero */) {
+                    if (signChangeAtPrevious != SignChange.BECAME_ZERO) {
+                        // (1) either we sent out a INSERT before and now we need to cancel it,
+                        // (2) or we just DELETE this for the first time
+                        diffs.add(new Signed<>(Direction.DELETE, timestamp));
+                    } else {
+                        // we have already emitted this at the previous timestamp
+                        // both previous and current became zero
+                        throw new IllegalStateException(
+                                "This would mean that the diff at current is 0 " + counter.diff);
+                    }
+
+                    // remember for next timestamp
+                    return SignChange.BECAME_ZERO;
+                } else /* current stays positive */ {
+                    if (signChangeAtPrevious == SignChange.BECAME_ZERO) {
+                        // we sent out a DELETE before and now the timeline is zero already starting at previous
+                        // we need to cancel the effect of this with a INSERT
+                        diffs.add(new Signed<>(Direction.INSERT, timestamp));
+                    } else {
+                        // this is normal, both previous and current was positive and stays positive
+                    }
+
+                    // remember for next timestamp
+                    return SignChange.IRRELEVANT;
+                }
+            }
+        }
+    }
+
+    public Diff<Timestamp> put(final Tuple tuple, final Timestamp timestamp) {
+        if (this.isLazy) {
+            return putLazy(tuple, timestamp);
+        } else {
+            return putEager(tuple, timestamp);
+        }
+    }
+
+    public Diff<Timestamp> remove(final Tuple tuple, final Timestamp timestamp) {
+        if (this.isLazy) {
+            return removeLazy(tuple, timestamp);
+        } else {
+            return removeEager(tuple, timestamp);
+        }
+    }
+
+    protected Diff<Timestamp> putEager(final Tuple tuple, final Timestamp timestamp) {
+        final Diff<Timestamp> resultDiff = new Diff<>();
+        final CumulativeCounter counter = getCounter(tuple, timestamp);
+        ++counter.diff;
+
+        // before the INSERT timestamp, no change at all
+        // it cannot happen that those became positive in this round
+        SignChange signChangeAtPrevious = SignChange.IRRELEVANT;
+
+        final NavigableMap<Timestamp, CumulativeCounter> nextCounters = this.counters.get(tuple).tailMap(timestamp,
+                true);
+        for (final Entry<Timestamp, CumulativeCounter> currentEntry : nextCounters.entrySet()) {
+            final Timestamp currentTimestamp = currentEntry.getKey();
+            final CumulativeCounter currentCounter = currentEntry.getValue();
+            ++currentCounter.cumulative;
+            signChangeAtPrevious = computeDiffsEager(Direction.INSERT, currentCounter, signChangeAtPrevious,
+                    currentTimestamp, resultDiff);
+        }
+
+        gcCounters(counter, tuple, timestamp);
+        updateTimeline(tuple, resultDiff);
+
+        return resultDiff;
+    }
+
+    protected Diff<Timestamp> putLazy(final Tuple tuple, final Timestamp timestamp) {
+        final CumulativeCounter counter = getCounter(tuple, timestamp);
+        counter.diff += 1;
+        // before the INSERT timestamp, no change at all
+        // it cannot happen that those became positive in this round
+        addFoldingState(tuple, new FoldingState(+1), timestamp);
+        return EMPTY_DIFF;
+    }
+
+    protected Diff<Timestamp> removeEager(final Tuple tuple, final Timestamp timestamp) {
+        final Diff<Timestamp> resultDiff = new Diff<>();
+        final CumulativeCounter counter = getCounter(tuple, timestamp);
+        --counter.diff;
+
+        // before the DELETE timestamp, no change at all
+        // it cannot happen that those became zero in this round
+        SignChange signChangeAtPrevious = SignChange.IRRELEVANT;
+
+        final NavigableMap<Timestamp, CumulativeCounter> nextCounters = this.counters.get(tuple).tailMap(timestamp,
+                true);
+        for (final Entry<Timestamp, CumulativeCounter> currentEntry : nextCounters.entrySet()) {
+            final Timestamp currentTimestamp = currentEntry.getKey();
+            final CumulativeCounter currentCounter = currentEntry.getValue();
+            --currentCounter.cumulative;
+            signChangeAtPrevious = computeDiffsEager(Direction.DELETE, currentCounter, signChangeAtPrevious,
+                    currentTimestamp, resultDiff);
+        }
+
+        gcCounters(counter, tuple, timestamp);
+        updateTimeline(tuple, resultDiff);
+
+        return resultDiff;
+    }
+
+    protected Diff<Timestamp> removeLazy(final Tuple tuple, final Timestamp timestamp) {
+        final CumulativeCounter counter = getCounter(tuple, timestamp);
+        counter.diff -= 1;
+        // before the DELETE timestamp, no change at all
+        // it cannot happen that those became zero in this round
+        addFoldingState(tuple, new FoldingState(-1), timestamp);
+        return EMPTY_DIFF;
+    }
+
+    /**
+     * Updates and garbage collects the timeline of the given tuple based on the given timeline diff.
+     */
+    protected void updateTimeline(final Tuple tuple, final Diff<Timestamp> diff) {
+        if (!diff.isEmpty()) {
+            this.timelines.compute(tuple, (k, oldTimeline) -> {
+                this.presentAtInfinity.remove(tuple);
+                final Timeline<Timestamp> timeline = oldTimeline == null ? Timelines.createFrom(diff)
+                        : oldTimeline.mergeAdditive(diff);
+                if (timeline.isPresentAtInfinity()) {
+                    this.presentAtInfinity.add(tuple);
+                }
+                if (timeline.isEmpty()) {
+                    return null;
+                } else {
+                    return timeline;
+                }
+            });
+        }
+    }
+
+    /**
+     * @since 2.8
+     */
+    public Set<Tuple> getTuplesAtInfinity() {
+        return this.presentAtInfinity;
+    }
+
+    /**
+     * Returns the number of tuples that are present at the moment 'infinity'.
+     */
+    public int getCountAtInfinity() {
+        return this.presentAtInfinity.size();
+    }
+
+    /**
+     * Returns true if the given tuple is present at the moment 'infinity'.
+     */
+    public boolean isPresentAtInfinity(final Tuple tuple) {
+        final Timeline<Timestamp> timeline = this.timelines.get(tuple);
+        if (timeline == null) {
+            return false;
+        } else {
+            return timeline.isPresentAtInfinity();
+        }
+    }
+
+    public boolean isEmpty() {
+        return this.counters.isEmpty();
+    }
+
+    public int size() {
+        return this.counters.size();
+    }
+
+    public Set<Tuple> keySet() {
+        return this.counters.keySet();
+    }
+
+    public Map<Tuple, Timeline<Timestamp>> asMap() {
+        return this.timelines;
+    }
+
+    public Timeline<Timestamp> get(final ITuple tuple) {
+        return this.timelines.get(tuple);
+    }
+
+    @Override
+    public void clear() {
+        this.counters.clear();
+        this.timelines.clear();
+        if (this.foldingState != null) {
+            this.foldingState.clear();
+        }
+    }
+
+    public boolean containsKey(final ITuple tuple) {
+        return this.counters.containsKey(tuple);
+    }
+
+    @Override
+    public String toString() {
+        return this.counters + "\n" + this.timelines + "\n" + this.foldingState + "\n";
+    }
+
+    protected static final class CumulativeCounter {
+        protected int diff;
+        protected int cumulative;
+
+        protected CumulativeCounter(final int diff, final int cumulative) {
+            this.diff = diff;
+            this.cumulative = cumulative;
+        }
+
+        @Override
+        public String toString() {
+            return "{diff=" + this.diff + ", cumulative=" + this.cumulative + "}";
+        }
+
+    }
+
+    protected static final class FoldingState {
+        protected final int diff;
+
+        protected FoldingState(final int diff) {
+            this.diff = diff;
+        }
+
+        @Override
+        public String toString() {
+            return "{diff=" + this.diff + "}";
+        }
+
+        /**
+         * The returned result will never be null, even if the resulting diff is zero.
+         */
+        public FoldingState merge(final FoldingState that) {
+            Preconditions.checkArgument(that != null);
+            return new FoldingState(this.diff + that.diff);
+        }
+
+    }
+
+    protected enum SignChange {
+        BECAME_POSITIVE, BECAME_ZERO, IRRELEVANT;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/MaskedResumable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/MaskedResumable.java
new file mode 100644
index 00000000..ea70e61d
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/MaskedResumable.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.resumable;
+
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+
+/**
+ * A masked {@link Resumable} implementation, which maintains lazy folding per tuple signature. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public interface MaskedResumable<Timestamp extends Comparable<Timestamp>> extends Resumable<Timestamp> {
+
+    /**
+     * When called, the folding of the state shall be resumed at the given timestamp. The resumable is expected to
+     * do a folding step at the given timestamp only. Afterwards, folding shall be interrupted, even if there is more
+     * folding to do towards higher timestamps.
+     */
+    public Map<Tuple, Map<Tuple, Diff<Timestamp>>> resumeAt(final Timestamp timestamp);
+    
+    /**
+     * Returns the set of signatures for which lazy folding shall be resumed at the next timestamp. 
+     */
+    public Iterable<Tuple> getResumableSignatures();
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/Resumable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/Resumable.java
new file mode 100644
index 00000000..2861df20
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/Resumable.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.resumable;
+
+/**
+ * A resumable lazily folds its state towards higher timestamps. Folding shall be done in the increasing order of
+ * timestamps, and it shall be interrupted after each step. The resumable can then be instructed to resume the folding,
+ * one step at a time.
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public interface Resumable<Timestamp extends Comparable<Timestamp>> {
+
+    /**
+     * Returns the smallest timestamp where lazy folding shall be resumed, or null if there is no more folding to do in this
+     * resumable.
+     */
+    public Timestamp getResumableTimestamp();
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/UnmaskedResumable.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/UnmaskedResumable.java
new file mode 100644
index 00000000..1671940b
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/UnmaskedResumable.java
@@ -0,0 +1,36 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Tamas Szabo, Istvan Rath and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.resumable;
+
+import java.util.Map;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.timeline.Diff;
+
+/**
+ * A unmasked {@link Resumable} implementation, which maintains lazy folding without caring about tuple signatures. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public interface UnmaskedResumable<Timestamp extends Comparable<Timestamp>> extends Resumable<Timestamp> {
+
+    /**
+     * When called, the folding of the state shall be resumed at the given timestamp. The resumable is expected to
+     * do a folding step at the given timestamp only. Afterwards, folding shall be interrupted, even if there is more
+     * folding to do towards higher timestamps.
+     */
+    public Map<Tuple, Diff<Timestamp>> resumeAt(final Timestamp timestamp);
+
+    /**
+     * Returns the set of tuples for which lazy folding shall be resumed at the next timestamp. 
+     */
+    public Iterable<Tuple> getResumableTuples();
+    
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/CompactTimeline.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/CompactTimeline.java
new file mode 100644
index 00000000..0532d094
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/CompactTimeline.java
@@ -0,0 +1,111 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.timeline;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+
+/**
+ * A compact timeline may cosist of an arbitrary amount of moments. 
+ * It is backed by an {@link ArrayList}. 
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public class CompactTimeline<Timestamp extends Comparable<Timestamp>> extends Timeline<Timestamp> {
+
+    protected final List<Timestamp> elements;
+
+    CompactTimeline() {
+        this.elements = new ArrayList<>();
+    }
+    
+    CompactTimeline(final Timestamp timestamp) {
+        this();
+        this.elements.add(timestamp);
+    }
+    
+    CompactTimeline(final List<Timestamp> timestamps) {
+        this.elements = new ArrayList<>(timestamps.size());
+        this.elements.addAll(timestamps);
+    }
+
+    CompactTimeline(final Diff<Timestamp> diff) {
+        this.elements = new ArrayList<>(diff.size());
+        Direction expected = Direction.INSERT;
+        for (Signed<Timestamp> signed : diff) {
+            if (!expected.equals(signed.getDirection())) {
+                throw new IllegalStateException(String.format("Expected direction (%s) constraint violated! %s @%s",
+                        expected, diff, signed.getPayload()));
+            }
+            this.elements.add(signed.getPayload());
+            expected = expected.opposite();
+        }
+    }
+    
+    @Override
+    public Signed<Timestamp> getSigned(final int index) {
+        final Direction direction = index % 2 == 0 ? Direction.INSERT : Direction.DELETE;
+        return new Signed<>(direction, this.getUnsigned(index));
+    }
+
+    @Override
+    public Timestamp getUnsigned(final int index) {
+        if (this.elements.size() <= index) {
+            throw new IllegalArgumentException(
+                    "Timeline size (" + this.size() + ") is smaller than requested index " + index + "!");
+        } else {
+            return this.elements.get(index);
+        }
+    }
+
+    @Override
+    public int size() {
+        return this.elements.size();
+    }
+
+    @Override
+    public boolean isPresentAtInfinity() {
+        // if it has an odd length, then it ends with "INSERT"
+        return this.size() % 2 == 1;
+    }
+
+    @Override
+    public Iterable<Signed<Timestamp>> asChangeSequence() {
+        Iterable<Timestamp> outer = this.elements;
+        return () -> {
+            final Iterator<Timestamp> itr = outer.iterator();
+            return new Iterator<Signed<Timestamp>>() {
+                Direction direction = Direction.INSERT;
+
+                @Override
+                public boolean hasNext() {
+                    return itr.hasNext();
+                }
+
+                @Override
+                public Signed<Timestamp> next() {
+                    final Signed<Timestamp> result = new Signed<Timestamp>(direction, itr.next());
+                    direction = direction.opposite();
+                    return result;
+                }
+            };
+        };
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return this.elements.isEmpty();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Diff.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Diff.java
new file mode 100644
index 00000000..cec6049e
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Diff.java
@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.timeline;
+
+import java.util.ArrayList;
+
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+
+/**
+ * The description of a delta that specifies how a {@link Timeline} changes. It consists of {@link Signed} timestamps that
+ * depict the moments of insertions and deletions on the timeline.
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ * @param <Timestamp>
+ *            the type representing the timestamps
+ */
+public class Diff<Timestamp extends Comparable<Timestamp>> extends ArrayList<Signed<Timestamp>> {
+
+    private static final long serialVersionUID = 3853460426655994160L;
+
+    public Diff() {
+
+    }
+
+    public void appendWithCancellation(Signed<Timestamp> item) {
+        if (this.isEmpty()) {
+            this.add(item);
+        } else {
+            final Signed<Timestamp> last = this.get(this.size() - 1);
+            final int lastMinusItem = last.getPayload().compareTo(item.getPayload());
+            if (lastMinusItem == 0) {
+                if (last.getDirection() != item.getDirection()) {
+                    // cancellation
+                    this.remove(this.size() - 1);
+                } else {
+                    throw new IllegalStateException(
+                            "Trying to insert or delete for the second time at the same timestamp! " + item);
+                }
+            } else if (lastMinusItem > 0) {
+                throw new IllegalStateException(
+                        "Trying to append a timestamp that is smaller than the last one! " + last + " " + item);
+            } else {
+                this.add(item);
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/SingletonTimeline.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/SingletonTimeline.java
new file mode 100644
index 00000000..526a95f5
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/SingletonTimeline.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.timeline;
+
+import java.util.Collections;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+
+/**
+ * A timeline which solely consists of one timestamp value, representing a single insertion. Intuitively, a singleton
+ * timeline always represents a bump which starts at the given timestamp and lasts till plus infinity.
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public class SingletonTimeline<Timestamp extends Comparable<Timestamp>> extends Timeline<Timestamp> {
+
+    protected final Timestamp start;
+
+    SingletonTimeline(final Timestamp timestamp) {
+        this.start = timestamp;
+    }
+
+    SingletonTimeline(final Diff<Timestamp> diff) {
+        if (diff.size() != 1 || diff.get(0).getDirection() == Direction.DELETE) {
+            throw new IllegalArgumentException("There is only a single (insert) timestamp in the singleton timestamp!");
+        } else {
+            this.start = diff.get(0).getPayload();
+        }
+    }
+
+    @Override
+    public Signed<Timestamp> getSigned(final int index) {
+        return new Signed<>(Direction.INSERT, this.getUnsigned(index));
+    }
+
+    @Override
+    public Timestamp getUnsigned(final int index) {
+        if (index != 0) {
+            throw new IllegalArgumentException("There is only a single (insert) timestamp in the singleton timestamp!");
+        } else {
+            return this.start;
+        }
+    }
+
+    @Override
+    public int size() {
+        return 1;
+    }
+
+    @Override
+    public boolean isPresentAtInfinity() {
+        return true;
+    }
+
+    @Override
+    public Iterable<Signed<Timestamp>> asChangeSequence() {
+        return Collections.singletonList(this.getSigned(0));
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return false;
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timeline.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timeline.java
new file mode 100644
index 00000000..9214536c
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timeline.java
@@ -0,0 +1,146 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.timeline;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.Signed;
+
+/**
+ * A timeline describes the life cycle of a piece of data (typically a tuple in a relation) as a sequence of moments.
+ * Even moments represent appearances, odd moments represent disappearances. A timeline is immutable, once created, it
+ * is not possible to extend it with further moments.
+ * 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public abstract class Timeline<Timestamp extends Comparable<Timestamp>> {
+
+    public abstract Iterable<Signed<Timestamp>> asChangeSequence();
+
+    public abstract boolean isPresentAtInfinity();
+
+    public abstract boolean isEmpty();
+
+    public abstract int size();
+
+    public abstract Signed<Timestamp> getSigned(final int index);
+
+    public abstract Timestamp getUnsigned(final int index);
+
+    public Timeline<Timestamp> mergeMultiplicative(final Timeline<Timestamp> that) {
+        final List<Timestamp> result = new ArrayList<>();
+        int thisIdx = 0, thatIdx = 0;
+        Timestamp thisNext = thisIdx < this.size() ? this.getUnsigned(thisIdx) : null;
+        Timestamp thatNext = thatIdx < that.size() ? that.getUnsigned(thatIdx) : null;
+
+        while (thisNext != null || thatNext != null) {
+            int thisMinusThat = 0;
+            if (thisNext != null && thatNext != null) {
+                thisMinusThat = thisNext.compareTo(thatNext);
+            }
+            if (thisNext == null || thisMinusThat > 0) {
+                if (thisIdx % 2 == 1) {
+                    result.add(thatNext);
+                }
+                thatIdx++;
+                thatNext = thatIdx < that.size() ? that.getUnsigned(thatIdx) : null;
+            } else if (thatNext == null || thisMinusThat < 0) {
+                if (thatIdx % 2 == 1) {
+                    result.add(thisNext);
+                }
+                thisIdx++;
+                thisNext = thisIdx < this.size() ? this.getUnsigned(thisIdx) : null;
+            } else {
+                if (thisIdx % 2 == thatIdx % 2) {
+                    result.add(thisNext);
+                }
+                thisIdx++;
+                thatIdx++;
+                thatNext = thatIdx < that.size() ? that.getUnsigned(thatIdx) : null;
+                thisNext = thisIdx < this.size() ? this.getUnsigned(thisIdx) : null;
+            }
+        }
+
+        return Timelines.createFrom(result);
+    }
+
+    /**
+     * Merges this timeline with the given timestamp diff. The expectation is that the resulting timeline starts with an
+     * insertion. The logic is similar to a merge sort; we iterate side-by-side over the timeline and the diff. During
+     * the merge, cancellation can happen if at the same timestamp we observe different signs at the corresponding
+     * timeline and diff elements.
+     */
+    public Timeline<Timestamp> mergeAdditive(final Diff<Timestamp> diff) {
+        final Iterator<Signed<Timestamp>> thisItr = this.asChangeSequence().iterator();
+        final Iterator<Signed<Timestamp>> diffItr = diff.iterator();
+        final List<Timestamp> result = new ArrayList<>();
+        Direction expected = Direction.INSERT;
+        Signed<Timestamp> thisNext = thisItr.hasNext() ? thisItr.next() : null;
+        Signed<Timestamp> diffNext = diffItr.hasNext() ? diffItr.next() : null;
+
+        while (thisNext != null || diffNext != null) {
+            int thisMinusDiff = 0;
+            if (thisNext != null && diffNext != null) {
+                thisMinusDiff = thisNext.getPayload().compareTo(diffNext.getPayload());
+            }
+
+            if (thisNext == null || thisMinusDiff > 0) {
+                if (!expected.equals(diffNext.getDirection())) {
+                    throw new IllegalStateException(
+                            String.format("Expected direction (%s) constraint violated! %s %s @%s", expected, this,
+                                    diff, diffNext.getPayload()));
+                }
+                result.add(diffNext.getPayload());
+                diffNext = diffItr.hasNext() ? diffItr.next() : null;
+                expected = expected.opposite();
+            } else if (diffNext == null || thisMinusDiff < 0) {
+                if (!expected.equals(thisNext.getDirection())) {
+                    throw new IllegalStateException(
+                            String.format("Expected direction (%s) constraint violated! %s %s @%s", expected, this,
+                                    diff, thisNext.getPayload()));
+                }
+                result.add(thisNext.getPayload());
+                thisNext = thisItr.hasNext() ? thisItr.next() : null;
+                expected = expected.opposite();
+            } else {
+                // they cancel out each other
+                if (diffNext.getDirection().equals(thisNext.getDirection())) {
+                    throw new IllegalStateException(String.format("Changes do not cancel out each other! %s %s @%s",
+                            this, diff, thisNext.getPayload()));
+                }
+                diffNext = diffItr.hasNext() ? diffItr.next() : null;
+                thisNext = thisItr.hasNext() ? thisItr.next() : null;
+            }
+        }
+
+        return Timelines.createFrom(result);
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder builder = new StringBuilder();
+        builder.append("[");
+        boolean first = true;
+        for (final Signed<Timestamp> element : this.asChangeSequence()) {
+            if (first) {
+                first = false;
+            } else {
+                builder.append(", ");
+            }
+            builder.append(element.toString());
+        }
+        builder.append("]");
+        return builder.toString();
+    }
+
+}
diff --git a/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timelines.java b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timelines.java
new file mode 100644
index 00000000..747fda15
--- /dev/null
+++ b/subprojects/viatra-runtime/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timelines.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Tamas Szabo, itemis AG, Gabor Bergmann, IncQuery Labs Ltd.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.matchers.util.timeline;
+
+import java.util.List;
+
+/**
+ * Utility class for creating {@link Timeline}s. 
+ * @author Tamas Szabo
+ * @since 2.4
+ */
+public final class Timelines<Timestamp extends Comparable<Timestamp>> {
+
+    public static <Timestamp extends Comparable<Timestamp>> Timeline<Timestamp> createEmpty() {
+        return new CompactTimeline<Timestamp>();
+    }
+    
+    public static <Timestamp extends Comparable<Timestamp>> Timeline<Timestamp> createFrom(
+            final Diff<Timestamp> diffs) {
+        if (diffs.size() == 1) {
+            return new SingletonTimeline<Timestamp>(diffs);
+        } else {
+            return new CompactTimeline<Timestamp>(diffs);
+        }
+    }
+
+    public static <Timestamp extends Comparable<Timestamp>> Timeline<Timestamp> createFrom(
+            final List<Timestamp> timestamps) {
+        if (timestamps.size() == 1) {
+            return new SingletonTimeline<Timestamp>(timestamps.get(0));
+        } else {
+            return new CompactTimeline<Timestamp>(timestamps);
+        }
+    }
+
+    public static <Timestamp extends Comparable<Timestamp>> Timeline<Timestamp> createFrom(final Timestamp timestamp) {
+        return new SingletonTimeline<Timestamp>(timestamp);
+    }
+
+}