anchor.diff:      ;
   
   relationalExpression
  -    : (n1=numericExpression -> $n1) ( (EQUAL n2=numericExpression -> ^(EQUAL $relationalExpression $n2))   
  +    : (n1=numericExpression -> $n1) ((EQUAL n2=numericExpression -> ^(EQUAL $relationalExpression $n2))   
                                       | (NOT_EQUAL n3=numericExpression -> ^(NOT_EQUAL $relationalExpression $n3)) 
                                       | (LESS n4=numericExpression -> ^(LESS $relationalExpression $n4)) 
                                       | (GREATER n5=numericExpression -> ^(GREATER $relationalExpression $n5))
                                       | (LESS_EQUAL n6=numericExpression -> ^(LESS_EQUAL $relationalExpression $n6))
                                       | (GREATER_EQUAL n7=numericExpression -> ^(GREATER_EQUAL $relationalExpression $n7))  
                                       | (IN l2=expressionList -> ^(IN $relationalExpression $l2))
  -                                    | (NOT IN l3=expressionList -> ^(NOT IN $relationalExpression $l3)) )?
  +                                    | (NOT IN l3=expressionList -> ^(NOT IN $relationalExpression $l3)))?
       ;
   
   numericExpression
  
positive.code:     ;
  
  triplesSameSubjectPath
      : varOrTerm propertyListNotEmptyPath[(CommonTree)$varOrTerm.tree] -> ^(TRIPLE propertyListNotEmptyPath)
      | triplesNode propertyListNotEmpty[new CommonTree(new CommonToken(BLANK_NODE,"[]"))]? -> ^(TRIPLE  triplesNode (/*^(SUBJECT BLANK_NODE)*/ propertyListNotEmpty)?)
      ;
    
  propertyListNotEmptyPath[CommonTree subject]
      : verbSimpleOrPath objectList (SEMICOLON (verbSimpleOrPath objectList)?)* -> (^(SUBJECT {new CommonTree(subject)}) ^(PREDICATE verbSimpleOrPath) objectList)+
      ;
    
  verbSimpleOrPath
  
negative.code:     ;
      	
  path
      : pathSequence (PIPE pathSequence)* -> ^(PATH pathSequence+)
      ; 
  
  pathSequence
      : pathEltOrInverse (DIVIDE pathEltOrInverse)* -> ^(PATH_SEQUENCE pathEltOrInverse+)
      ;
  
  pathEltOrInverse
  