                         (summaries/summary-changed! s)))    
      summaries/Summarizable (summarize [s] (summaries/or-summary s @tdb-atom)))))
 
-(defn connect-subsuming! [child subsuming-sp]
-  (when subsuming-sp (summaries/connect! child (tree-summarizer subsuming-sp) true)))
-
 (defn init-tree-summarizer! [ts inner-sp subsuming-sp]
   (connect-and-watch! ts inner-sp
     (fn [child-sp]
       (summaries/connect! ts (tree-summarizer child-sp) false)
       (add-top-down-bound! (tree-summarizer child-sp) (top-down-bound ts))
-      (summaries/summary-changed! ts))) ;; TODO: speedup? 
+      (summaries/summary-changed! ts))) ;; TODO: speedup by checking child reward? 
   (connect-subsuming! ts subsuming-sp))
-
-;; TODO: top-down bound business does not actually help at all ? 
-;; TODO: look at this.
-(comment         (let [my-sum (summaries/summary ret)
-                child-sum (summaries/summary (tree-summarizer child-sp))]
-            (when-not (summary/>= my-sum child-sum)
-              (summaries/summary-changed! ret))))
 
 (defn get-inner-sp [ts]
   (->> (summaries/node-ordinary-children ts)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


;; TODO: simplify this.
(defn- get-root-subproblem [inp-set fs]
  (let [root-stub (get-atomic-stub nil inp-set fs)
        inner-root (first (summary/extract-leaf-source-seq (summaries/summary root-stub)))
        ret       (atom nil)]
    (add-watcher! inner-root (fn [root] (reset! ret root)))
    (evaluate! inner-root)
    (evaluate! inner-root)
    (assert @ret)
    @ret))

(defn implicit-fah-a*-eval2 [henv]
  (binding [summaries/*cache-method* :eager
            *decompose-cache* (when *decompose-cache* (HashMap.))]
    (summaries/solve
     (tree-summarizer (apply get-root-subproblem (fs/make-init-pair henv)))

    
    ret))

;; TODO: remove children as they are no longer needed ?
(defn- make-pair-stub2 [subsuming-sp left-sp right-stub]
  (let [ret (traits/reify-traits
