   (cond (and (= (get-in lexical-entry [:synsem :cat]) :verb)
              (not (nil? (get-in lexical-entry [:synsem :sem :obj])))
              (not (= (get-in lexical-entry [:synsem :sem :obj]) :unspec))
+
              ;; do not apply rule if (:subcat :2) is explicitly empty.
-             (not (= '() (get-in lexical-entry [:synsem :subcat :2]))))
+             (not (= '() (get-in lexical-entry [:synsem :subcat :2])))
+
+             ;; do not apply rule if there is :3.
+             (= :none (get-in lexical-entry [:synsem :subcat :3] :none)))
+
         (unifyc
          lexical-entry
          transitive-but-object-cat-not-set)

                                         (get-in map2 [first-fail-key])))
          (if (not (nil? first-fail-key))
            [first-fail-key]))))))


                                (fn [rule]
                                  ;; check for return value of (apply rule (list lexical-entry)):
                                  ;; if not list, make it a list.
                                  (let [debug (log/debug "applying rule: " rule " to lexical entry: " (strip-refs lexical-entry))
                                        result (rule lexical-entry)]
                                    (if (fail? result)
                                      (let [message
                                            (str "rule: " rule " caused lexical entry: " (strip-refs lexical-entry) " to fail.")]
                                        (log/error message)
                                        (throw (Exception. message)))
                                      (do
                                        (log/debug (str "rule: " rule " was ok."))
                                        result))))
                                rules))
                result (if (not (fail? result))
                         (reduce merge (map (fn [rule]
                                              (let [result (rule result)]
                                                (if (fail? result)
                                                  (do (log/error (str "merge-type lexical rule: " rule " caused lexical-entry: " lexical-entry 
                                                                      " to fail; fail path was: " (fail-path result)))
                                                      :fail)
                                                  result)))
                                            modifying-rules))
                           :fail)]
            (if (fail? result) 
              (do
