diff --git a/src/mw_parser/declarative.clj b/src/mw_parser/declarative.clj
index 1801b12..2a274b4 100644
--- a/src/mw_parser/declarative.clj
+++ b/src/mw_parser/declarative.clj
@@ -29,7 +29,8 @@
    DISJUNCT-EXPRESSION := IN SPACE DISJUNCT-VALUE;
    RANGE-EXPRESSION := BETWEEN SPACE NUMERIC-EXPRESSION SPACE AND SPACE NUMERIC-EXPRESSION;
    NUMERIC-EXPRESSION := VALUE | VALUE SPACE OPERATOR SPACE NUMERIC-EXPRESSION;
-   QUALIFIER := COMPARATIVE SPACE THAN | EQUIVALENCE | IS SPACE QUALIFIER;
+   NEGATED-QUALIFIER := QUALIFIER SPACE NOT | NOT SPACE QUALIFIER;
+   QUALIFIER := NEGATED-QUALIFIER | IS COMPARATIVE SPACE THAN | EQUIVALENCE | IS SPACE QUALIFIER;
    QUANTIFIER := NUMBER | SOME | NONE | ALL;
    EQUIVALENCE := IS SPACE EQUAL | EQUAL | IS ;
    COMPARATIVE := MORE | LESS;
@@ -38,6 +39,7 @@
    THEN := 'then';
    THAN := 'than';
    OR := 'or';
+   NOT := 'not';
    AND := 'and';
    SOME := 'some';
    NONE := 'no';
