                       (identical? member1 member2))
                     set2))
             set1)))
+
+(defn not-fail? [arg]
+  (not (= :fail arg)))

  (filter #(not (= :fail %))
          (pmap (fn [rule]
                  (log/trace (str "candidate-parents: rule: " (:rule rule)))
                  (if (and (not (fail? (unifyc (get-in rule [:synsem :cat] :top)
                                               (get-in spec [:synsem :cat] :top))))
                           (not (fail? (unifyc (get-in rule [:synsem :infl] :top)
                                               (get-in spec [:synsem :infl] :top))))
                           (not (fail? (unifyc (get-in rule [:synsem :sem :tense] :top)
                                               (get-in spec [:synsem :sem :tense] :top))))
                           (not (fail? (unifyc (get-in rule [:synsem :modified] :top)
                                               (get-in spec [:synsem :modified] :top)))))
                    (let [result
                           (unifyc spec rule)]
                      (if (fail? result)

        bolt-child-synsem (strip-refs (get-in bolt (concat path [:synsem]) :top))
        
        lexical-complements (lazy-shuffle
                             (filter (fn [lexeme]
                                       (and (not-fail? (unify (strip-refs (get-in lexeme [:synsem] :top))
                                                              bolt-child-synsem))))
                                     complement-candidate-lexemes))]
    (filter #(not-fail? %)
            (mapfn (fn [complement]
                     (let [unified
                           (unify (copy bolt)
