diff --git a/src/de/dhbwstuttgart/core/JavaTXCompiler.java b/src/de/dhbwstuttgart/core/JavaTXCompiler.java
index 68bb2585..05edbaa1 100644
--- a/src/de/dhbwstuttgart/core/JavaTXCompiler.java
+++ b/src/de/dhbwstuttgart/core/JavaTXCompiler.java
@@ -121,8 +121,9 @@ public class JavaTXCompiler {
 				System.out.println(xConsSet);
 				Set<String> paraTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().map(y -> y.getParameterList().getFormalparalist()
 						.stream().filter(z -> z.getType() instanceof TypePlaceholder)
-						.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get())
-						.reduce((a,b) -> { a.addAll(b); return a;} ).get();
+						.map(z -> ((TypePlaceholder)z.getType()).getName()).collect(Collectors.toCollection(HashSet::new)))
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;}, (a,b) -> { a.addAll(b); return a;} )  )
+						.reduce(new HashSet<String>(), (a,b) -> { a.addAll(b); return a;} );
 				
 				Set<String> returnTypeVarNames = allClasses.stream().map(x -> x.getMethods().stream().filter(y -> y.getReturnType() instanceof TypePlaceholder)
 						.map(z -> ((TypePlaceholder)z.getReturnType()).getName()).collect(Collectors.toCollection(HashSet::new))).reduce((a,b) -> { a.addAll(b); return a;} ).get();
diff --git a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
index e3f4de88..b05dd0ee 100644
--- a/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
+++ b/src/de/dhbwstuttgart/syntaxtree/factory/UnifyTypeFactory.java
@@ -51,6 +51,10 @@ public class UnifyTypeFactory {
         return new UnifyPair(tl, tr, PairOperator.SMALLERDOT);
     }
 
+    public static UnifyPair generateSmallNotEqualDotPair(UnifyType tl, UnifyType tr){
+        return new UnifyPair(tl, tr, PairOperator.SMALLERNEQDOT);
+    }
+    
     public static UnifyPair generateEqualDotPair(UnifyType tl, UnifyType tr){
         return new UnifyPair(tl, tr, PairOperator.EQUALSDOT);
     }
@@ -152,6 +156,10 @@ public class UnifyTypeFactory {
             UnifyPair ret = generateSmallerDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
             return ret;
+        }else if(p.GetOperator().equals(PairOperator.SMALLERNEQDOT)) {
+            UnifyPair ret = generateSmallNotEqualDotPair(UnifyTypeFactory.convert(p.TA1)
+                    , UnifyTypeFactory.convert(p.TA2));
+            return ret;
         }else if(p.GetOperator().equals(PairOperator.EQUALSDOT)) {
             UnifyPair ret = generateEqualDotPair(UnifyTypeFactory.convert(p.TA1)
                     , UnifyTypeFactory.convert(p.TA2));
diff --git a/src/de/dhbwstuttgart/typeinference/constraints/Pair.java b/src/de/dhbwstuttgart/typeinference/constraints/Pair.java
index eb322274..98679f7d 100644
--- a/src/de/dhbwstuttgart/typeinference/constraints/Pair.java
+++ b/src/de/dhbwstuttgart/typeinference/constraints/Pair.java
@@ -42,14 +42,16 @@ public class Pair implements Serializable
         if( TA2 != null )
            strElement2 = TA2.toString();
         
+       /* PL ausskommentiert 2018-05-24
         if(OperatorEqual())
         	Operator = "=";
         if(OperatorSmaller())
         	Operator = "<.";
         if(OperatorSmallerExtends())
         	Operator = "<?";
+        	*/
         
-        return "\n(" + strElement1 + " " + Operator + " " + strElement2 + ")";
+        return "\n(" + strElement1 + " " + eOperator.toString() + " " + strElement2 + ")";
         
        /*- Equals: " + bEqual*/
     }
