chore: import VIATRA source

Make our modifications more maintainable by editing the source code directly
instead of using reflection.

227 files changed, 21337 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/ViatraQueryRuntimeException.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/ViatraQueryRuntimeException.java
new file mode 100644
index 00000000..83f6f766
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/AverageAccumulator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/AverageAccumulator.java
new file mode 100644
index 00000000..2c09ede1
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleAverageOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleAverageOperator.java
new file mode 100644
index 00000000..e8a26afd
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleSumOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/DoubleSumOperator.java
new file mode 100644
index 00000000..744b0cd1
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/ExtremumOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/ExtremumOperator.java
new file mode 100644
index 00000000..ee4ceeb8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerAverageOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerAverageOperator.java
new file mode 100644
index 00000000..bf422476
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerSumOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/IntegerSumOperator.java
new file mode 100644
index 00000000..18584256
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongAverageOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongAverageOperator.java
new file mode 100644
index 00000000..d56c9507
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongSumOperator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/LongSumOperator.java
new file mode 100644
index 00000000..29ded090
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/avg.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/avg.java
new file mode 100644
index 00000000..c25678aa
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/count.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/count.java
new file mode 100644
index 00000000..8310a0ce
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/max.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/max.java
new file mode 100644
index 00000000..e0236223
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/min.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/min.java
new file mode 100644
index 00000000..6408c57b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/sum.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/aggregators/sum.java
new file mode 100644
index 00000000..69ff2e75
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/OrderedIterableMerge.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/OrderedIterableMerge.java
new file mode 100644
index 00000000..1917e909
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFind.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFind.java
new file mode 100644
index 00000000..c69f08e5
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFindNodeProperty.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/algorithms/UnionFindNodeProperty.java
new file mode 100644
index 00000000..82852f9c
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/CommonQueryHintOptions.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/CommonQueryHintOptions.java
new file mode 100644
index 00000000..317293bf
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ICallDelegationStrategy.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ICallDelegationStrategy.java
new file mode 100644
index 00000000..40853f46
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IMatcherCapability.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IMatcherCapability.java
new file mode 100644
index 00000000..104b68a8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackend.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackend.java
new file mode 100644
index 00000000..c85f10a4
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactory.java
new file mode 100644
index 00000000..e264ab3f
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactoryProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendFactoryProvider.java
new file mode 100644
index 00000000..8787814e
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendHintProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryBackendHintProvider.java
new file mode 100644
index 00000000..9bb76349
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryResultProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IQueryResultProvider.java
new file mode 100644
index 00000000..cd7d050f
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IUpdateable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/IUpdateable.java
new file mode 100644
index 00000000..baf7144a
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryEvaluationHint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryEvaluationHint.java
new file mode 100644
index 00000000..eab92128
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryHintOption.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/QueryHintOption.java
new file mode 100644
index 00000000..2c6bb4de
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ResultProviderRequestor.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/backend/ResultProviderRequestor.java
new file mode 100644
index 00000000..6ec6d53e
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryMetaContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryMetaContext.java
new file mode 100644
index 00000000..99611758
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryRuntimeContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/AbstractQueryRuntimeContext.java
new file mode 100644
index 00000000..c797eff9
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IInputKey.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IInputKey.java
new file mode 100644
index 00000000..4dbcca88
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IPosetComparator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IPosetComparator.java
new file mode 100644
index 00000000..e2d5bcee
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryBackendContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryBackendContext.java
new file mode 100644
index 00000000..04f00aaa
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryCacheContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryCacheContext.java
new file mode 100644
index 00000000..617207f6
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryMetaContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryMetaContext.java
new file mode 100644
index 00000000..4c22a3cb
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryResultProviderAccess.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryResultProviderAccess.java
new file mode 100644
index 00000000..7fecd01a
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContext.java
new file mode 100644
index 00000000..c2e90614
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContextListener.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IQueryRuntimeContextListener.java
new file mode 100644
index 00000000..7be27d56
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IndexingService.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/IndexingService.java
new file mode 100644
index 00000000..8210765d
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/InputKeyImplication.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/InputKeyImplication.java
new file mode 100644
index 00000000..2a403810
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/BaseInputKeyWrapper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/common/JavaTransitiveInstancesKey.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/context/surrogate/SurrogateQueryRegistry.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/AbstractTrivialMaskedMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/AbstractTrivialMaskedMemory.java
new file mode 100644
index 00000000..66587f77
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/DefaultMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/DefaultMaskedTupleMemory.java
new file mode 100644
index 00000000..92081409
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/IdentityMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/IdentityMaskedTupleMemory.java
new file mode 100644
index 00000000..dc59daf5
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/MaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/MaskedTupleMemory.java
new file mode 100644
index 00000000..62377624
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/NullaryMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/NullaryMaskedTupleMemory.java
new file mode 100644
index 00000000..7fa9e053
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/UnaryMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/UnaryMaskedTupleMemory.java
new file mode 100644
index 00000000..f34cc9e3
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyMaskedMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/AbstractTimelyTrivialMaskedMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyDefaultMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyIdentityMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyNullaryMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/memories/timely/TimelyUnaryMaskedTupleMemory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IOperationCompiler.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IOperationCompiler.java
new file mode 100644
index 00000000..c9f4b305
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IQueryPlannerStrategy.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/IQueryPlannerStrategy.java
new file mode 100644
index 00000000..6ce9d91b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/QueryProcessingException.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/QueryProcessingException.java
new file mode 100644
index 00000000..501ddf73
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlan.java
new file mode 100644
index 00000000..1998df9d
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlanFactory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/SubPlanFactory.java
new file mode 100644
index 00000000..d0df5fac
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/BuildHelper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/FunctionalDependencyHelper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/StatisticsHelper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/helpers/TypeHelper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PApply.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PEnumerate.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PJoin.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/POperation.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PProject.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/planning/operations/PStart.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/BasePConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/BasePConstraint.java
new file mode 100644
index 00000000..eda4aa25
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/DeferredPConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/DeferredPConstraint.java
new file mode 100644
index 00000000..d2bf088c
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/EnumerablePConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/EnumerablePConstraint.java
new file mode 100644
index 00000000..9129aa47
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IExpressionEvaluator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IExpressionEvaluator.java
new file mode 100644
index 00000000..686999f7
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IMultiQueryReference.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IMultiQueryReference.java
new file mode 100644
index 00000000..8f647c64
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IQueryReference.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IQueryReference.java
new file mode 100644
index 00000000..9ee05b39
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IRelationEvaluator.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IRelationEvaluator.java
new file mode 100644
index 00000000..e4c396d8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeConstraint.java
new file mode 100644
index 00000000..b72035a8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeInfoProviderConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/ITypeInfoProviderConstraint.java
new file mode 100644
index 00000000..ff127d38
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IValueProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/IValueProvider.java
new file mode 100644
index 00000000..d959adc4
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/InitializablePQuery.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/InitializablePQuery.java
new file mode 100644
index 00000000..a82d12ec
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/KeyedEnumerablePConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/KeyedEnumerablePConstraint.java
new file mode 100644
index 00000000..91eea817
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PBody.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PBody.java
new file mode 100644
index 00000000..c38dc23a
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PConstraint.java
new file mode 100644
index 00000000..ae2c4632
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PTraceable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PTraceable.java
new file mode 100644
index 00000000..f0241a9c
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PVariable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/PVariable.java
new file mode 100644
index 00000000..b6ea4861
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/TypeJudgement.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/TypeJudgement.java
new file mode 100644
index 00000000..4447b225
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/VariableDeferredPConstraint.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/VariableDeferredPConstraint.java
new file mode 100644
index 00000000..8ea6bb93
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AbstractMemorylessAggregationOperator.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/AggregatorType.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/BoundAggregator.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IAggregatorFactory.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/aggregations/IMultisetAggregationOperator.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/analysis/QueryAnalyzer.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/PAnnotation.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/annotations/ParameterReference.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/AggregatorConstraint.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/BaseTypeSafeConstraint.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Equality.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExportedParameter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/ExpressionEvaluation.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/Inequality.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/NegativePatternCall.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternCallBasedDeferred.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/PatternMatchCounter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/RelationEvaluation.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicdeferred/TypeFilterConstraint.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/AbstractTransitiveClosure.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryReflexiveTransitiveClosure.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/BinaryTransitiveClosure.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/Connectivity.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/ConstantValue.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/PositivePatternCall.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/RepresentativeElectionConstraint.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/basicenumerables/TypeConstraint.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/BasePQuery.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PDisjunction.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PParameterDirection.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PProblem.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueries.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQuery.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PQueryHeader.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/PVisibility.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/queries/QueryInitializationException.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/AbstractRewriterTraceSource.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/ConstraintRemovalReason.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/DefaultFlattenCallPredicate.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/FlattenerCopier.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IConstraintFilter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IDerivativeModificationReason.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IFlattenCallPredicate.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IPTraceableTraceProvider.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IRewriterTraceCollector.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/IVariableRenamer.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/MappingTraceCollector.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NeverFlattenCallPredicate.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/NopTraceCollector.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyCopier.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PBodyNormalizer.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PDisjunctionRewriterCacher.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/PQueryFlattener.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/RewriterException.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/SurrogateQueryRewriter.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/psystem/rewriters/VariableMappingExpressionEvaluatorWrapper.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/IStorageBackend.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/IStorageBackend.java
new file mode 100644
index 00000000..16f40358
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/IStorageBackend.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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.scopes;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableContext;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterBinary;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableWriterUnary;
+
+/**
+ * An abstract storage backend that instantiates tables and coordinates transactions.
+ * 
+ * <p><strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ * 
+ * @author Gabor Bergmann
+ * 
+ * @since 2.1
+ */
+public interface IStorageBackend {
+
+
+        /**
+         * Marks the beginning of a transaction.
+         * In transaction mode, table updates may be temporarily delayed ({@link tools.refinery.viatra.runtime.matchers.scopes.tables.IIndexTable} methods may return stale answers) for better performance.
+         */
+        void startTransaction();
+        /**
+         * Marks the end of a transaction.
+         * Any updates delayed during the transaction must now be flushed. 
+         */
+        void finishTransaction();
+
+        /**
+         * Creates an index table for a simple value set.
+     * @param unique client promises to only insert a given tuple with multiplicity one
+         */
+        ITableWriterUnary.Table<Object> createUnaryTable(IInputKey key, ITableContext tableContext, boolean unique);
+        /**
+         * Creates an index table for a simple source-target bidirectional mapping.
+     * @param unique client promises to only insert a given tuple with multiplicity one
+         */
+        ITableWriterBinary.Table<Object,Object> createBinaryTable(IInputKey key, ITableContext tableContext, boolean unique);
+        
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleLocalStorageBackend.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleLocalStorageBackend.java
new file mode 100644
index 00000000..fd1f7b7e
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleLocalStorageBackend.java
@@ -0,0 +1,51 @@
+/*******************************************************************************
+ * 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.scopes;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableContext;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.SimpleBinaryTable;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.SimpleUnaryTable;
+
+/**
+ * Basic storage backend implementation based on local collections.
+ * 
+ * <p><strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.1
+ */
+public class SimpleLocalStorageBackend implements IStorageBackend {
+
+        @Override
+        public void startTransaction() {
+                // NOP
+        }
+
+        @Override
+        public void finishTransaction() {
+                // NOP
+        }
+
+        @Override
+        public SimpleUnaryTable<Object> createUnaryTable(IInputKey key, ITableContext tableContext, boolean unique) {
+                return new SimpleUnaryTable<>(key, tableContext, unique);
+        }
+
+        @Override
+        public SimpleBinaryTable<Object, Object> createBinaryTable(IInputKey key, ITableContext tableContext,
+                                                                                                                           boolean unique) {
+                return new SimpleBinaryTable<>(key, tableContext, unique);
+        }
+
+
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleRuntimeContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleRuntimeContext.java
new file mode 100644
index 00000000..a3a827dc
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/SimpleRuntimeContext.java
@@ -0,0 +1,132 @@
+/*******************************************************************************
+ * 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.scopes;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.concurrent.Callable;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.context.IndexingService;
+import tools.refinery.viatra.runtime.matchers.context.common.JavaTransitiveInstancesKey;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.IIndexTable;
+import tools.refinery.viatra.runtime.matchers.tuple.ITuple;
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+
+/**
+ * A simple demo implementation of the IQRC interface using tables.
+ * 
+ * <p>
+ * Usage: first, instantiate {@link IIndexTable} tables with this as the 'tableContext' argument, and call
+ * {@link #registerIndexTable(IIndexTable)} manually to register them. Afterwards, they will be visible to the query
+ * backends.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public class SimpleRuntimeContext extends TabularRuntimeContext {
+
+    private IQueryMetaContext metaContext;
+
+    public SimpleRuntimeContext(IQueryMetaContext metaContext) {
+        this.metaContext = metaContext;
+    }
+
+    @Override
+    public void logError(String message) {
+        System.err.println(message);
+    }
+
+    @Override
+    public IQueryMetaContext getMetaContext() {
+        return metaContext;
+    }
+
+    @Override
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+        try {
+            return callable.call();
+        } catch (Exception e) {
+            throw new InvocationTargetException(e);
+        }
+    }
+
+    @Override
+    public boolean isCoalescing() {
+        return false;
+    }
+
+    @Override
+    public boolean isIndexed(IInputKey key, IndexingService service) {
+        return peekIndexTable(key) != null;
+    }
+
+    @Override
+    public void ensureIndexed(IInputKey key, IndexingService service) {
+        if (peekIndexTable(key) == null)
+            throw new IllegalArgumentException(key.getPrettyPrintableName());
+    }
+
+    @Override
+    public Object wrapElement(Object externalElement) {
+        return externalElement;
+    }
+
+    @Override
+    public Object unwrapElement(Object internalElement) {
+        return internalElement;
+    }
+
+    @Override
+    public Tuple wrapTuple(Tuple externalElements) {
+        return externalElements;
+    }
+
+    @Override
+    public Tuple unwrapTuple(Tuple internalElements) {
+        return internalElements;
+    }
+
+    @Override
+    public void ensureWildcardIndexing(IndexingService service) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void executeAfterTraversal(Runnable runnable) throws InvocationTargetException {
+        runnable.run();
+    }
+
+    @Override
+    protected boolean isContainedInStatelessKey(IInputKey key, ITuple seed) {
+        if (key instanceof JavaTransitiveInstancesKey) {
+            Class<?> instanceClass = forceGetWrapperInstanceClass((JavaTransitiveInstancesKey) key);
+            return instanceClass != null && instanceClass.isInstance(seed.get(0));
+        } else
+            throw new IllegalArgumentException(key.getPrettyPrintableName());
+    }
+
+    private Class<?> forceGetWrapperInstanceClass(JavaTransitiveInstancesKey key) {
+        Class<?> instanceClass;
+        try {
+            instanceClass = key.forceGetWrapperInstanceClass();
+        } catch (ClassNotFoundException e) {
+            logError(
+                    "Could not load instance class for type constraint " + key.getWrappedKey() + ": " + e.getMessage());
+            instanceClass = null;
+        }
+        return instanceClass;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/TabularRuntimeContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/TabularRuntimeContext.java
new file mode 100644
index 00000000..e99e24d3
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/TabularRuntimeContext.java
@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * 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.scopes;
+
+import java.util.Map;
+import java.util.Optional;
+
+import tools.refinery.viatra.runtime.matchers.context.AbstractQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContextListener;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.IIndexTable;
+import tools.refinery.viatra.runtime.matchers.scopes.tables.ITableContext;
+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;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * An abstract runtime context that serves enumerable input key instances from tables.
+ * 
+ * <p>
+ * Usage: first, instantiate {@link IIndexTable} tables with this as the 'tableContext' argument. Call
+ * {@link #registerIndexTable(IIndexTable)} to register them; this may happen either during a coalesced indexing, or on
+ * external initiation. Afterwards, they will be visible to the query backends.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ * 
+ * @author Gabor Bergmann
+ * @since 2.0
+ */
+public abstract class TabularRuntimeContext extends AbstractQueryRuntimeContext implements ITableContext {
+
+    private Map<IInputKey, IIndexTable> instanceTables = CollectionsFactory.createMap();
+
+    public void registerIndexTable(IIndexTable table) {
+        IInputKey inputKey = table.getInputKey();
+        instanceTables.put(inputKey, table);
+    }
+
+    /**
+     * @return null if the table is not registered
+     */
+    public IIndexTable peekIndexTable(IInputKey key) {
+        return instanceTables.get(key);
+    }
+
+    /**
+     * If the table is not registered, {@link #handleUnregisteredTableRequest(IInputKey)} is invoked; it may handle it
+     * by raising an error or e.g. on-demand index construction
+     */
+    public IIndexTable getIndexTable(IInputKey key) {
+        IIndexTable table = instanceTables.get(key);
+        if (table != null)
+            return table;
+        else
+            return handleUnregisteredTableRequest(key);
+    }
+
+    /**
+     * Override this to provide on-demand table registration
+     */
+    protected IIndexTable handleUnregisteredTableRequest(IInputKey key) {
+        throw new IllegalArgumentException(key.getPrettyPrintableName());
+    }
+
+    @Override
+    public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+        return getIndexTable(key).countTuples(seedMask, seed);
+    }
+    
+    @Override
+    public Optional<Long> estimateCardinality(IInputKey key, TupleMask groupMask, Accuracy requiredAccuracy) {
+        return getIndexTable(key).estimateProjectionSize(groupMask, requiredAccuracy);
+    }
+
+    @Override
+    public Iterable<Tuple> enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) {
+        return getIndexTable(key).enumerateTuples(seedMask, seed);
+    }
+
+    @Override
+    public Iterable<? extends Object> enumerateValues(IInputKey key, TupleMask seedMask, ITuple seed) {
+        return getIndexTable(key).enumerateValues(seedMask, seed);
+    }
+
+    @Override
+    public boolean containsTuple(IInputKey key, ITuple seed) {
+        if (key.isEnumerable()) {
+            return getIndexTable(key).containsTuple(seed);
+        } else {
+            return isContainedInStatelessKey(key, seed);
+        }
+    }
+    
+    @Override
+    public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
+        getIndexTable(key).addUpdateListener(seed, listener);
+    }
+    @Override
+    public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) {
+        getIndexTable(key).removeUpdateListener(seed, listener);
+    }
+    
+    /**
+     * Handles non-enumerable input keys that are not backed by a table
+     */
+    protected abstract boolean isContainedInStatelessKey(IInputKey key, ITuple seed);
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/AbstractIndexTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/AbstractIndexTable.java
new file mode 100644
index 00000000..7b557c33
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/AbstractIndexTable.java
@@ -0,0 +1,266 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import java.util.List;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContextListener;
+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.IMultiLookup;
+
+/**
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public abstract class AbstractIndexTable implements IIndexTable {
+
+    private IInputKey inputKey;
+    protected ITableContext tableContext;
+    
+    protected final TupleMask emptyMask;
+    protected final Tuple emptyTuple;
+
+
+    public AbstractIndexTable(IInputKey inputKey, ITableContext tableContext) {
+        this.inputKey = inputKey;
+        this.tableContext = tableContext;
+        
+        this.emptyMask = TupleMask.empty(getInputKey().getArity());
+        this.emptyTuple = Tuples.flatTupleOf(new Object[inputKey.getArity()]);
+    }
+
+    @Override
+    public String toString() {
+        return this.getClass().getSimpleName() + ":" + inputKey.getPrettyPrintableName();
+    }
+
+    @Override
+    public IInputKey getInputKey() {
+        return inputKey;
+    }
+
+    protected void logError(String message) {
+        tableContext.logError(message);
+    }
+    
+    
+    /// UPDATE HANDLING SECTION
+    
+    // The entire mechanism is designed to accommodate a large number of update listeners,
+    // but maybe there will typically be only a single, universal (unseeded) listener? 
+    // TODO Create special handling for that case. 
+    
+    // Invariant: true iff #listenerGroupsAndSeed is nonempty
+    protected boolean emitNotifications = false; 
+    // Subscribed listeners grouped by their seed mask (e.g. all those that seed columns 2 and 5 are together), 
+    // groups are stored in a list for quick delivery-time iteration (at the expense of adding / removing);
+    // individual listeners can be looked up based on their seed tuple 
+    protected List<IListenersWithSameMask> listenerGroups = CollectionsFactory.createObserverList();
+
+    
+    /**
+     * Implementors shall call this to deliver all notifications.
+     * Call may be conditioned to {@link #emitNotifications}
+     */
+    protected void deliverChangeNotifications(Tuple updateTuple, boolean isInsertion) {
+        for (IListenersWithSameMask listenersForSeed : listenerGroups) {
+            listenersForSeed.deliver(updateTuple, isInsertion);
+        }
+    }
+    
+    @Override
+    public void addUpdateListener(Tuple seed, IQueryRuntimeContextListener listener) {
+        TupleMask seedMask;
+        if (seed == null) {
+            seed = emptyTuple;
+            seedMask = emptyMask;
+        } else {
+            seedMask = TupleMask.fromNonNullIndices(seed);
+        }
+        IListenersWithSameMask listenerGroup = getListenerGroup(seedMask);
+        if (listenerGroup == null) { // create new group
+            switch (seedMask.getSize()) {
+            case 0:
+                listenerGroup = new UniversalListeners();
+                break;
+            case 1: 
+                listenerGroup = new ColumnBoundListeners(seedMask.indices[0]);
+                break;
+            default:
+                listenerGroup = new GenericBoundListeners(seedMask);                        
+            }
+            listenerGroups.add(listenerGroup);
+            emitNotifications = true;
+        }
+        listenerGroup.addUpdateListener(seed, listener);
+    }
+
+    @Override
+    public void removeUpdateListener(Tuple seed, IQueryRuntimeContextListener listener) {
+        TupleMask seedMask;
+        if (seed == null) {
+            seed = emptyTuple;
+            seedMask = emptyMask;
+        } else {
+            seedMask = TupleMask.fromNonNullIndices(seed);
+        }
+        IListenersWithSameMask listenerGroup = getListenerGroup(seedMask);
+        if (listenerGroup == null) 
+            throw new IllegalStateException("no listener subscribed with mask" + seedMask);
+        
+        if (listenerGroup.removeUpdateListener(seed, listener)) {
+            listenerGroups.remove(listenerGroup);
+            emitNotifications = !listenerGroups.isEmpty();
+        }
+    }
+    
+    protected IListenersWithSameMask getListenerGroup(TupleMask seedMask) {
+        for (IListenersWithSameMask candidateGroup : listenerGroups) { // group already exists?
+            if (seedMask.equals(candidateGroup.getSeedMask())) {
+                return candidateGroup;
+            }
+        }
+        return null;
+    }
+    
+    
+    /**
+     * Represents all listeners subscribed to seeds with the given seed mask.
+     * 
+     * @author Bergmann Gabor
+     */
+    protected static interface IListenersWithSameMask { 
+        
+        public TupleMask getSeedMask();
+        
+        public void deliver(Tuple updateTuple, boolean isInsertion);
+        
+        public void addUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener);
+        /**
+         * @return true if this was the last listener, and the {@link IListenersWithSameMask} can be disposed of.
+         */
+        public boolean removeUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener);
+    }
+    /** 
+     * Listeners interested in all tuples
+     */
+    protected final class UniversalListeners implements IListenersWithSameMask {
+        private final TupleMask mask = TupleMask.empty(inputKey.getArity());
+        private List<IQueryRuntimeContextListener> listeners = CollectionsFactory.createObserverList();
+        
+        @Override
+        public TupleMask getSeedMask() {
+            return mask;
+        }
+        @Override
+        public void deliver(Tuple updateTuple, boolean isInsertion) {
+            IInputKey key = inputKey;
+            for (IQueryRuntimeContextListener listener : listeners) {
+                listener.update(key, updateTuple, isInsertion);
+            }
+        }
+        @Override
+        public void addUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            listeners.add(listener);
+        }
+        @Override
+        public boolean removeUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            listeners.remove(listener);
+            return listeners.isEmpty();
+        }
+    }
+    /** 
+     * Listeners interested in all tuples seeded by a single columns
+     */
+    protected final class ColumnBoundListeners implements IListenersWithSameMask {
+        private int seedPosition;
+        protected final TupleMask mask;
+        // indexed by projected seed tuple
+        protected IMultiLookup<Object,IQueryRuntimeContextListener> listeners = 
+                CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+        
+        public ColumnBoundListeners(int seedPosition) {
+            this.seedPosition = seedPosition;
+            this.mask = TupleMask.selectSingle(seedPosition, inputKey.getArity());
+        }
+        
+        @Override
+        public TupleMask getSeedMask() {
+            return mask;
+        }
+        @Override
+        public void deliver(Tuple updateTuple, boolean isInsertion) {
+            IInputKey key = inputKey;
+            Object projectedSeed = updateTuple.get(seedPosition);
+           for (IQueryRuntimeContextListener listener : listeners.lookupOrEmpty(projectedSeed)) {
+                listener.update(key, updateTuple, isInsertion);
+            }
+        }
+        @Override
+        public void addUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            Object projectedSeed = originalSeed.get(seedPosition);
+            listeners.addPair(projectedSeed, listener);
+        }
+        @Override
+        public boolean removeUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            Object projectedSeed = originalSeed.get(seedPosition);
+            listeners.removePair(projectedSeed, listener);
+            return listeners.countKeys() == 0;
+        }
+    }
+   /** 
+     * Listeners interested in all tuples seeded by a tuple of values
+     */
+    protected final class GenericBoundListeners implements IListenersWithSameMask {
+        protected final TupleMask mask;
+        // indexed by projected seed tuple
+        protected IMultiLookup<Tuple,IQueryRuntimeContextListener> listeners = 
+                CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+        
+        public GenericBoundListeners(TupleMask mask) {
+            this.mask = mask;
+        }
+        
+        @Override
+        public TupleMask getSeedMask() {
+            return mask;
+        }
+        @Override
+        public void deliver(Tuple updateTuple, boolean isInsertion) {
+            IInputKey key = inputKey;
+            Tuple projectedSeed = mask.transform(updateTuple);
+            for (IQueryRuntimeContextListener listener : listeners.lookupOrEmpty(projectedSeed)) {
+                listener.update(key, updateTuple, isInsertion);
+            }
+        }
+        @Override
+        public void addUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            Tuple projectedSeed = mask.transform(originalSeed);
+            listeners.addPair(projectedSeed, listener);
+        }
+        @Override
+        public boolean removeUpdateListener(Tuple originalSeed, IQueryRuntimeContextListener listener) {
+            Tuple projectedSeed = mask.transform(originalSeed);
+            listeners.removePair(projectedSeed, listener);
+            return listeners.countKeys() == 0;
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DefaultIndexTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DefaultIndexTable.java
new file mode 100644
index 00000000..39475d11
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DefaultIndexTable.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.scopes.tables;
+
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.memories.MaskedTupleMemory;
+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;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.IMemory;
+
+/**
+ * Demo default implementation.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public class DefaultIndexTable extends AbstractIndexTable implements ITableWriterGeneric {
+
+    protected IMemory<Tuple> rows = CollectionsFactory.createMultiset(); // TODO use SetMemory if unique
+    protected Map<TupleMask, MaskedTupleMemory<?>> indexMemories = CollectionsFactory.createMap();
+    private boolean unique;
+
+    /**
+     * @param unique
+     *            client promises to only insert a given tuple with multiplicity one
+     */
+    public DefaultIndexTable(IInputKey inputKey, ITableContext tableContext, boolean unique) {
+        super(inputKey, tableContext);
+        this.unique = unique;
+    }
+
+    @Override
+    public void write(Direction direction, Tuple row) {
+        if (direction == Direction.INSERT) {
+            boolean changed = rows.addOne(row);
+            if (unique && !changed) {
+                String msg = String.format(
+                        "Error: trying to add duplicate row %s to the unique table %s. This indicates some errors in underlying model representation.",
+                        row, getInputKey().getPrettyPrintableName());
+                logError(msg);
+            }
+            if (changed) {
+                for (MaskedTupleMemory<?> indexMemory : indexMemories.values()) {
+                    indexMemory.add(row);
+                }
+                if (emitNotifications) {
+                    deliverChangeNotifications(row, true);
+                }
+            }
+        } else { // DELETE
+            boolean changed = rows.removeOne(row);
+            if (unique && !changed) {
+                String msg = String.format(
+                        "Error: trying to remove duplicate value %s from the unique table %s. This indicates some errors in underlying model representation.",
+                        row, getInputKey().getPrettyPrintableName());
+                logError(msg);
+            }
+            if (changed) {
+                for (MaskedTupleMemory<?> indexMemory : indexMemories.values()) {
+                    indexMemory.remove(row);
+                }
+                if (emitNotifications) {
+                    deliverChangeNotifications(row, false);
+                }
+            }
+        }
+    }
+
+    @Override
+    public boolean containsTuple(ITuple seed) {
+        return rows.distinctValues().contains(seed);
+    }
+
+    private MaskedTupleMemory<?> getIndexMemory(TupleMask seedMask) {
+        return indexMemories.computeIfAbsent(seedMask, mask -> {
+            MaskedTupleMemory<?> memory = MaskedTupleMemory.create(seedMask, MemoryType.SETS, DefaultIndexTable.this);
+            for (Tuple tuple : rows.distinctValues()) {
+                memory.add(tuple);
+            }
+            return memory;
+        });
+    }
+    
+    @Override
+    public int countTuples(TupleMask seedMask, ITuple seed) {
+        switch (seedMask.getSize()) {
+        case 0: // unseeded
+            return rows.size();
+        default:
+            return getIndexMemory(seedMask).getOrEmpty(seed).size();
+        }
+    }
+
+    @Override
+    public Optional<Long> estimateProjectionSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        // always exact count
+        if (groupMask.getSize() == 0) {
+            return rows.size() == 0 ? Optional.of(0L) : Optional.of(1L);
+        } else if (groupMask.getSize() == this.emptyTuple.getSize()) {
+            return Optional.of((long) rows.size());
+        } else { 
+            return Optional.of((long)getIndexMemory(groupMask).getKeysetSize());
+        }
+    }
+
+    @Override
+    public Iterable<Tuple> enumerateTuples(TupleMask seedMask, ITuple seed) {
+        return getIndexMemory(seedMask).getOrEmpty(seed);
+    }
+    
+    @Override
+    public Stream<? extends Tuple> streamTuples(TupleMask seedMask, ITuple seed) {
+        return getIndexMemory(seedMask).getOrEmpty(seed).stream();
+    }
+
+    @Override
+    public Stream<? extends Object> streamValues(TupleMask seedMask, ITuple seed) {
+        // we assume there is a single omitted index in the mask
+        int queriedColumn = seedMask.getFirstOmittedIndex().getAsInt();
+        return getIndexMemory(seedMask).getOrEmpty(seed).stream()
+                .map(row2 -> row2.get(queriedColumn));
+    }
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DisjointUnionTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DisjointUnionTable.java
new file mode 100644
index 00000000..a3a65f14
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/DisjointUnionTable.java
@@ -0,0 +1,192 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContextListener;
+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.Accuracy;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+
+/**
+ * Disjoint union of the provided child tables.
+ * 
+ * Used e.g. to present a transitive instance table as a view composed from direct instance tables.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public class DisjointUnionTable extends AbstractIndexTable {
+
+    protected List<IIndexTable> childTables = CollectionsFactory.createObserverList();
+
+    public DisjointUnionTable(IInputKey inputKey, ITableContext tableContext) {
+        super(inputKey, tableContext);
+    }
+
+    public List<IIndexTable> getChildTables() {
+        return Collections.unmodifiableList(childTables);
+    }
+
+    /**
+     * Precondition: the new child currently is, and will forever stay, disjoint from any other child tables.
+     */
+    public void addChildTable(IIndexTable child) {
+        if (getInputKey().getArity() != child.getInputKey().getArity())
+            throw new IllegalArgumentException(child.toString());
+
+        childTables.add(child);
+        
+        if (emitNotifications) {
+            for (Tuple tuple : child.enumerateTuples(emptyMask, Tuples.staticArityFlatTupleOf())) {
+                deliverChangeNotifications(tuple, true);
+            }
+        }
+    }
+
+    @Override
+    public int countTuples(TupleMask seedMask, ITuple seed) {
+        int count = 0;
+        for (IIndexTable child : childTables) {
+            count += child.countTuples(seedMask, seed);
+        }
+        return count;
+    }
+
+
+    @Override
+    public Optional<Long> estimateProjectionSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        // exact results for trivial projections
+        if (groupMask.getSize() == 0) {
+            for (IIndexTable child : childTables) {
+                if (0 != child.countTuples(this.emptyMask, Tuples.staticArityFlatTupleOf()))
+                    return Optional.of(1L);
+            }
+            return Optional.of(0L);
+        } else if (groupMask.getSize() == emptyTuple.getSize()) {
+            return Optional.of((long)countTuples(this.emptyMask, Tuples.staticArityFlatTupleOf()));
+        }
+        // summing child tables is an upper bound
+        if (Accuracy.BEST_UPPER_BOUND.atLeastAsPreciseAs(requiredAccuracy)) {
+            return Optional.of((long)countTuples(this.emptyMask, Tuples.staticArityFlatTupleOf()));
+        } else { // (Accuracy.BEST_LOWER_BOUND == requiredAccuracy)  
+            //projections of child tables may coincide, but the largest one is still a lower bound
+            Optional<Long> maxProjection = Optional.empty();
+            for (IIndexTable child : childTables) {
+                Optional<Long> estimateOfChild = child.estimateProjectionSize(groupMask, requiredAccuracy);
+                if (estimateOfChild.isPresent()) {
+                    maxProjection = Optional.of(Math.max(estimateOfChild.get(), maxProjection.orElse(0L)));
+                }
+            }
+            return maxProjection;
+        } 
+    }
+    
+    @Override
+    public Stream<? extends Tuple> streamTuples(TupleMask seedMask, ITuple seed) {
+        Stream<? extends Tuple> stream = Stream.empty();
+        for (IIndexTable child : childTables) {
+            Stream<? extends Tuple> childStream = child.streamTuples(seedMask, seed);
+            stream = Stream.concat(stream, childStream);
+        }
+        return stream;
+    }
+
+    @Override
+    public Stream<? extends Object> streamValues(TupleMask seedMask, ITuple seed) {
+        Stream<? extends Object> stream = Stream.empty();
+        for (IIndexTable child : childTables) {
+            Stream<? extends Object> childStream = child.streamValues(seedMask, seed);
+            stream = Stream.concat(stream, childStream);
+        }
+        return stream;
+    }
+
+    @Override
+    public boolean containsTuple(ITuple seed) {
+        for (IIndexTable child : childTables) {
+            if (child.containsTuple(seed))
+                return true;
+        }
+        return false;
+    }
+    
+    @Override
+    public void addUpdateListener(Tuple seed, IQueryRuntimeContextListener listener) {
+        super.addUpdateListener(seed, listener);
+        
+        for (IIndexTable table : childTables) {
+            table.addUpdateListener(seed, new ListenerWrapper(listener));
+        }
+    }
+    @Override
+    public void removeUpdateListener(Tuple seed, IQueryRuntimeContextListener listener) {
+        super.removeUpdateListener(seed, listener);
+        
+        for (IIndexTable table : childTables) {
+            table.removeUpdateListener(seed, new ListenerWrapper(listener));
+        }
+    }
+    
+    
+    // TODO this would not be necessary 
+    // if we moved from IQRCL to an interface that does not expose the input key
+    private class ListenerWrapper implements IQueryRuntimeContextListener {
+
+        private IQueryRuntimeContextListener wrappedListener;
+        public ListenerWrapper(IQueryRuntimeContextListener wrappedListener) {
+            this.wrappedListener = wrappedListener;
+        }
+        
+        @Override
+        public void update(IInputKey key, Tuple updateTuple, boolean isInsertion) {
+            wrappedListener.update(getInputKey(), updateTuple, isInsertion);
+        }
+        
+        @Override
+        public int hashCode() {
+            return Objects.hash(wrappedListener, DisjointUnionTable.this);
+        }
+        @Override
+        public boolean equals(Object obj) {
+            if (this == obj)
+                return true;
+            if (obj == null)
+                return false;
+            if (getClass() != obj.getClass())
+                return false;
+            ListenerWrapper other = (ListenerWrapper) obj;
+            if (!getOuterType().equals(other.getOuterType()))
+                return false;
+            return Objects.equals(wrappedListener, other.wrappedListener);
+        }
+        private DisjointUnionTable getOuterType() {
+            return DisjointUnionTable.this;
+        }
+        @Override
+        public String toString() {
+            return "Wrapper to DisjointUnion("+getInputKey().getPrettyPrintableName()+") for " + wrappedListener;
+        }
+    }
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/IIndexTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/IIndexTable.java
new file mode 100644
index 00000000..be375393
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/IIndexTable.java
@@ -0,0 +1,212 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import java.util.Iterator;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+import tools.refinery.viatra.runtime.matchers.context.IQueryMetaContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContext;
+import tools.refinery.viatra.runtime.matchers.context.IQueryRuntimeContextListener;
+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;
+
+/**
+ * Read-only interface that provides the {@link IInputKey}-specific slice of an instance store to realize a
+ * {@link IQueryRuntimeContext}. Implemented by a customizable data store that is responsible for:
+ * <ul>
+ * <li>storing the instance tuples of the {@link IInputKey},</li>
+ * <li>providing efficient lookup via storage-specific indexing,</li>
+ * <li>delivering notifications. (TODO not designed yet)</li>
+ * </ul>
+ * 
+ * <p>
+ * Can be specialized for unary / binary / etc., opposite edges or node subtypes, specific types, distributed storage,
+ * etc.
+ * <p>
+ * Writeable API is specific to the customized implementations (e.g. unary).
+ * 
+ * <p>
+ * <b>Precondition:</b> the associated input key is enumerable, see {@link IQueryMetaContext#isEnumerable(IInputKey)}.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ * @noimplement This interface is not intended to be implemented directly. Extend {@link AbstractIndexTable} instead.
+ */
+public interface IIndexTable {
+
+    // TODO add superinterface that represents a statistics-only counter?
+
+    /**
+     * @return the input key indexed by this table
+     */
+    public IInputKey getInputKey();
+
+    /**
+     * Returns the tuples, optionally seeded with the given tuple.
+     * 
+     * <p> Consider using the more idiomatic {@link #streamTuples(TupleMask, ITuple)} instead.
+     * 
+     * @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 row set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered row tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(row)) should hold. Must not be null.
+     * @return the tuples in the table for the given key and seed
+     */
+    @SuppressWarnings("unchecked")
+    public default Iterable<Tuple> enumerateTuples(TupleMask seedMask, ITuple seed) {
+        return () -> (Iterator<Tuple>) (streamTuples(seedMask, seed).iterator());
+    }
+
+    /**
+     * Returns the tuples, optionally seeded with the given tuple.
+     * 
+     * @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 row set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered row tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(row)) should hold. Must not be null.
+     * @return the tuples in the table for the given key and seed
+     * @since 2.1
+     */
+    public Stream<? extends Tuple> streamTuples(TupleMask seedMask, ITuple seed);
+
+    /**
+     * Simpler form of {@link #enumerateTuples(TupleMask, ITuple)} in the case where all values of the tuples are bound
+     * by the seed except for one.
+     * 
+     * <p>
+     * Selects the tuples in the table, optionally seeded with the given tuple, and then returns the single value from
+     * each tuple which is not bound by the seed mask.
+     * 
+     * <p> Consider using the more idiomatic {@link #streamValues(TupleMask, ITuple)} instead.
+     * 
+     * @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 row set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered row tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(row)) should hold. Must not be null.
+     * @return the objects in the table for the given key and seed
+     * 
+     */
+    @SuppressWarnings("unchecked")
+    public default Iterable<? extends Object> enumerateValues(TupleMask seedMask, ITuple seed) {
+        return () -> (Iterator<Object>) (streamValues(seedMask, seed).iterator());
+    }
+
+    /**
+     * Simpler form of {@link #enumerateTuples(TupleMask, ITuple)} in the case where all values of the tuples are bound
+     * by the seed except for one.
+     * 
+     * <p>
+     * Selects the tuples in the table, optionally seeded with the given tuple, and then returns the single value from
+     * each tuple which is not bound by the seed mask.
+     * 
+     * @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 row set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered row tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(row)) should hold. Must not be null.
+     * @return the objects in the table for the given key and seed
+     * 
+     * @since 2.1
+     */
+    public Stream<? extends Object> streamValues(TupleMask seedMask, ITuple seed);
+
+    /**
+     * Simpler form of {@link #enumerateTuples(TupleMask, ITuple)} in the case where all values of the tuples are bound
+     * by the seed.
+     * 
+     * <p>
+     * Returns whether the given tuple is in the table identified by the input key.
+     * 
+     * @param seed
+     *            a row tuple of fixed values whose presence in the table is queried
+     * @return true iff there is a row tuple contained in the table that corresponds to the given seed
+     */
+    public boolean containsTuple(ITuple seed);
+
+    /**
+     * Returns the number of tuples, optionally seeded with the given tuple.
+     * 
+     * <p>
+     * Selects the tuples in the table, optionally seeded with the given tuple, and then returns their number.
+     * 
+     * @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 row set to be considered, in the same order as given in
+     *            parameterSeedMask, so that for each considered row tuple,
+     *            projectedParameterSeed.equals(parameterSeedMask.transform(row)) should hold. Must not be null.
+     * @return the number of tuples in the table for the given key and seed
+     * 
+     */
+    public int countTuples(TupleMask seedMask, ITuple seed);
+
+    /**
+     * Gives an estimate of the number of different groups the tuples of the table 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> Derived tables may return {@link Optional#empty()} if it would be costly to provide an answer up to the required precision.
+     * Direct storage tables are expected to always be able to give an exact count.  
+     *  
+     * <p> PRE: {@link TupleMask#isNonrepeating()} must hold for the group mask.
+     * 
+     * @since 2.1
+     */
+    public Optional<Long> estimateProjectionSize(TupleMask groupMask, Accuracy requiredAccuracy);
+    
+    /**
+     * Subscribes for updates in the table, optionally seeded with the given tuple.
+     * <p> This should be called after initializing a result cache by an enumeration method.
+     *
+     * @param seed can be null or a tuple with matching arity;
+     *   if non-null, notifications will delivered only about those updates of the table
+     *   that match the seed at positions where the seed is non-null.
+     * @param listener will be notified of future changes
+     * 
+     * @since 2.1
+     */
+     public void addUpdateListener(Tuple seed, IQueryRuntimeContextListener listener);
+    
+     /**
+     * Unsubscribes from updates in the table, optionally seeded with the given tuple.
+     *
+     * @param seed can be null or a tuple with matching arity;
+     *   see {@link #addUpdateListener(Tuple, IQueryRuntimeContextListener)} for definition.
+     * @param listener will no longer be notified of future changes
+     * 
+     * @since 2.1
+     */
+     public void removeUpdateListener(Tuple seed, IQueryRuntimeContextListener listener);
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableContext.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableContext.java
new file mode 100644
index 00000000..69e83cd7
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableContext.java
@@ -0,0 +1,29 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+/**
+ * Callbacks that {@link IIndexTable} implementations are expected to invoke on their environment.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public interface ITableContext {
+
+    // TODO notifications?
+
+    /**
+     * Indicates that an error has occurred in maintaining an index table, e.g. duplicate value.
+     */
+    public void logError(String message);
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterBinary.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterBinary.java
new file mode 100644
index 00000000..fb614014
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterBinary.java
@@ -0,0 +1,53 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+/**
+ * Modifies the contents of a binary {@link IIndexTable}.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public interface ITableWriterBinary<Source, Target> {
+    /**
+     * Adds/removes a row to/from the table.
+     * 
+     * @param direction
+     *            tells whether putting a row into the table or deleting
+     * 
+     *            TODO: store as multiset, return bool?
+     */
+    void write(Direction direction, Source source, Target target);
+
+    /**
+     * Intersection type for writers that are also tables
+     */
+    interface Table<Source, Target> extends ITableWriterBinary<Source, Target>, IIndexTable {
+    }
+
+    /**
+     * /dev/null implementation
+     * 
+     * @author Gabor Bergmann
+     */
+    static class Nop<Source, Target> implements ITableWriterBinary<Source, Target> {
+        @Override
+        public void write(Direction direction, Source source, Target target) {
+            // NO-OP
+        }
+
+    }
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterGeneric.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterGeneric.java
new file mode 100644
index 00000000..fb1ebcc0
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterGeneric.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import tools.refinery.viatra.runtime.matchers.tuple.Tuple;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+/**
+ * Modifies the contents of an {@link IIndexTable}.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public interface ITableWriterGeneric {
+
+    /**
+     * Adds/removes a row to/from the table.
+     * 
+     * @param direction
+     *            tells whether putting a row into the table or deleting TODO: store as multiset, return bool?
+     */
+    void write(Direction direction, Tuple row);
+
+    /**
+     * Intersection type for writers that are also tables
+     */
+    interface Table extends ITableWriterGeneric, IIndexTable {
+    }
+
+    /**
+     * /dev/null implementation
+     * 
+     * @author Gabor Bergmann
+     */
+    static class Nop implements ITableWriterGeneric {
+        @Override
+        public void write(Direction direction, Tuple row) {
+            // NO-OP
+        }
+
+    }
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterUnary.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterUnary.java
new file mode 100644
index 00000000..f90d5362
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/ITableWriterUnary.java
@@ -0,0 +1,52 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+
+/**
+ * Modifies the contents of a unary {@link IIndexTable}.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ *
+ */
+public interface ITableWriterUnary<Value> {
+
+    /**
+     * Adds/removes a row to/from the table.
+     * 
+     * @param direction
+     *            tells whether putting a row into the table or deleting TODO: store as multiset, return bool?
+     */
+    void write(Direction direction, Value value);
+
+    /**
+     * Intersection type for writers that are also tables
+     */
+    interface Table<Value> extends ITableWriterUnary<Value>, IIndexTable {
+    }
+
+    /**
+     * /dev/null implementation
+     * 
+     * @author Gabor Bergmann
+     */
+    static class Nop<Value> implements ITableWriterUnary<Value> {
+        @Override
+        public void write(Direction direction, Value value) {
+            // NO-OP
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleBinaryTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleBinaryTable.java
new file mode 100644
index 00000000..588ed9d2
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleBinaryTable.java
@@ -0,0 +1,320 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import java.util.Collections;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+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.Accuracy;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+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;
+
+/**
+ * Simple source-target bidirectional mapping.
+ * 
+ * <p>
+ * TODO: specialize for to-one features and unique to-many features
+ * <p>
+ * TODO: on-demand construction of valueToHolderMap
+ * <p>
+ * TODO: support for lean indexing, opposites, long surrogate ids, etc.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public class SimpleBinaryTable<Source, Target> extends AbstractIndexTable
+        implements ITableWriterBinary.Table<Source, Target> {
+
+    /**
+     * value -> holder(s)
+     * <p>
+     * this is currently the primary store, may hold duplicates depending on the unique parameter
+     */
+    private IMultiLookup<Target, Source> valueToHolderMap;
+    /**
+     * holder -> value(s); constructed on-demand, null if unused
+     */
+    private IMultiLookup<Source, Target> holderToValueMap;
+    private int totalRowCount = 0;
+    private boolean unique;
+
+    /**
+     * @param unique
+     *            client promises to only insert a given tuple with multiplicity one
+     */
+    public SimpleBinaryTable(IInputKey inputKey, ITableContext tableContext, boolean unique) {
+        super(inputKey, tableContext);
+        this.unique = unique;
+        valueToHolderMap = CollectionsFactory.createMultiLookup(Object.class,
+                unique ? MemoryType.SETS : MemoryType.MULTISETS, Object.class);
+        if (2 != inputKey.getArity())
+            throw new IllegalArgumentException(inputKey.toString());
+    }
+
+    @Override
+    public void write(Direction direction, Source holder, Target value) {
+        if (direction == Direction.INSERT) {
+            try {
+                // TODO we currently assume V2H map exists
+                boolean changed = addToValueToHolderMap(value, holder);
+                if (holderToValueMap != null) {
+                    addToHolderToValueMap(value, holder);
+                }
+                if (changed) {
+                    totalRowCount++;
+                    if (emitNotifications) {
+                        deliverChangeNotifications(Tuples.staticArityFlatTupleOf(holder, value), true);
+                    }
+                }
+            } catch (IllegalStateException ex) { // if unique table and duplicate tuple
+                String msg = String.format(
+                        "Error: trying to add duplicate value %s to the unique feature %s of host object %s. This indicates some errors in underlying model representation.",
+                        value, getInputKey().getPrettyPrintableName(), holder);
+                logError(msg);
+            }
+        } else { // DELETE
+            try {
+                // TODO we currently assume V2H map exists
+                boolean changed = removeFromValueToHolderMap(value, holder);
+                if (holderToValueMap != null) {
+                    removeFromHolderToValueMap(value, holder);
+                }
+                if (changed) {
+                    totalRowCount--;
+                    if (emitNotifications) {
+                        deliverChangeNotifications(Tuples.staticArityFlatTupleOf(holder, value), false);
+                    }
+                }
+            } catch (IllegalStateException ex) { // if unique table and duplicate tuple
+                String msg = String.format(
+                        "Error: trying to remove non-existing value %s from the feature %s of host object %s. This indicates some errors in underlying model representation.",
+                        value, getInputKey().getPrettyPrintableName(), holder);
+                logError(msg);
+            }
+        }
+    }
+
+    private boolean addToHolderToValueMap(Target value, Source holder) {
+        return ChangeGranularity.DUPLICATE != holderToValueMap.addPair(holder, value);
+    }
+
+    private boolean addToValueToHolderMap(Target value, Source holder) {
+        return ChangeGranularity.DUPLICATE != valueToHolderMap.addPair(value, holder);
+    }
+
+    /**
+     * @throws IllegalStateException
+     */
+    private boolean removeFromHolderToValueMap(Target value, Source holder) {
+        return ChangeGranularity.DUPLICATE != holderToValueMap.removePair(holder, value);
+    }
+
+    /**
+     * @throws IllegalStateException
+     */
+    private boolean removeFromValueToHolderMap(Target value, Source holder) {
+        return ChangeGranularity.DUPLICATE != valueToHolderMap.removePair(value, holder);
+    }
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public int countTuples(TupleMask seedMask, ITuple seed) {
+        switch (seedMask.getSize()) {
+        case 0: // unseeded
+            // TODO we currently assume V2H map exists
+            return totalRowCount;
+        case 1: // lookup by source or target
+            int seedIndex = seedMask.indices[0];
+            if (seedIndex == 0) { // lookup by source
+                Source source = (Source) seed.get(0);
+                return getDistinctValuesOfHolder(source).size();
+            } else if (seedIndex == 1) { // lookup by target
+                Target target = (Target) seed.get(0);
+                return getDistinctHoldersOfValue(target).size();
+            } else
+                throw new IllegalArgumentException(seedMask.toString());
+        case 2: // containment check
+            // hack: if mask is not identity, then it is [1,0]/2, which is its own inverse
+            Source source = (Source) seedMask.getValue(seed, 0);
+            Target target = (Target) seedMask.getValue(seed, 1);
+            if (containsRow(source, target))
+                return 1;
+            else
+                return 0;
+        default:
+            throw new IllegalArgumentException(seedMask.toString());
+        }
+    }
+
+    @Override
+    public Optional<Long> estimateProjectionSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        // always exact count
+        if (groupMask.getSize() == 0) {
+            return totalRowCount == 0 ? Optional.of(0L) : Optional.of(1L);
+        } else if (groupMask.getSize() == 2) {
+            return Optional.of((long)totalRowCount);
+        } else if (groupMask.indices[0] == 0) { // project to holder
+            return Optional.of((long)getHolderToValueMap().countKeys());
+        } else { // (groupMask.indices[0] == 0) // project to value 
+            return Optional.of((long)getValueToHolderMap().countKeys());
+        }
+    }
+
+    @Override
+    public Stream<? extends Tuple> streamTuples(TupleMask seedMask, ITuple seed) {
+        switch (seedMask.getSize()) {
+        case 0: // unseeded
+            // TODO we currently assume V2H map exists
+            return getAllDistinctValuesStream()
+                    .flatMap(value -> valueToHolderMap.lookup(value).distinctValues().stream()
+                    .map(source -> Tuples.staticArityFlatTupleOf(source, value)));
+
+        case 1: // lookup by source or target
+            int seedIndex = seedMask.indices[0];
+            if (seedIndex == 0) { // lookup by source
+                @SuppressWarnings("unchecked")
+                Source source = (Source) seed.get(0);
+                return getDistinctValuesOfHolder(source).stream()
+                        .map(target -> Tuples.staticArityFlatTupleOf(source, target));
+            } else if (seedIndex == 1) { // lookup by target
+                @SuppressWarnings("unchecked")
+                Target target = (Target) seed.get(0);
+                return getDistinctHoldersOfValue(target).stream()
+                            .map(source -> Tuples.staticArityFlatTupleOf(source, target));
+            } else
+                throw new IllegalArgumentException(seedMask.toString());
+        case 2: // containment check
+            // hack: if mask is not identity, then it is [1,0]/2, which is its own inverse
+            @SuppressWarnings("unchecked")
+            Source source = (Source) seedMask.getValue(seed, 0);
+            @SuppressWarnings("unchecked")
+            Target target = (Target) seedMask.getValue(seed, 1);
+
+            if (containsRow(source, target))
+                return Stream.of(Tuples.staticArityFlatTupleOf(source, target));
+            else
+                return Stream.empty();
+        default:
+            throw new IllegalArgumentException(seedMask.toString());
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Iterable<? extends Object> enumerateValues(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() != 1)
+            throw new IllegalArgumentException(seedMask.toString());
+
+        int seedIndex = seedMask.indices[0];
+        if (seedIndex == 0) { // lookup by source
+            return getDistinctValuesOfHolder((Source) seed.get(0));
+        } else if (seedIndex == 1) { // lookup by target
+            return getDistinctHoldersOfValue((Target) seed.get(0));
+        } else
+            throw new IllegalArgumentException(seedMask.toString());
+
+    }
+    @Override
+    public Stream<? extends Object> streamValues(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() != 1)
+            throw new IllegalArgumentException(seedMask.toString());
+
+        int seedIndex = seedMask.indices[0];
+        if (seedIndex == 0) { // lookup by source
+            return getDistinctValuesOfHolder((Source) seed.get(0)).stream();
+        } else if (seedIndex == 1) { // lookup by target
+            return getDistinctHoldersOfValue((Target) seed.get(0)).stream();
+        } else
+            throw new IllegalArgumentException(seedMask.toString());
+
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean containsTuple(ITuple seed) {
+        return containsRow((Source) seed.get(0), (Target) seed.get(1));
+    }
+
+    public boolean containsRow(Source source, Target target) {
+        // TODO we currently assume V2H map exists
+        if (valueToHolderMap != null) {
+            IMemoryView<Source> holders = valueToHolderMap.lookup(target);
+            return holders != null && holders.containsNonZero(source);
+        } else
+            throw new UnsupportedOperationException("TODO implement");
+    }
+
+    public Iterable<Source> getAllDistinctHolders() {
+        return getHolderToValueMap().distinctKeys();
+    }
+    public Stream<Source> getAllDistinctHoldersStream() {
+        return getHolderToValueMap().distinctKeysStream();
+    }
+    public Iterable<Target> getAllDistinctValues() {
+        return getValueToHolderMap().distinctKeys();
+    }
+    public Stream<Target> getAllDistinctValuesStream() {
+        return getValueToHolderMap().distinctKeysStream();
+    }
+
+    public Set<Source> getDistinctHoldersOfValue(Target value) {
+        IMemoryView<Source> holdersMultiset = getValueToHolderMap().lookup(value);
+        if (holdersMultiset == null)
+            return Collections.emptySet();
+        else
+            return holdersMultiset.distinctValues();
+    }
+
+    public Set<Target> getDistinctValuesOfHolder(Source holder) {
+        IMemoryView<Target> valuesMultiset = getHolderToValueMap().lookup(holder);
+        if (valuesMultiset == null)
+            return Collections.emptySet();
+        else
+            return valuesMultiset.distinctValues();
+    }
+
+    private IMultiLookup<Source, Target> getHolderToValueMap() {
+        if (holderToValueMap == null) {
+            holderToValueMap = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, // no duplicates, as
+                                                                                                   // this is the
+                                                                                                   // secondary
+                                                                                                   // collection
+                    Object.class);
+
+            // TODO we currently assume V2H map exists
+            for (Target value : valueToHolderMap.distinctKeys()) {
+                for (Source holder : valueToHolderMap.lookup(value).distinctValues()) {
+                    holderToValueMap.addPair(holder, value);
+                }
+            }
+        }
+        return holderToValueMap;
+    }
+
+    private IMultiLookup<Target, Source> getValueToHolderMap() {
+        // TODO we currently assume V2H map exists
+        return valueToHolderMap;
+    }
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleUnaryTable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleUnaryTable.java
new file mode 100644
index 00000000..428ea78b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/scopes/tables/SimpleUnaryTable.java
@@ -0,0 +1,140 @@
+/*******************************************************************************
+ * 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.scopes.tables;
+
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import tools.refinery.viatra.runtime.matchers.context.IInputKey;
+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.Accuracy;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+import tools.refinery.viatra.runtime.matchers.util.IMemory;
+
+/**
+ * Simple value set.
+ * <p>
+ * <strong>EXPERIMENTAL</strong>. This class or interface has been added as
+ * part of a work in progress. There is no guarantee that this API will
+ * work or that it will remain the same.
+ *
+ * @since 2.0
+ * @author Gabor Bergmann
+ */
+public class SimpleUnaryTable<Value> extends AbstractIndexTable implements ITableWriterUnary.Table<Value> {
+
+    protected IMemory<Value> values = CollectionsFactory.createMultiset(); // TODO use SetMemory if unique
+
+    private boolean unique;
+
+    /**
+     * @param unique
+     *            client promises to only insert a given tuple with multiplicity one
+     */
+    public SimpleUnaryTable(IInputKey inputKey, ITableContext tableContext, boolean unique) {
+        super(inputKey, tableContext);
+        this.unique = unique;
+        if (1 != inputKey.getArity())
+            throw new IllegalArgumentException(inputKey.toString());
+    }
+
+    @Override
+    public void write(Direction direction, Value value) {
+        if (direction == Direction.INSERT) {
+            boolean changed = values.addOne(value);
+            if (unique && !changed) {
+                String msg = String.format(
+                        "Error: trying to add duplicate value %s to the unique set %s. This indicates some errors in underlying model representation.",
+                        value, getInputKey().getPrettyPrintableName());
+                logError(msg);
+            }
+            if (changed && emitNotifications) {
+                deliverChangeNotifications(Tuples.staticArityFlatTupleOf(value), true);
+            }
+        } else { // DELETE
+            boolean changed = values.removeOne(value);
+            if (unique && !changed) {
+                String msg = String.format(
+                        "Error: trying to remove duplicate value %s from the unique set %s. This indicates some errors in underlying model representation.",
+                        value, getInputKey().getPrettyPrintableName());
+                logError(msg);
+            }
+            if (changed && emitNotifications) {
+                deliverChangeNotifications(Tuples.staticArityFlatTupleOf(value), false);
+            }
+        }
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public boolean containsTuple(ITuple seed) {
+        return values.containsNonZero((Value) seed.get(0));
+    }
+
+    @Override
+    public int countTuples(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() == 0) { // unseeded
+            return values.size();
+        } else {
+            @SuppressWarnings("unchecked")
+            Value value = (Value) seed.get(0);
+            return values.containsNonZero(value) ? 1 : 0;
+        }
+    }
+
+
+    @Override
+    public Optional<Long> estimateProjectionSize(TupleMask groupMask, Accuracy requiredAccuracy) {
+        // always exact count
+        if (groupMask.getSize() == 0) {
+            return values.isEmpty() ? Optional.of(0L) : Optional.of(1L);
+        } else {
+            return Optional.of((long)values.size());
+        }
+    }
+
+    
+    @Override
+    public Stream<? extends Tuple> streamTuples(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() == 0) { // unseeded
+            return values.distinctValues().stream().map(Tuples::staticArityFlatTupleOf);
+        } else {
+            @SuppressWarnings("unchecked")
+            Value value = (Value) seed.get(0);
+            if (values.containsNonZero(value))
+                return Stream.of(Tuples.staticArityFlatTupleOf(value));
+            else
+                return Stream.empty();
+        }
+    }
+
+    @Override
+    public Iterable<? extends Object> enumerateValues(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() == 0) { // unseeded
+            return values;
+        } else {
+            throw new IllegalArgumentException(seedMask.toString());
+        }
+    }
+    @Override
+    public Stream<? extends Object> streamValues(TupleMask seedMask, ITuple seed) {
+        if (seedMask.getSize() == 0) { // unseeded
+            return values.asStream();
+        } else {
+            throw new IllegalArgumentException(seedMask.toString());
+        }
+    }
+    
+
+}
diff --git a/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/AbstractTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/AbstractTuple.java
new file mode 100644
index 00000000..a26d9193
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseFlatTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseFlatTuple.java
new file mode 100644
index 00000000..6f46b763
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseLeftInheritanceTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/BaseLeftInheritanceTuple.java
new file mode 100644
index 00000000..03f9ea89
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple.java
new file mode 100644
index 00000000..8bbb0ac2
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple0.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple0.java
new file mode 100644
index 00000000..93f412b7
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple1.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple1.java
new file mode 100644
index 00000000..b3b1c312
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple2.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple2.java
new file mode 100644
index 00000000..2dcfd718
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple3.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple3.java
new file mode 100644
index 00000000..50cee57e
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple4.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/FlatTuple4.java
new file mode 100644
index 00000000..024c94f4
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/IModifiableTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/IModifiableTuple.java
new file mode 100644
index 00000000..f5dab2a5
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/ITuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/ITuple.java
new file mode 100644
index 00000000..92014781
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple.java
new file mode 100644
index 00000000..dcdfc376
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple1.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple1.java
new file mode 100644
index 00000000..61123176
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple2.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple2.java
new file mode 100644
index 00000000..e9fb98e8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple3.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple3.java
new file mode 100644
index 00000000..e61d196f
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple4.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/LeftInheritanceTuple4.java
new file mode 100644
index 00000000..4e50f1e1
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/MaskedTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/MaskedTuple.java
new file mode 100644
index 00000000..a5d1991c
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuple.java
new file mode 100644
index 00000000..d94f545f
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask.java
new file mode 100644
index 00000000..49c55fef
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask0.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMask0.java
new file mode 100644
index 00000000..5a0c79ff
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMaskIdentity.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleMaskIdentity.java
new file mode 100644
index 00000000..62746587
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleValueProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/TupleValueProvider.java
new file mode 100644
index 00000000..79193516
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuples.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/Tuples.java
new file mode 100644
index 00000000..5e41d7d8
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileMaskedTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileMaskedTuple.java
new file mode 100644
index 00000000..f683d544
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileModifiableMaskedTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileModifiableMaskedTuple.java
new file mode 100644
index 00000000..92306c6e
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileTuple.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/tuple/VolatileTuple.java
new file mode 100644
index 00000000..699105a5
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Accuracy.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Accuracy.java
new file mode 100644
index 00000000..338990ab
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Clearable.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Clearable.java
new file mode 100644
index 00000000..1b09aec6
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/CollectionsFactory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/CollectionsFactory.java
new file mode 100644
index 00000000..590a1ec3
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Direction.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Direction.java
new file mode 100644
index 00000000..88f7ec00
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsBagMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsBagMemory.java
new file mode 100644
index 00000000..e24b2448
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsDeltaBag.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsDeltaBag.java
new file mode 100644
index 00000000..94ec33cd
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsFactory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsFactory.java
new file mode 100644
index 00000000..5a623c9b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongMultiset.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongMultiset.java
new file mode 100644
index 00000000..88773c5d
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongSetMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsLongSetMemory.java
new file mode 100644
index 00000000..fceb54fc
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiLookup.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiLookup.java
new file mode 100644
index 00000000..394135c9
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiset.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsMultiset.java
new file mode 100644
index 00000000..46977c8b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsSetMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EclipseCollectionsSetMemory.java
new file mode 100644
index 00000000..92f65246
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EmptyMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/EmptyMemory.java
new file mode 100644
index 00000000..a17b3a3f
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/ICache.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/ICache.java
new file mode 100644
index 00000000..8c2e54ad
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IDeltaBag.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IDeltaBag.java
new file mode 100644
index 00000000..99a4cb3b
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemory.java
new file mode 100644
index 00000000..ea788e53
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemoryView.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMemoryView.java
new file mode 100644
index 00000000..add575c6
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookup.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookup.java
new file mode 100644
index 00000000..1ce1d2c9
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookupAbstract.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiLookupAbstract.java
new file mode 100644
index 00000000..8b1944c1
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiset.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IMultiset.java
new file mode 100644
index 00000000..bdd5d597
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/IProvider.java
new file mode 100644
index 00000000..cd25dc95
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/ISetMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/ISetMemory.java
new file mode 100644
index 00000000..0c03da48
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MapBackedMemoryView.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MapBackedMemoryView.java
new file mode 100644
index 00000000..3be078bd
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MarkedMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MarkedMemory.java
new file mode 100644
index 00000000..d22dcbe7
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MemoryViewBackedMapView.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/MemoryViewBackedMapView.java
new file mode 100644
index 00000000..49711a89
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Preconditions.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Preconditions.java
new file mode 100644
index 00000000..e9e5e3a0
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/PurgableCache.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/PurgableCache.java
new file mode 100644
index 00000000..c4e6b5af
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Sets.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Sets.java
new file mode 100644
index 00000000..3749fe06
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Signed.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/Signed.java
new file mode 100644
index 00000000..8f8bc228
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonInstanceProvider.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonInstanceProvider.java
new file mode 100644
index 00000000..cc5963f7
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonMemoryView.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/SingletonMemoryView.java
new file mode 100644
index 00000000..b303f9ad
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/TimelyMemory.java b/subprojects/viatra-runtime-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/TimelyMemory.java
new file mode 100644
index 00000000..90fcad4d
--- /dev/null
+++ b/subprojects/viatra-runtime-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/MaskedResumable.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/Resumable.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/resumable/UnmaskedResumable.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/CompactTimeline.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Diff.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/SingletonTimeline.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timeline.java b/subprojects/viatra-runtime-matchers/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-matchers/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-matchers/src/main/java/tools/refinery/viatra/runtime/matchers/util/timeline/Timelines.java b/subprojects/viatra-runtime-matchers/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-matchers/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);
+    }
+
+}