         vertices            (model-base-set model),
         neighbours          (fn [x]
                               (set-of [r y] [r (role-names language),
-                                             [_ y] (filter #(= (first %) x) (interpretation r))])),                                                  
+                                             [_ y] (filter #(= (first %) x) (interpretation r))])),
         vertex-labels       (fn [x]
                               (set-of P [P (concept-names language),
                                          :when (contains? (interpretation P) x)]))]


    (HashMap->hash-map sim-sets)))

;; efficient simulator sets (by meng)

(defn- single-edge->double-edge-graph
  "Given a single-edged graph G (i.e. a graph with a neighbours function
  on it) returns a structure with a :pre and a :post function on it."
  [G]
  ;; trivial implementation for transition
  {:base-set (vertices G),
   :labels   (vertex-labels G),
   :post     (fn [v r]
               (set-of w [[s w] ((neighbours G) v)
                          :when (= s r)])),
   :pre      (fn [v r]
               (set-of w [w (vertices G),
                          :when (contains? ((neighbours G) w) [r v])]))})

(defn- efficient-initialize
  "Returns tripel [sim, remove, pre*] as needed by

      (.remove non-empty-removes [v r]))
    (HashMap->hash-map sim)))


;; simulation invocation point

(defvar *simulator-set-algorithm* efficient-simulator-sets
  "Algorithm to use when computing simulator sets between two description graphs.")

(defn simulates?
