diff --git a/eraser-base/src/main/jastadd/eraser.flex b/eraser-base/src/main/jastadd/eraser.flex
index ffb7bdeb5d40bdb7d81bff427a018d9ad275bb5e..0dd979a642a1efd7e311e863a198bb8d9ab51769 100644
--- a/eraser-base/src/main/jastadd/eraser.flex
+++ b/eraser-base/src/main/jastadd/eraser.flex
@@ -102,12 +102,12 @@ Comment = "//" [^\n\r]+
 // special characters
 "="            { return sym(Terminals.EQUALS); }
 //"\""           { return sym(Terminals.QUOTE); }
-"<"            { return sym(Terminals.LE); }
-"<="           { return sym(Terminals.LT); }
+"<"            { return sym(Terminals.LT); }
+"<="           { return sym(Terminals.LE); }
 "=="           { return sym(Terminals.EQ); }
 "!="           { return sym(Terminals.NE); }
+"=>"           { return sym(Terminals.GE); }
 ">"            { return sym(Terminals.GT); }
-">="           { return sym(Terminals.GE); }
 "+"            { return sym(Terminals.PLUS); }
 "*"            { return sym(Terminals.MULT); }
 "-"            { return sym(Terminals.MINUS); }
diff --git a/eraser-base/src/main/jastadd/eraser.parser b/eraser-base/src/main/jastadd/eraser.parser
index 0639a0fa3fe73ac5f75605fb991f95a1743abd99..0d4cf28d0fc945c9d81afb59beae97ccdd9d656c 100644
--- a/eraser-base/src/main/jastadd/eraser.parser
+++ b/eraser-base/src/main/jastadd/eraser.parser
@@ -74,7 +74,7 @@ NumberExpression number_expression =
 LogicalExpression logical_expression =
     LB_ROUND logical_expression.a AND   logical_expression.b RB_ROUND     {: return new AndExpression(a, b); :}
   | LB_ROUND logical_expression.a OR    logical_expression.b RB_ROUND     {: return new OrExpression(a, b); :}
-  | LB_ROUND EXCLAMATION logical_expression.e RB_ROUND                    {: return new NotExpression(e); :}
+  | EXCLAMATION logical_expression.e                                      {: return new NotExpression(e); :}
   | LB_ROUND logical_expression.e RB_ROUND                                {: return new ParenthesizedLogicalExpression(e); :}
   | LB_ROUND number_expression.a LT    number_expression.b RB_ROUND       {: return new ComparingExpression(a, b, ComparatorType.LessThan); :}
   | LB_ROUND number_expression.a LE    number_expression.b RB_ROUND       {: return new ComparingExpression(a, b, ComparatorType.LessOrEqualThan); :}
