 
 
 
-(defn atomic-name-fs [n] (assert (#{:Atomic :Dijkstra} (first n))) (second n))
+(defn atomic-name-fs [n] (assert (#{:Atomic} (first n))) (second n))
 (defn log-input [fs inp-set] (if *state-abstraction* (fs/get-logger fs inp-set) inp-set))
 (defn get-input-key [fs inp-set] (if *state-abstraction* (fs/extract-context fs inp-set) inp-set))
 

    :dir       Factor sequences into pairs using :left or :right recursion
    :prop      Automatically propagate subsumption from parents to matching children?"
  [henv & {gather :gather d :d  s :s   choice-fn :choice-fn
           local? :local?  dir :dir   prop :prop dijkstra :dijkstra :as m
      :or {gather true   d true s true choice-fn last
           local? true     dir :right prop true dijkstra #{}}}]
  (assert (every? #{:gather :d :s :choice-fn :local? :dir :prop :dijkstra} (keys m)))
  (when s (assert d))
  (when d (assert gather))
  (binding [*collect-equal-outputs* gather
            *decompose-cache*       (when d (HashMap.))
            *state-abstraction*     s
            *left-recursive*        (case dir :left true :right false)
            *propagate-subsumption* prop
            *dijkstra-actions*      dijkstra]
    (def *root* (sp-ts (apply make-atomic-subproblem (reverse (fs/make-init-pair henv)))))
    (summary/solve
     #(sg/summary *root*)

  (if (seq r) (pair-name f (right-factor r)) f))

(defn- wrapped-atomic-name [fs]
  (let [in  (atomic-name fs)
        mid (if *collect-equal-outputs* (oc-name in) in)]
    (if *state-abstraction* (sa-name mid) mid)))

