                  (if (fs/eq-sets fs/=-state-sets ni inp-sets) sp
                      (let [log-ni (fs/map-sets fs/get-logger fs ni)
                            ri     (refine-input inner-sp log-ni)]                      
-                       (refine-channel (:child-channel sp)
-                         (make-state-abstracted-subproblem config fs ri ni)))))
+                       (make-state-abstracted-subproblem config fs ri ni))))
                (util/safe-get config :or-summarize))]      
       (connect-and-watch! ret inner-sp 
-       #(publish-child! ret (make-state-abstracted-subproblem config fs % inp-sets)))
+       #(publish-child! ret false (make-state-abstracted-subproblem config fs % inp-sets)))
       ret)))
-
 
 (defmethod get-subproblem :SA [config [_ inner-n :as n] inp-sets]
   (let [fs (atomic-name-fs inner-n)]

                              {:or-summarize sg/or-summary
                               :make-summary (fn [[p-r o-r] stat src]
                                               (summary/make-simple-summary
                                                (min (sg/get-bound src) o-r) stat src))})))
        [init fs] (fs/make-init-pair henv)
        root      (sp-ts (make-atomic-subproblem config fs [(when (:weight opts) init) init] nil))]
    (let [ks (util/keyset defaults)] (doseq [k (keys opts)] (util/assert-is (ks k))))
    (when (:abstract? config)  (assert (:decompose? config)))
    (when (:decompose? config)  (assert (:collect? config)))
    (def *root* root)
    (case (:search-strategy config)
          :ldfs (do (sg/ldfs! root (:choice-fn config) Double/NEGATIVE_INFINITY expand!)

            (sg/connect-subsumed! (sp-ts sp) (sp-ts child-sp))
            (sg/connect! (sp-ts sp) (sp-ts child-sp))
            (sg/status-increased! (sp-ts sp) (sp-ts child-sp)))
          (if (= :hierarchical (util/safe-get (:config sp) :collect?))
            (let [^HashMap com (:oc-map (:config sp))
                  k         [(:name sp) (System/identityHashCode sp) (:output-sets child-sp)]
                  [oc new?] (or (when-let [oc  (.get com k)]
                                  [oc false])
                                (let [oc (make-output-collector
                                          (:config sp) k (:name sp) (:input-sets sp) (:output-sets child-sp))]
                                  (.put com k oc)
                                  [oc true]))]
              (if (or new? (<= (summary/max-reward (sg/summary child-sp)) (summary/max-reward (sg/summary oc))))
                (do (publish-inner-child! oc child-sp)
                    (when new?
                      (channel/publish! (:child-channel sp) oc)))
                (channel/publish! (:child-channel sp) child-sp))) 
            (channel/publish! (:child-channel sp) child-sp))))))


(defn subsuming-sps        [s] (keys (:subsuming-sp-set s)))
