             ;; recursively call lightning-bolt with (+ 1 depth).
             (if (< depth maxdepth)
               (mapcat (fn [parent]
-                        (log/trace (str "calling over/overh with parent: " (get-in parent [:rule])))
+                        (log/debug (str "calling over/overh with parent: " (get-in parent [:rule])))
                         (let [phrasal-children
                               (lightning-bolt grammar lexicon
                                               (get-in parent [:head])
                                               (+ 1 depth)
                                               index parent morph)]
-                          (log/trace (str "calling overh with parent: [" (get-in parent [:rule]) "]" "'" (morph parent) "'"
-                                          " and children: "
-                                          (if phrasal-children
-                                            (str "(" (count phrasal-children) ")")
-                                            "(nil)")
-                                          (string/join ","
-                                           (map (fn [child]
-                                                  (str "[" (get-in child [:rule]) "]"
-                                                       "'" (morph child) "'"
-                                                       ))
-                                                phrasal-children))))
                           (if (empty? phrasal-children)
                             (let [message (str "no phrasal children for parent: " (morph parent) "(rule=" (get-in parent [:rule]) ")" )]
-                              (log/trace message))
+                              (log/debug message))
                             ;; else; there are phrasal-children, so attach them below parent:
                             (do
-                              (log/trace (str "phrasal-children:" (map morph phrasal-children)))
+                              (log/debug (str "phrasal-children:" (string/join "," (map morph phrasal-children))))
+                              (log/debug (str "calling overh with parent: [" (get-in parent [:rule]) "]" "'" (morph parent) "'"
+                                              " and " (count phrasal-children) " phrasal children."))
                               (over/overh parent phrasal-children morph)))
                           )
                         )


(defn exception [error-string]
  #?(:clj
     (throw (Exception. error-string)))
  #?(:cljs
     (throw (js/Error. error-string))))


              filtered-lexical-complements (filter (fn [lexeme]
                                                     (complement-pre-check lexeme bolt path))
                                                   complement-candidate-lexemes)
              debug (log/debug (str "pre-filtered size: " (count complement-candidate-lexemes)))
              debug (log/debug (str "filtered size: " (count filtered-lexical-complements)))
              shuffled-candidate-lexical-complements (lazy-shuffle filtered-lexical-complements)
              
              return-val
