diff --git a/AlgebraicDataflowArchitectureModel/src/models/algebra/Symbol.java b/AlgebraicDataflowArchitectureModel/src/models/algebra/Symbol.java
index 047f906..20c3cf2 100644
--- a/AlgebraicDataflowArchitectureModel/src/models/algebra/Symbol.java
+++ b/AlgebraicDataflowArchitectureModel/src/models/algebra/Symbol.java
@@ -210,7 +210,7 @@
 		return (calculator != null);
 	}
 	
-	public Constant calculate(List<Constant> args) {
+	public Expression calculate(List<Expression> args) {
 		if (calculator != null) {
 			return calculator.calculate(args);
 		}
@@ -279,6 +279,6 @@
 	}
 	
 	public interface ICalculator {
-		public Constant calculate(List<Constant> args);
+		public Expression calculate(List<Expression> args);
 	}
 }
diff --git a/AlgebraicDataflowArchitectureModel/src/models/algebra/Term.java b/AlgebraicDataflowArchitectureModel/src/models/algebra/Term.java
index b326caa..7f69a35 100644
--- a/AlgebraicDataflowArchitectureModel/src/models/algebra/Term.java
+++ b/AlgebraicDataflowArchitectureModel/src/models/algebra/Term.java
@@ -150,17 +150,16 @@
 				return new Term(newSymbol, newChildren);
 			}
 		} else if (symbol.isCalculatable()) {
-			List<Constant> newChildren = new ArrayList<>();
+			List<Expression> newChildren = new ArrayList<>();
 			for (Expression child: children) {
 				if (child instanceof Term) {
 					child = ((Term) child).reduce();
 				}
-				if (!(child instanceof Constant)) {
-					return this;
-				}
-				newChildren.add((Constant) child);
+				newChildren.add(child);
 			}
-			return symbol.calculate(newChildren);
+			Expression newTerm = symbol.calculate(newChildren);
+			if (newTerm == null) return this;
+			return newTerm;
 		} else {
 			// Calculate inverse map
 			List<Expression> newChildren = new ArrayList<>();
diff --git a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java
index 7d21e0c..c169b2a 100644
--- a/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java
+++ b/AlgebraicDataflowArchitectureModel/src/models/dataConstraintModel/DataConstraintModel.java
@@ -39,115 +39,167 @@
 	public static final JsonType typeJson = new JsonType("Json", "HashMap<>", "Map<String, Object>");
 	public static final Symbol add = new Symbol(Parser.ADD, 2, Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				return new Constant(Double.toString(Double.parseDouble(arg0) + Double.parseDouble(arg1)), typeDouble);
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				return new Constant(Float.toString(Float.parseFloat(arg0) + Float.parseFloat(arg1)), typeFloat);
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				return new Constant(Long.toString(Long.parseLong(arg0) + Long.parseLong(arg1)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(Integer.parseInt(arg0) + Integer.parseInt(arg1)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(Integer.parseInt(arg0) + Integer.parseInt(arg1)));
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				return new Constant(Double.toString(Double.parseDouble(sArg0) + Double.parseDouble(sArg1)), typeDouble);
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				return new Constant(Float.toString(Float.parseFloat(sArg0) + Float.parseFloat(sArg1)), typeFloat);
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				return new Constant(Long.toString(Long.parseLong(sArg0) + Long.parseLong(sArg1)), typeLong);
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(Integer.parseInt(sArg0) + Integer.parseInt(sArg1)), typeInt);
+			}
+			return new Constant(Integer.toString(Integer.parseInt(sArg0) + Integer.parseInt(sArg1)));
 		}
 	});
 	public static final Symbol mul = new Symbol(Parser.MUL, 2, Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				return new Constant(Double.toString(Double.parseDouble(arg0) * Double.parseDouble(arg1)), typeDouble);
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				return new Constant(Float.toString(Float.parseFloat(arg0) * Float.parseFloat(arg1)), typeFloat);
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				return new Constant(Long.toString(Long.parseLong(arg0) * Long.parseLong(arg1)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(Integer.parseInt(arg0) * Integer.parseInt(arg1)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(Integer.parseInt(arg0) * Integer.parseInt(arg1)));
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				return new Constant(Double.toString(Double.parseDouble(sArg0) * Double.parseDouble(sArg1)), typeDouble);
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				return new Constant(Float.toString(Float.parseFloat(sArg0) * Float.parseFloat(sArg1)), typeFloat);
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				return new Constant(Long.toString(Long.parseLong(sArg0) * Long.parseLong(sArg1)), typeLong);
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(Integer.parseInt(sArg0) * Integer.parseInt(sArg1)), typeInt);
+			}
+			return new Constant(Integer.toString(Integer.parseInt(sArg0) * Integer.parseInt(sArg1)));
 		}
 	});
 	public static final Symbol sub = new Symbol(Parser.SUB, 2, Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				return new Constant(Double.toString(Double.parseDouble(arg0) - Double.parseDouble(arg1)), typeDouble);
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				return new Constant(Float.toString(Float.parseFloat(arg0) - Float.parseFloat(arg1)), typeFloat);
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				return new Constant(Long.toString(Long.parseLong(arg0) - Long.parseLong(arg1)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(Integer.parseInt(arg0) - Integer.parseInt(arg1)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(Integer.parseInt(arg0) - Integer.parseInt(arg1)));
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				return new Constant(Double.toString(Double.parseDouble(sArg0) - Double.parseDouble(sArg1)), typeDouble);
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				return new Constant(Float.toString(Float.parseFloat(sArg0) - Float.parseFloat(sArg1)), typeFloat);
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				return new Constant(Long.toString(Long.parseLong(sArg0) - Long.parseLong(sArg1)), typeLong);
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(Integer.parseInt(sArg0) - Integer.parseInt(sArg1)), typeInt);
+			}
+			return new Constant(Integer.toString(Integer.parseInt(sArg0) - Integer.parseInt(sArg1)));
 		}
 	});
 	public static final Symbol div = new Symbol(Parser.DIV, 2, Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				return new Constant(Double.toString(Double.parseDouble(arg0) / Double.parseDouble(arg1)), typeDouble);
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				return new Constant(Float.toString(Float.parseFloat(arg0) / Float.parseFloat(arg1)), typeFloat);
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				return new Constant(Long.toString(Long.parseLong(arg0) / Long.parseLong(arg1)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(Integer.parseInt(arg0) / Integer.parseInt(arg1)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(Integer.parseInt(arg0) / Integer.parseInt(arg1)));
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				return new Constant(Double.toString(Double.parseDouble(sArg0) / Double.parseDouble(sArg1)), typeDouble);
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				return new Constant(Float.toString(Float.parseFloat(sArg0) / Float.parseFloat(sArg1)), typeFloat);
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				return new Constant(Long.toString(Long.parseLong(sArg0) / Long.parseLong(sArg1)), typeLong);
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(Integer.parseInt(sArg0) / Integer.parseInt(sArg1)), typeInt);
+			}
+			return new Constant(Integer.toString(Integer.parseInt(sArg0) / Integer.parseInt(sArg1)));
 		}
 	});
 	public static final Symbol mod = new Symbol(Parser.MOD, 2, Symbol.Type.INFIX, "%", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
-			if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				return new Constant(Long.toString(Long.parseLong(arg0) % Long.parseLong(arg1)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(Integer.parseInt(arg0) % Integer.parseInt(arg1)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(Integer.parseInt(arg0) % Integer.parseInt(arg1)));
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
+			if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				return new Constant(Long.toString(Long.parseLong(sArg0) % Long.parseLong(sArg1)), typeLong);
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(Integer.parseInt(sArg0) % Integer.parseInt(sArg1)), typeInt);
+			}
+			return new Constant(Integer.toString(Integer.parseInt(sArg0) % Integer.parseInt(sArg1)));
 		}
 	});
 	public static final Symbol minus = new Symbol(Parser.MINUS, 1, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg = args.get(0).getSymbol().toString();
-			if (args.get(0).getType().equals(typeDouble)) {
-				return new Constant(Double.toString(-Double.parseDouble(arg)), typeDouble);
-			} else if (args.get(0).getType().equals(typeFloat)) {
-				return new Constant(Float.toString(-Float.parseFloat(arg)), typeFloat);
-			} else if (args.get(0).getType().equals(typeLong)) {
-				return new Constant(Long.toString(-Long.parseLong(arg)), typeLong);
-			} else if (args.get(0).getType().equals(typeInt)) {
-				return new Constant(Integer.toString(-Integer.parseInt(arg)), typeInt);
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
 			}
-			return new Constant(Integer.toString(-Integer.parseInt(arg)));
+			Constant arg = (Constant) args.get(0);
+			String sArg = arg.getSymbol().toString();
+			if (arg.getType().equals(typeDouble)) {
+				return new Constant(Double.toString(-Double.parseDouble(sArg)), typeDouble);
+			} else if (arg.getType().equals(typeFloat)) {
+				return new Constant(Float.toString(-Float.parseFloat(sArg)), typeFloat);
+			} else if (arg.getType().equals(typeLong)) {
+				return new Constant(Long.toString(-Long.parseLong(sArg)), typeLong);
+			} else if (arg.getType().equals(typeInt)) {
+				return new Constant(Integer.toString(-Integer.parseInt(sArg)), typeInt);
+			}
+			return new Constant(Integer.toString(-Integer.parseInt(sArg)));
 		}
 	});
 	public static final Symbol eq = new Symbol(Parser.EQ, 2, Symbol.Type.INFIX, "==", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) == Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) == Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) == Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) == Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) == Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) == Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) == Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) == Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -158,18 +210,26 @@
 	});
 	public static final Symbol neq = new Symbol(Parser.NEQ, 2, Symbol.Type.INFIX, "!=", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) != Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) != Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) != Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) != Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) != Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) != Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) != Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) != Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -180,18 +240,26 @@
 	});
 	public static final Symbol gt = new Symbol(Parser.GT, 2, Symbol.Type.INFIX, ">", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) > Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) > Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) > Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) > Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) > Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) > Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) > Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) > Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -202,18 +270,26 @@
 	});
 	public static final Symbol lt = new Symbol(Parser.LT, 2, Symbol.Type.INFIX, "<", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) < Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) < Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) < Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) < Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) < Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) < Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) < Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) < Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -224,18 +300,26 @@
 	});
 	public static final Symbol ge = new Symbol(Parser.GE, 2, Symbol.Type.INFIX, ">=", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) >= Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) >= Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) >= Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) >= Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) >= Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) >= Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) >= Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) >= Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -246,18 +330,26 @@
 	});
 	public static final Symbol le = new Symbol(Parser.LE, 2, Symbol.Type.INFIX, "<=", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeDouble) || args.get(1).getType().equals(typeDouble)) {
-				result = (Double.parseDouble(arg0) <= Double.parseDouble(arg1));
-			} else if (args.get(0).getType().equals(typeFloat) || args.get(1).getType().equals(typeFloat)) {
-				result = (Float.parseFloat(arg0) <= Float.parseFloat(arg1));
-			} else if (args.get(0).getType().equals(typeLong) || args.get(1).getType().equals(typeLong)) {
-				result = (Long.parseLong(arg0) <= Long.parseLong(arg1));
-			} else if (args.get(0).getType().equals(typeInt) || args.get(1).getType().equals(typeInt)) {
-				result = (Integer.parseInt(arg0) <= Integer.parseInt(arg1));
+			if (arg0.getType().equals(typeDouble) || arg1.getType().equals(typeDouble)) {
+				result = (Double.parseDouble(sArg0) <= Double.parseDouble(sArg1));
+			} else if (arg0.getType().equals(typeFloat) || arg1.getType().equals(typeFloat)) {
+				result = (Float.parseFloat(sArg0) <= Float.parseFloat(sArg1));
+			} else if (arg0.getType().equals(typeLong) || arg1.getType().equals(typeLong)) {
+				result = (Long.parseLong(sArg0) <= Long.parseLong(sArg1));
+			} else if (arg0.getType().equals(typeInt) || arg1.getType().equals(typeInt)) {
+				result = (Integer.parseInt(sArg0) <= Integer.parseInt(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -268,12 +360,20 @@
 	});
 	public static final Symbol and = new Symbol(Parser.AND, 2, Symbol.Type.INFIX, "&&", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeBoolean) || args.get(1).getType().equals(typeBoolean)) {
-				result = (Boolean.parseBoolean(arg0) && Boolean.parseBoolean(arg1));
+			if (arg0.getType().equals(typeBoolean) || arg1.getType().equals(typeBoolean)) {
+				result = (Boolean.parseBoolean(sArg0) && Boolean.parseBoolean(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -284,12 +384,20 @@
 	});
 	public static final Symbol or = new Symbol(Parser.OR, 2, Symbol.Type.INFIX, "||", Symbol.Type.INFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
-			String arg1 = args.get(1).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			if (!(args.get(1) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			Constant arg1 = (Constant) args.get(1);
+			String sArg0 = arg0.getSymbol().toString();
+			String sArg1 = arg1.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeBoolean) || args.get(1).getType().equals(typeBoolean)) {
-				result = (Boolean.parseBoolean(arg0) || Boolean.parseBoolean(arg1));
+			if (arg0.getType().equals(typeBoolean) || arg1.getType().equals(typeBoolean)) {
+				result = (Boolean.parseBoolean(sArg0) || Boolean.parseBoolean(sArg1));
 			}
 			if (result) {
 				return new Constant(true_);
@@ -300,11 +408,15 @@
 	});
 	public static final Symbol neg = new Symbol(Parser.NEG, 1, Symbol.Type.PREFIX, "!", Symbol.Type.PREFIX, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			String arg0 = args.get(0).getSymbol().toString();
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) {
+				return null;
+			}
+			Constant arg0 = (Constant) args.get(0);
+			String sArg0 = arg0.getSymbol().toString();
 			boolean result = false;
-			if (args.get(0).getType().equals(typeBoolean)) {
-				result = !Boolean.parseBoolean(arg0);
+			if (arg0.getType().equals(typeBoolean)) {
+				result = !Boolean.parseBoolean(sArg0);
 			}
 			if (result) {
 				return new Constant(true_);
@@ -332,6 +444,49 @@
 			}
 			return childrenImpl[0] + "." + "contains(" + childrenImpl[1] + ")";
 		}
+	}, new Symbol.ICalculator() {
+		@Override
+		public Expression calculate(List<Expression> args) {
+			if (args.get(0) instanceof Constant && ((Constant) args.get(0)).getSymbol().equals(nil)) {
+				return new Constant(false_);
+			}
+			if (args.get(0) instanceof Term) {
+				Term term = (Term) args.get(0);
+				Type type = term.getType();
+				if (typeList.isAncestorOf(type)) {
+					while (term.getSymbol().equals(DataConstraintModel.append)) {
+						if (term.getChild(1).equals(args.get(1))) {
+							return new Constant(true_);
+						}
+						if (!(term.getChild(0) instanceof Term)) {
+							return new Constant(false_);
+						}
+						term = (Term) term.getChild(0);
+					}
+				} else if (typeMap.isAncestorOf(type)) {
+					while (term.getSymbol().equals(DataConstraintModel.insert)) {
+						if (term.getChild(1).equals(args.get(1))) {
+							return new Constant(true_);
+						}
+						if (!(term.getChild(0) instanceof Term)) {
+							return new Constant(false_);
+						}
+						term = (Term) term.getChild(0);
+					}
+				} else if (typeJson.isAncestorOf(type)) {
+					while (term.getSymbol().equals(DataConstraintModel.addMember)) {
+						if (term.getChild(1).equals(args.get(1))) {
+							return new Constant(true_);
+						}
+						if (!(term.getChild(0) instanceof Term)) {
+							return new Constant(false_);
+						}
+						term = (Term) term.getChild(0);
+					}
+				}
+			}
+			return new Constant(false_);
+		}
 	});
 	public static final Symbol nil = new Symbol("nil", 0, Symbol.Type.PREFIX, new Symbol.IImplGenerator() {
 		@Override
@@ -384,10 +539,11 @@
 		}
 	}, new Symbol.ICalculator() {
 		@Override
-		public Constant calculate(List<Constant> args) {
-			if (args.get(0).getSymbol().equals(true_)) {
+		public Expression calculate(List<Expression> args) {
+			if (!(args.get(0) instanceof Constant)) return null;
+			if (((Constant) args.get(0)).getSymbol().equals(true_)) {
 				return args.get(1);
-			} else if (args.get(0).getSymbol().equals(false_)) {
+			} else if (((Constant) args.get(0)).getSymbol().equals(false_)) {
 				return args.get(2);
 			}
 			return null;
diff --git a/AlgebraicDataflowArchitectureModel/src/simulator/SystemState.java b/AlgebraicDataflowArchitectureModel/src/simulator/SystemState.java
index 9a58a33..2221b0e 100644
--- a/AlgebraicDataflowArchitectureModel/src/simulator/SystemState.java
+++ b/AlgebraicDataflowArchitectureModel/src/simulator/SystemState.java
@@ -160,9 +160,6 @@
 				return createdResource;
 			}
 		} else {
-			if (resStateValue instanceof Term) {
-				resStateValue = ((Term) resStateValue).reduce();
-			}
 			if (resStateValue instanceof Constant) {
 				Resource res = getResource(resourceIdentifier);
 				ResourceState state = null;
@@ -191,6 +188,7 @@
 		Type resType = null;
 		if (resStateValue instanceof Term) {
 			resType = ((Term) resStateValue).getType();
+			resStateValue = ((Term) resStateValue).reduce();
 		}
 		if (resType != null) {
 			if (DataConstraintModel.typeList.isAncestorOf(resType)) {