   [language-model spec depth total-depth
                        & {:keys [max-total-depth]
                           :or {max-total-depth max-total-depth}}]
-  (log/debug (str "lightning-bolts: start: spec: " (spec-info spec)))
   (let [grammar (:grammar language-model)
         depth (if depth depth 0)
         ;; this is the relative depth; that is, the depth from the top of the current lightning bolt.

          phrasal ;; 2. generate list of all phrases where the head child of each parent is itself a phrase.
          (if (and (< total-depth max-total-depth)
                   (= true (get-in spec [:head :phrasal] true)))
            (do
              (lazy-mapcat (fn [parent]
                             (log/debug (str "calling lightning-bolts recursively: parent: " (:rule parent) " with spec : "
                                             (spec-info (get-in parent [:head]))))
                             (over/overh
                              parent
                              (lightning-bolts language-model (get-in parent [:head])
                                               (+ 1 depth) (+ 1 total-depth)
                                               :max-total-depth max-total-depth)))
                         (filter #(= true
                                     (get-in % [:head :phrasal] true))
                                 parents))))]
      (filter
       (fn [bolt]
         (any-possible-complement?

               (let [lexicon (or (:lexicon (:generate language-model)) (:lexicon language-model))
                     subset (if-let [index-fn (:index-fn language-model)]
                              (index-fn (get-in parent [:head] :top))
                              (flatten (vals lexicon)))]
                 (let [result (over/overh parent (shuffle subset))]
                   (if (and (not (empty? subset)) (empty? result)
                            (> (count subset)
                               50))
