                           (go-right! ss)))
 	  ret (make-subproblem config nm (:input-sets left-sp) (:output-sets right-sp) nil 		 
 		(fn ri-fn [s ni]
-		  (refine-channel (:child-channel s)
-                   (make-half-pair-subproblem config (refine-input left-sp ni) #(refine-input right-sp %))))
+                  (make-half-pair-subproblem config (refine-input left-sp ni) #(refine-input right-sp %)))
                 (util/safe-get config :or-summarize))]    
       (sg/connect! ret ss) 
       (connect-ts! ss right-sp)
       (connect-and-watch! ss left-sp
-	#(publish-child! ret (make-pair-subproblem config % (refine-input right-sp (:output-sets %)))))    
+	#(publish-child! ret false (make-pair-subproblem config % (refine-input right-sp (:output-sets %)))))    
       ret)))
 
 (defn make-half-pair-subproblem [config left-sp right-fn]

             (fn summarize [s] (@summary-fn s)))
            :subsuming-sp subsuming-sp
            :expanded?-atom expanded?
            :expand!-fn
            (fn expand! [s]
              (util/print-debug 1 "expand" nm)
              (reset! expanded? true)
              (reset! summary-fn (util/safe-get config :or-summarize))
              (if (and subsuming-sp @(:expanded?-atom subsuming-sp)) ;; TODO: don't require expanded?
                (do (refine-channel (:child-channel subsuming-sp) s)
                    (refine-channel (:inner-child-channel subsuming-sp) s))
                (doseq [ref-name (refinement-names config fs inp-sets)] 
                  (publish-child! s (get-subproblem config ref-name inp-sets))))))))))))

(defmethod get-subproblem :Atomic [config [_ fs] inp-sets]
  (make-atomic-subproblem config fs inp-sets nil))          


;; Initially we are evaluated but have no children. (Lazy can be simulated by hierarchy)
;; Expanding generates and publishes child subproblems, based on children of subsuming if possible.

(defmacro cache-under [dc ks body]
  `(if-let [^HashMap dc# ~dc]
