                 (log/error message)
 ;                (throw (exception message)))
 )
-              (do (log/trace (str "add-complement after adding complement: "
+              (do (log/debug (str "add-complement after adding complement: "
                                   (string/join ","
                                                (map (fn [each]
                                                       (morph each))

head of its parent. generate (above) 'decorates' each returned lightning bolt
of this function with complements."

  (if (and (not (= :fail spec))
           (not (empty? (strip-refs spec))))
    (log/trace (str "lighting-bolt@" depth " spec: " (strip-refs spec) "; parent: " (if parent
                                                                                      (:rule parent)))))
  (if (not parent)
    (log/trace (str "no parent for lightning-bolt@" depth " with spec: " (strip-refs spec))))
  (let [maxdepth 3 ;; maximum depth of a lightning bolt: H1 -> H2 -> H3 where H3 must be a lexeme, not a phrase.
        debug (log/trace (str "lightning-bolt@" depth " grammar:" (string/join ", " (map #(get-in % [:rule]) grammar))))

        depth (if depth depth 0)        
        ;; TODO: unifyc is expensive: factor out into a let.
        debug (log/trace (str "looking for candidate parents.."))
        candidate-parents (filter #(not (fail? %))
                                  (map (fn [rule]
                                         (unifyc spec rule))
                                       (if parent (get-head-phrases-of parent index)
                                           grammar)))

        debug (log/trace (str "done looking for candidate parents:" candidate-parents))
        
        debug (if (not (empty? candidate-parents))
                (log/trace (str "candidate-parents: " (string/join "," (map #(get-in % [:rule])
                                                                            candidate-parents))))
                (log/trace (str "no candidate-parents for spec: " (strip-refs spec))))]
    ;; TODO: remove or parameterize this hard-coded value.
    (if (> depth 5)
      (throw (exception (str "DEPTH IS GREATER THAN 5; HOW DID YOU END UP IN THIS TERRIBLE SITUATION? LOOK AT THE STACK. I'M OUTTA HERE."))))

                     (do
                       (let [result (get-lex immediate-parent :comp cache spec)]
                         (if (not (nil? result))
                           (log/debug (str " cached lexical subset ratio: " 
                                           (string/replace (str (/ (* 1.0 (/ (count lexicon) (count result)))))
                                                           #"\.(..).*"
                                                           (fn [[_ two-digits]] (str "." two-digits))))))
                         result))
                     (do (log/debug (str "no cache: will go through entire lexicon."))
                         nil))
            complement-candidate-lexemes (if cached cached (flatten (vals lexicon)))]
        (let [semantics (get-in spec [:synsem :sem])]
          (if (not (nil? semantics))
            (if (not (nil? semantics)) (log/debug (str "  with semantics:" (strip-refs semantics))))))
        (log/debug (str " immediate parent:" (get-in immediate-parent [:rule])))
        (let [complement-pre-check (fn [child parent path-to-child]
                                     (let [child-in-bolt (get-in bolt path-to-child)]
                                       (and (not (fail?