@@ -132,7 +134,10 @@
          qualifier (generate (nth tree 2))
          expression (generate (nth tree 3))]
      (case expression-type
-       :DISJUNCT-EXPRESSION (list 'let ['value (list property 'cell)] (list 'some (list 'fn ['i] '(= i value)) (list 'quote expression)))
+       :DISJUNCT-EXPRESSION (let [e (list 'some (list 'fn ['i] '(= i value)) (list 'quote expression))]
+                              (list 'let ['value (list property 'cell)]
+                                  (if (= qualifier '=) e
+                                    (list 'not e))))
        :RANGE-EXPRESSION (generate-ranged-property-condition tree property expression)
        (list qualifier (list property 'cell) expression)))))
 
@@ -173,26 +178,32 @@
   (if
     (coll? tree)
     (case (first tree)
-      :RULE (generate-rule tree)
-      :CONDITIONS (generate-conditions tree)
+      :ACTIONS (generate-multiple-actions tree)
+      :COMPARATIVE (generate (second tree))
       :CONDITION (generate-condition tree)
-      ;;    :NEIGHBOURS-CONDITION (generate-neighbours-condition tree)
-      :DISJUNCT-CONDITION (generate-disjunct-condition tree)
+      :CONDITIONS (generate-conditions tree)
       :CONJUNCT-CONDITION (generate-conjunct-condition tree)
+      :DISJUNCT-CONDITION (generate-disjunct-condition tree)
       :PROPERTY-CONDITION (generate-property-condition tree)
       :DISJUNCT-EXPRESSION (generate (nth tree 2))
-      :NUMERIC-EXPRESSION (generate-numeric-expression tree)
       :DISJUNCT-VALUE (generate-disjunct-value tree)
-      :SIMPLE-ACTION (generate-simple-action tree)
-      :ACTIONS (generate-multiple-actions tree)
-      :SYMBOL (keyword (second tree))
-      :NUMBER (read-string (second tree))
       :EQUIVALENCE '=
-      :MORE '>
+      :EXPRESSION (generate (second tree))
       :LESS '<
-      :COMPARATIVE (generate (second tree))
-      ;;    :EXPRESSION (generate-expression tree)
-      ;;    :SIMPLE-EXPRESSION
+      :MORE '>
+      :NEGATED-QUALIFIER (case (generate (second tree))
+                                 = 'not=
+                                 > '<
+                                 < '>)
+      ;;    :NEIGHBOURS-CONDITION (generate-neighbours-condition tree)
+      :NUMERIC-EXPRESSION (generate-numeric-expression tree)
+      :NUMBER (read-string (second tree))
+      :PROPERTY (list (generate (second tree)) 'cell) ;; dubious - may not be right
+      :QUALIFIER (generate (second tree))
+      :RULE (generate-rule tree)
+      :SIMPLE-ACTION (generate-simple-action tree)
+      :SYMBOL (keyword (second tree))
+      :VALUE (generate (second tree))
       (map generate tree))
     tree))
 
@@ -229,22 +240,24 @@
   (if
     (coll? tree)
     (case (first tree)
+      :ACTION (simplify-second-of-two tree)
+      :ACTIONS (simplify-second-of-two tree)
+      :COMPARATIVE (simplify-second-of-two tree)
+      :CONDITION (simplify-second-of-two tree)
+      :CONDITIONS (simplify-second-of-two tree)
+      :EXPRESSION (simplify-second-of-two tree)
+      :QUANTIFIER (simplify-second-of-two tree)
+      :NOT nil
+      :PROPERTY (simplify-second-of-two tree)
       :SPACE nil
       :THEN nil
-      :QUALIFIER (simplify-qualifier tree)
-      :CONDITIONS (simplify-second-of-two tree)
-      :CONDITION (simplify-second-of-two tree)
-      :EXPRESSION (simplify-second-of-two tree)
-      :COMPARATIVE (simplify-second-of-two tree)
-      :QUANTIFIER (simplify-second-of-two tree)
+      ;; :QUALIFIER (simplify-qualifier tree)
       :VALUE (simplify-second-of-two tree)
-      :PROPERTY (simplify-second-of-two tree)
-      :ACTIONS (simplify-second-of-two tree)
-      :ACTION (simplify-second-of-two tree)
       (remove nil? (map simplify tree)))
     tree))
 
 (def parse-rule
+  "Parse the argument, assumed to be a string in the correct syntax, and return a parse tree."
   (insta/parser grammar))
 
 (defn explain-parse-error-reason
@@ -277,7 +290,7 @@
   [rule]
   (assert (string? rule))
   (let [tree (simplify (parse-rule rule))]
-    (if (rule? rule) (generate tree)
+    (if (rule? tree) (eval (generate tree))
       (throw-parse-exception tree))))
 
 
diff --git a/test/mw_parser/declarative_test.clj b/test/mw_parser/declarative_test.clj
index 67b31d1..1b40eb9 100644
--- a/test/mw_parser/declarative_test.clj
+++ b/test/mw_parser/declarative_test.clj
@@ -95,7 +95,413 @@
          "Exception thrown on attempt to set 'y'")
     ))
 
-(deftest compilation-tests
-  (testing "Full compilation of rules"
+(deftest correctness-tests
+  ;; these are, in so far as possible, the same as the correctness-tests in core-tests - i.e., the two compilers
+  ;; compile the same language.
+  (testing "Simplest possible rule"
+           (let [afn (compile-rule "if state is new then state should be grassland")]
+                 (is (= (apply afn (list {:state :new} nil))
+                            {:state :grassland})
+                     "Rule fires when condition is met")
+                 (is (nil? (apply afn (list {:state :forest} nil))))
+                     "Rule doesn't fire when condition isn't met"))
 
+  (testing "Condition conjunction rule"
+           (let [afn (compile-rule "if state is new and altitude is 0 then state should be water")]
+                 (is (= (apply afn (list {:state :new :altitude 0} nil))
+                            {:state :water :altitude 0})
+                     "Rule fires when conditions are met")
+                 (is (nil? (apply afn (list {:state :new :altitude 5} nil)))
+                     "Rule does not fire: second condition not met")
+                 (is (nil?  (apply afn (list {:state :forest :altitude 0} nil)))
+                     "Rule does not fire: first condition not met")))
+
+  (testing "Condition disjunction rule"
+           (let [afn (compile-rule "if state is new or state is waste then state should be grassland")]
+                 (is (= (apply afn (list {:state :new} nil))
+                            {:state :grassland})
+                     "Rule fires: first condition met")
+                 (is (= (apply afn (list {:state :waste} nil))
+                            {:state :grassland})
+                     "Rule fires: second condition met")
+                 (is (nil?  (apply afn (list {:state :forest} nil)))
+                     "Rule does not fire: neither condition met")))
+
+  (testing "Simple negation rule"
+           (let [afn (compile-rule "if state is not new then state should be grassland")]
+                 (is (nil? (apply afn (list {:state :new} nil)))
+                     "Rule doesn't fire when condition isn't met")
+                 (is (= (apply afn (list {:state :forest} nil))
+                            {:state :grassland})
+                     "Rule fires when condition is met")))
+
+  (testing "Can't set x or y properties"
+         (is (thrown-with-msg?
+          Exception #"The properties 'x' and 'y' of a cell are reserved and should not be set in rule actions"
+          (compile-rule "if state is new then x should be 0"))
+         "Exception thrown on attempt to set 'x'")
+     (is (thrown-with-msg?
+          Exception #"The properties 'x' and 'y' of a cell are reserved and should not be set in rule actions"
+          (compile-rule "if state is new then y should be 0"))
+         "Exception thrown on attempt to set 'y'"))
+
+  (testing "Simple list membership rule"
+           (let [afn (compile-rule "if state is in heath or scrub or forest then state should be climax")]
+             (is (= (apply afn (list {:state :heath} nil))
+                    {:state :climax})
+                 "Rule fires when condition is met")
+             (is (= (apply afn (list {:state :scrub} nil))
+                    {:state :climax})
+                 "Rule fires when condition is met")
+             (is (= (apply afn (list {:state :forest} nil))
+                    {:state :climax})
+                 "Rule fires when condition is met")
+             (is (nil? (apply afn (list {:state :grassland} nil)))
+                 "Rule does not fire when condition is not met")))
+
+  (testing "Negated list membership rule"
+           (let [afn (compile-rule "if state is not in heath or scrub or forest then state should be climax")]
+             (is (nil? (apply afn (list {:state :heath} nil)))
+                 "Rule does not fire when condition is not met")
+             (is (nil? (apply afn (list {:state :scrub} nil)))
+                 "Rule does not fire when condition is not met")
+             (is (nil? (apply afn (list {:state :forest} nil)))
+                 "Rule does not fire when condition is not met")
+             (is (= (apply afn (list {:state :grassland} nil))
+                    {:state :climax})
+                 "Rule fires when condition is met")))
+
+  (testing "Property is more than numeric-value"
+           (let [afn (compile-rule "if altitude is more than 200 then state should be snow")]
+             (is (= (apply afn (list {:altitude 201} nil))
+                    {:state :snow :altitude 201})
+                 "Rule fires when condition is met")
+             (is (nil? (apply afn (list {:altitude 200} nil)))
+                 "Rule does not fire when condition is not met")))
+
+  (testing "Property is more than property"
+           (let [afn (compile-rule "if wolves are more than deer then deer should be 0")]
+             (is (= (apply afn (list {:deer 2 :wolves 3} nil))
+                    {:deer 0 :wolves 3})
+                 "Rule fires when condition is met")
+             (is (nil? (apply afn (list {:deer 3 :wolves 2} nil)))
+                 "Rule does not fire when condition is not met")))
+
+  (testing "Property is less than numeric-value"
+           (let [afn (compile-rule "if altitude is less than 10 then state should be water")]
+             (is (= (apply afn (list {:altitude 9} nil))
+                    {:state :water :altitude 9})
+                 "Rule fires when condition is met")
+             (is (nil? (apply afn (list {:altitude 10} nil)))
+                 "Rule does not fire when condition is not met")))
+
+  (testing "Property is less than property"
+           (let [afn (compile-rule "if wolves are less than deer then deer should be deer - wolves")]
+             (is (= (apply afn (list {:deer 3 :wolves 2} nil))
+                    {:deer 1 :wolves 2})
+                 "Rule fires when condition is met")
+             (is (nil? (apply afn (list {:deer 2 :wolves 3} nil)))
+                 "Rule does not fire when condition is not met")))
+
+  (testing "Number neighbours have property equal to value"
+           (let [afn (compile-rule "if 3 neighbours have state equal to new then state should be water")
+                 world (make-world 3 3)]
+             (is (= (apply afn (list {:x 0 :y 0} world))
+                    {:state :water :x 0 :y 0})
+                 "Rule fires when condition is met (in a new world all cells are new, corner cell has three neighbours)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell has eight neighbours, so rule does not fire."))
+           (let [afn (compile-rule "if 3 neighbours are new then state should be water")
+                 world (make-world 3 3)]
+             ;; 'are new' should be the same as 'have state equal to new'
+             (is (= (apply afn (list {:x 0 :y 0} world))
+                    {:state :water :x 0 :y 0})
+                 "Rule fires when condition is met (in a new world all cells are new, corner cell has three neighbours)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell has eight neighbours, so rule does not fire.")))
+
+  (testing "Number neighbours have property more than numeric-value"
+           (let [afn (compile-rule "if 3 neighbours have altitude more than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire.")))
+
+  (testing "Number neighbours have property less than numeric-value"
+           (let [afn (compile-rule "if 5 neighbours have altitude less than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has two high neighbours, so rule should not fire.")))
+
+  (testing "More than number neighbours have property equal to numeric-value"
+           (let [afn (compile-rule "if more than 2 neighbours have altitude equal to 11 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire.")))
+
+  (testing "More than number neighbours have property equal to symbolic-value"
+           (let [afn (compile-rule "if more than 2 neighbours have state equal to grassland then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is less than 2 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire."))
+           (let [afn (compile-rule "if more than 2 neighbours are grassland then state should be beach")
+                 ;; 'are grassland' should mean the same as 'have state equal to grassland'.
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is less than 2 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire."))
+           )
+
+  (testing "Fewer than number neighbours have property equal to numeric-value"
+           (let [afn (compile-rule "if fewer than 3 neighbours have altitude equal to 11 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 2 :y 1} world))) :beach)
+                 "Rule fires when condition is met (Middle cell of the strip has only two high neighbours)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell of world has three high neighbours, so rule should not fire.")))
+
+  (testing "Fewer than number neighbours have property equal to symbolic-value"
+           (let [afn (compile-rule "if fewer than 3 neighbours have state equal to grassland then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is less than 2 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 2 :y 1} world))) :beach)
+                 "Rule fires when condition is met (Middle cell of the strip has only two high neighbours)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell of world has three high neighbours, so rule should not fire.")))
+
+;; some neighbours have property equal to value
+  (testing "Some neighbours have property equal to numeric-value"
+           (let [afn (compile-rule "if some neighbours have altitude equal to 11 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 0 :y 1} world)))
+                 "Left hand side of world has no high neighbours, so rule should not fire.")))
+
+  (testing "Some neighbours have property equal to symbolic-value"
+           (let [afn (compile-rule "if some neighbours have state equal to grassland then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is less than 2 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 0 :y 1} world)))
+                 "Left hand side of world has no high neighbours, so rule should not fire.")))
+
+;; more than number neighbours have property more than numeric-value
+  (testing "More than number neighbours have property more than symbolic-value"
+           (let [afn (compile-rule "if more than 2 neighbours have altitude more than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is less than 2 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire.")))
+
+;; fewer than number neighbours have property more than numeric-value
+  (testing "Fewer than number neighbours have property more than numeric-value"
+           (let [afn (compile-rule "if fewer than 3 neighbours have altitude more than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 2 :y 1} world))) :beach)
+                 "Rule fires when condition is met (Middle cell of the strip has only two high neighbours)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell of world has three high neighbours, so rule should not fire.")))
+
+;; some neighbours have property more than numeric-value
+  (testing "Some neighbours have property more than numeric-value"
+           (let [afn (compile-rule "if some neighbours have altitude more than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 0 :y 1} world)))
+                 "Left hand side of world has no high neighbours, so rule should not fire.")))
+
+;; more than number neighbours have property less than numeric-value
+  (testing "More than number neighbours have property less than numeric-value"
+           (let [afn (compile-rule "if more than 4 neighbours have altitude less than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 2 :y 1} world)))
+                 "Middle cell of the strip has only three low neighbours, so rule should not fire.")))
+
+;; fewer than number neighbours have property less than numeric-value
+  (testing "Fewer than number neighbours have property less than numeric-value"
+           (let [afn (compile-rule "if fewer than 4 neighbours have altitude less than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is 2 then altitude should be 11")
+                               (compile-rule "if x is less than 2 then altitude should be 0")))]
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Centre cell has five low neighbours, so rule should not fire")
+             (is (= (:state (apply afn (list {:x 2 :y 1} world))) :beach)
+                 "Middle cell of the strip has only three low neighbours, so rule should  fire.")))
+
+;; some neighbours have property less than numeric-value
+  (testing "Some number neighbours have property less than numeric-value"
+           (let [afn (compile-rule "if some neighbours have altitude less than 10 then state should be beach")
+                 world (transform-world
+                         (make-world 3 3)
+                         (list (compile-rule "if x is less than 2 then altitude should be 11")
+                               (compile-rule "if x is 2 then altitude should be 0")))]
+             (is (= (:state (apply afn (list {:x 1 :y 1} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 0 down right hand side)")
+             (is (nil? (apply afn (list {:x 0 :y 1} world)))
+                 "Left of world is all high, so rule should not fire.")))
+
+
+;; 'single action' already tested in 'condition' tests above
+;; action and actions
+  (testing "Conjunction of actions"
+           (let [afn (compile-rule "if state is new then state should be grassland and fertility should be 0")]
+                 (is (= (apply afn (list {:state :new} nil))
+                            {:state :grassland :fertility 0})
+                     "Both actions are executed")))
+
+;; 'property should be symbolic-value' and 'property should be numeric-value'
+;; already tested in tests above
+
+;; number chance in number property should be value
+  (testing "Syntax of probability rule - action of real probability very hard to test"
+           (let [afn (compile-rule "if state is forest then 5 chance in 5 state should be climax")]
+             (is (= (:state (apply afn (list {:state :forest} nil))) :climax)
+                 "five chance in five should fire every time"))
+           (let [afn (compile-rule "if state is forest then 0 chance in 5 state should be climax")]
+             (is (nil? (apply afn (list {:state :forest} nil)))
+                 "zero chance in five should never fire")))
+
+;; property operator numeric-value
+  (testing "Arithmetic action: addition of number"
+           (let [afn (compile-rule "if state is climax then fertility should be fertility + 1")]
+                 (is (= (:fertility
+                          (apply afn (list {:state :climax :fertility 0} nil)))
+                        1)
+                     "Addition is executed")))
+
+  (testing "Arithmetic action: addition of property value"
+           (let [afn (compile-rule "if state is climax then fertility should be fertility + leaf-fall")]
+                 (is (= (:fertility
+                          (apply afn
+                                 (list {:state :climax
+                                        :fertility 0
+                                        :leaf-fall 1} nil)))
+                        1)
+                     "Addition is executed")))
+
+  (testing "Arithmetic action: subtraction of number"
+           (let [afn (compile-rule "if state is crop then fertility should be fertility - 1")]
+                 (is (= (:fertility
+                          (apply afn (list {:state :crop :fertility 2} nil)))
+                        1)
+                     "Action is executed")))
+
+  (testing "Arithmetic action: subtraction of property value"
+           (let [afn (compile-rule "if wolves are more than 0 then deer should be deer - wolves")]
+                 (is (= (:deer
+                          (apply afn
+                                 (list {:deer 3
+                                        :wolves 2} nil)))
+                        1)
+                     "Action is executed")))
+
+  (testing "Arithmetic action: multiplication by number"
+           (let [afn (compile-rule "if deer are more than 1 then deer should be deer * 2")]
+                 (is (= (:deer
+                          (apply afn (list {:deer 2} nil)))
+                        4)
+                     "Action is executed")))
+
+  (testing "Arithmetic action: multiplication by property value"
+           (let [afn (compile-rule "if state is crop then deer should be deer * deer")]
+                 (is (= (:deer
+                          (apply afn
+                                 (list {:state :crop :deer 2} nil)))
+                        4)
+                     "Action is executed")))
+
+  (testing "Arithmetic action: division by number"
+           (let [afn (compile-rule "if wolves are more than 0 then deer should be deer / 2")]
+                 (is (= (:deer
+                          (apply afn (list {:deer 2 :wolves 1} nil)))
+                        1)
+                     "Action is executed")))
+
+  (testing "Arithmetic action: division by property value"
+           (let [afn (compile-rule "if wolves are more than 0 then deer should be deer / wolves")]
+                 (is (= (:deer
+                          (apply afn
+                                 (list {:deer 2 :wolves 2} nil)))
+                        1)
+                     "Action is executed")))
+
+;; simple within distance
+  (testing "Number neighbours within distance have property equal to value"
+           (let [afn (compile-rule "if 8 neighbours within 2 have state equal to new then state should be water")
+                 world (make-world 5 5)]
+              (is (= (apply afn (list {:x 0 :y 0} world))
+                    {:state :water :x 0 :y 0})
+                 "Rule fires when condition is met (in a new world all cells are new, corner cell has eight neighbours within two)")
+             (is (nil? (apply afn (list {:x 1 :y 1} world)))
+                 "Middle cell has twenty-four neighbours within two, so rule does not fire.")))
+
+;; comparator within distance
+  (testing "More than number neighbours within distance have property equal to symbolic-value"
+           (let [afn (compile-rule "if more than 7 neighbours within 2 have state equal to grassland and more than 7 neighbours within 2 have state equal to water then state should be beach")
+                 ;; 5x5 world, strip of high ground two cells wide down left hand side
+                 ;; xxooo
+                 ;; xxooo
+                 ;; xxooo
+                 ;; xxooo
+                 ;; xxooo
+                 world (transform-world
+                         (make-world 5 5)
+                         (list (compile-rule "if x is less than 2 then altitude should be 11 and state should be grassland")
+                               (compile-rule "if x is more than 1 then altitude should be 0 and state should be water")))]
+             (is (= (:state (apply afn (list {:x 2 :y 2} world))) :beach)
+                 "Rule fires when condition is met (strip of altitude 11 down right hand side)")
+             (is (nil? (apply afn (list {:x 0 :y 1} world)))
+                 "Middle cell of the strip has only two high neighbours, so rule should not fire."))
     ))