diff --git a/eraser-base/src/test/java/de/tudresden/inf/st/eraser/ExpressionParserTest.java b/eraser-base/src/test/java/de/tudresden/inf/st/eraser/ExpressionParserTest.java
index a7f959654ed4db35802b7e553e0db3926680695a..3d6fb52e4a601e6891de73b654a91395c7b134c1 100644
--- a/eraser-base/src/test/java/de/tudresden/inf/st/eraser/ExpressionParserTest.java
+++ b/eraser-base/src/test/java/de/tudresden/inf/st/eraser/ExpressionParserTest.java
@@ -95,7 +95,6 @@ public class ExpressionParserTest {
 
   @Test
   public void complexExpression() throws IOException, Parser.Exception {
-    ParserUtils.setVerboseLoading(true);
     NumberExpression sut = ParserUtils.parseNumberExpression("((3 + 4) * (1 / (12 - 8)))");
     assertThat(sut, instanceOf(MultExpression.class));
     MultExpression multExpression = (MultExpression) sut;
@@ -128,4 +127,72 @@ public class ExpressionParserTest {
     NumberLiteralExpression rightOfSub = (NumberLiteralExpression) rightofDiv.getRightOperand();
     assertThat(rightOfSub.getValue(), equalTo(8.0));
   }
+
+  @Test
+  public void comparingExpressions() throws IOException, Parser.Exception {
+    comparingExpression("<",  ComparatorType.LessThan, 1, 2);
+    comparingExpression("<=", ComparatorType.LessOrEqualThan, 3, 4);
+    comparingExpression("==", ComparatorType.Equals, 5, 6);
+    comparingExpression("!=", ComparatorType.NotEquals, 7, 8);
+    comparingExpression("=>", ComparatorType.GreaterOrEqualThan, 9, 10);
+    comparingExpression(">",  ComparatorType.GreaterThan, 11, 12);
+  }
+
+  private void comparingExpression(String actualComparatorString, ComparatorType expectedComparatorType, double left, double right) throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression(String.format("(%f %s %f)", left, actualComparatorString, right));
+    assertThat(sut, instanceOf(ComparingExpression.class));
+    ComparingExpression comparingExpression = (ComparingExpression) sut;
+    assertThat(comparingExpression.getLeftOperand(), instanceOf(NumberLiteralExpression.class));
+    NumberLiteralExpression leftExpression = (NumberLiteralExpression) comparingExpression.getLeftOperand();
+    assertThat(leftExpression.getValue(), equalTo(left));
+    assertThat(comparingExpression.getRightOperand(), instanceOf(NumberLiteralExpression.class));
+    NumberLiteralExpression rightExpression = (NumberLiteralExpression) comparingExpression.getRightOperand();
+    assertThat(rightExpression.getValue(), equalTo(right));
+    assertThat(comparingExpression.getComparator(), equalTo(expectedComparatorType));
+  }
+
+  @Test
+  public void notExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("!(0==0)");
+    assertThat(sut, instanceOf(NotExpression.class));
+    NotExpression notExpression = (NotExpression) sut;
+    checkZeroEqualsZero(notExpression.getOperand());
+  }
+
+  @Test
+  public void andExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0) & (0==0))");
+    assertThat(sut, instanceOf(AndExpression.class));
+    AndExpression notExpression = (AndExpression) sut;
+    checkZeroEqualsZero(notExpression.getLeftOperand());
+    checkZeroEqualsZero(notExpression.getRightOperand());
+  }
+
+  @Test
+  public void orExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0) | (0==0))");
+    assertThat(sut, instanceOf(OrExpression.class));
+    OrExpression notExpression = (OrExpression) sut;
+    checkZeroEqualsZero(notExpression.getLeftOperand());
+    checkZeroEqualsZero(notExpression.getRightOperand());
+  }
+
+  @Test
+  public void parenthesizedLogicalExpression() throws IOException, Parser.Exception {
+    LogicalExpression sut = ParserUtils.parseLogicalExpression("((0==0))");
+    assertThat(sut, instanceOf(ParenthesizedLogicalExpression.class));
+    ParenthesizedLogicalExpression parenthesizedLogicalExpression = (ParenthesizedLogicalExpression) sut;
+    checkZeroEqualsZero(parenthesizedLogicalExpression.getOperand());
+  }
+
+  private void checkZeroEqualsZero(LogicalExpression logicalExpression) {
+    assertThat(logicalExpression, instanceOf(ComparingExpression.class));
+    ComparingExpression comparingExpression = (ComparingExpression) logicalExpression;
+    assertThat(comparingExpression.getLeftOperand(), instanceOf(NumberLiteralExpression.class));
+    NumberLiteralExpression leftOfSSub = (NumberLiteralExpression) comparingExpression.getLeftOperand();
+    assertThat(leftOfSSub.getValue(), equalTo(0.0));
+    assertThat(comparingExpression.getRightOperand(), instanceOf(NumberLiteralExpression.class));
+    NumberLiteralExpression rightOfSub = (NumberLiteralExpression) comparingExpression.getRightOperand();
+    assertThat(rightOfSub.getValue(), equalTo(0.0));
+  }
 }