diff --git a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
index 4dad9de6..fcd8ecfa 100644
--- a/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
+++ b/src/de/dhbwstuttgart/typeinference/typeAlgo/TYPEStmt.java
@@ -217,7 +217,7 @@ public class TYPEStmt implements StatementVisitor{
                 binary.operation.equals(BinaryExpr.Operator.MUL)||
                 binary.operation.equals(BinaryExpr.Operator.MOD)||
                 binary.operation.equals(BinaryExpr.Operator.ADD)){
-            Set<Constraint> numericAdditionOrStringConcatenation = new HashSet<>();
+            Set<Constraint<Pair>> numericAdditionOrStringConcatenation = new HashSet<>();
             
             //Zuerst der Fall für Numerische AusdrücPairOpnumericeratorke, das sind Mul, Mod und Div immer:
             //see: https://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.17
@@ -272,8 +272,8 @@ public class TYPEStmt implements StatementVisitor{
                 binary.operation.equals(BinaryExpr.Operator.BIGGEREQUAL) ||
                 binary.operation.equals(BinaryExpr.Operator.BIGGERTHAN) ||
                 binary.operation.equals(BinaryExpr.Operator.LESSTHAN)){
-        	//eingefuegt PL 2018-05-24
-        	Set<Constraint> numericRelationConcatenation = new HashSet<>();
+  /*      	//eingefuegt PL 2018-05-24
+        	Set<Constraint<Pair>> numericRelationConcatenation = new HashSet<>();
         	Constraint<Pair> numeric = new Constraint<>();
         	numeric.add(new Pair(binary.lexpr.getType(), bytee, PairOperator.SMALLERDOT));
             numeric.add(new Pair(binary.rexpr.getType(), bytee, PairOperator.SMALLERDOT));
@@ -308,7 +308,13 @@ public class TYPEStmt implements StatementVisitor{
             //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
             constraintsSet.addOderConstraint(numericRelationConcatenation);
             //***ACHTUNG: Moeglicherweise oder und und-Contraint falsch
-            
+    */        
+            //Testeise eingefuegt PL 2018-05-24
+            constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERNEQDOT));
+            constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERNEQDOT));
+            //Rückgabetyp ist Boolean
+            constraintsSet.addUndConstraint(new Pair(bool, binary.getType(), PairOperator.SMALLERDOT));
+        	
             //auskommentiert PL 2018-05-24
             //constraintsSet.addUndConstraint(new Pair(binary.lexpr.getType(), number, PairOperator.SMALLERDOT));
             //constraintsSet.addUndConstraint(new Pair(binary.rexpr.getType(), number, PairOperator.SMALLERDOT));
diff --git a/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java b/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
index 5631724b..8c1c60ae 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/RuleSet.java
@@ -369,9 +369,13 @@ public class RuleSet implements IRuleSet{
 
 	@Override
 	public boolean erase1(UnifyPair pair, IFiniteClosure fc) {
-		if(pair.getPairOp() != PairOperator.SMALLERDOT)
+		if((pair.getPairOp() != PairOperator.SMALLERDOT) && (pair.getPairOp() != PairOperator.SMALLERNEQDOT))
 			return false;
 		
+		if ((pair.getPairOp() == PairOperator.SMALLERNEQDOT) && (pair.getLhsType().equals(pair.getRhsType()))) {
+			return false;
+		}
+		
 		UnifyType lhsType = pair.getLhsType();
 		if(!(lhsType instanceof ReferenceType) && !(lhsType instanceof PlaceholderType))
 			return false;
diff --git a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
index 1d5ca564..bd50d5de 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/TypeUnifyTask.java
@@ -586,8 +586,13 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 	
 
 	protected boolean isUndefinedPairSet(Set<UnifyPair> s) {
+		if (s.size() >= 1 ) {
 			Boolean ret = s.stream().map(x -> x.isUndefinedPair()).reduce(true, (x,y)-> (x && y));
 			return ret;
+		}
+		else { 
+			return false;
+		}
 	}
 	
 	protected boolean isUndefinedPairSetSet(Set<Set<UnifyPair>> s) {
@@ -789,10 +794,15 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			UnifyType rhsType = pair.getRhsType();
 	
 			// Case 1: (a <. Theta')
-			if(pairOp == PairOperator.SMALLERDOT && lhsType instanceof PlaceholderType) {
+			if (((pairOp == PairOperator.SMALLERDOT) || (pairOp == PairOperator.SMALLERNEQDOT))  && lhsType instanceof PlaceholderType) {
 				//System.out.println(pair);
 				if (first) { //writeLog(pair.toString()+"\n");
 					Set<Set<UnifyPair>> x1 = unifyCase1(pair, fc);
+					if (pairOp == PairOperator.SMALLERNEQDOT) {
+						Set<UnifyType> remElem = new HashSet<>();
+						remElem.add(pair.getRhsType());
+						x1.remove(remElem);
+					}
 				//System.out.println(x1);
 					result.get(0).add(x1);
 					if (x1.isEmpty()) {
@@ -848,10 +858,15 @@ public class TypeUnifyTask extends RecursiveTask<Set<Set<UnifyPair>>>  {
 			//	result.get(3).add(unifyCase4((PlaceholderType) lhsType, rhsType, fc));
 				
 			// Case 5: (Theta <. a)
-			else if(pairOp == PairOperator.SMALLERDOT && rhsType instanceof PlaceholderType)
+			else if (((pairOp == PairOperator.SMALLERDOT) || (pairOp == PairOperator.SMALLERNEQDOT)) && rhsType instanceof PlaceholderType)
 				if (first) { //writeLog(pair.toString()+"\n");
 					Set<Set<UnifyPair>> x1 = unifyCase5(pair, fc);
 					result.get(4).add(x1);
+					if (pairOp == PairOperator.SMALLERNEQDOT) {
+						Set<UnifyType> remElem = new HashSet<>();
+						remElem.add(pair.getLhsType());
+						x1.remove(remElem);
+					}
 					if (x1.isEmpty()) {
 						undefined.add(pair); //Theta ist nicht im FC
 					}
diff --git a/src/de/dhbwstuttgart/typeinference/unify/model/PairOperator.java b/src/de/dhbwstuttgart/typeinference/unify/model/PairOperator.java
index fd18f6c0..ea323c79 100644
--- a/src/de/dhbwstuttgart/typeinference/unify/model/PairOperator.java
+++ b/src/de/dhbwstuttgart/typeinference/unify/model/PairOperator.java
@@ -17,6 +17,12 @@ public enum PairOperator {
 	 */
 	SMALLERDOT,
 	
+	/**
+	 * The smallernedot operator for arguments (T <!=. P) is the same as SMALLERDOT without
+	 * T == P. It is used for operations + / - / * / < / > / ... with the Supertype Number
+	 */
+	SMALLERNEQDOT,
+	
 	/**
 	 * The smallerdot operator for arguments (T <.? P) is used to express that 
 	 * T is an element of smArg(P) (or P is an element of grArg(T)) in a CONSTRAINT 
@@ -35,6 +41,7 @@ public enum PairOperator {
 		switch (this) {
 			case SMALLER: return "<";
 			case SMALLERDOT: return "<.";
+			case SMALLERNEQDOT: return "<!=.";
 			case SMALLERDOTWC: return "<.?";
 			default: return "=."; // EQUALSDOT
 		}
diff --git a/test/bytecode/LambdaTest.java b/test/bytecode/LambdaTest.java
index 12e16829..f29690cb 100644
--- a/test/bytecode/LambdaTest.java
+++ b/test/bytecode/LambdaTest.java
@@ -13,7 +13,7 @@ public class LambdaTest {
 	
 	@Test
 	public void generateBC() throws Exception {
-		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Lambda2.jav";
+		path = System.getProperty("user.dir")+"/test/bytecode/javFiles/Lambda.jav";
 		fileToTest = new File(path);
 		compiler = new JavaTXCompiler(fileToTest);
 		compiler.generateBytecode();
diff --git a/test/bytecode/javFiles/RelOps.jav b/test/bytecode/javFiles/RelOps.jav
index d75ee2f3..0fdd2cff 100644
--- a/test/bytecode/javFiles/RelOps.jav
+++ b/test/bytecode/javFiles/RelOps.jav
@@ -1,4 +1,5 @@
 import java.lang.Integer;
+import java.lang.Boolean;
 
 public class RelOps {
 	m(a,b){
diff --git a/test/javFiles/Matrix.jav b/test/javFiles/Matrix.jav
index 8b01c235..5e1eac08 100644
--- a/test/javFiles/Matrix.jav
+++ b/test/javFiles/Matrix.jav
@@ -16,8 +16,8 @@ class Matrix extends Vector<Vector<Integer>> {
                 var k = 0;
                 while(k < v1.size()) {
                   erg = erg + v1.elementAt(k) * m.elementAt(k).elementAt(j);
-                    //erg = add1(erg, mul1(v1.elementAt(k),
-                    //         m.elementAt(k).elementAt(j)));
+                  //erg = add1(erg, mul1(v1.elementAt(k),
+                  //           m.elementAt(k).elementAt(j)));
                     k++; }
                 v2.addElement(new Integer(erg));
                 j++; }