         labels      (vertex-labels description-graph),
         neighbours  (neighbours description-graph),
 
-        definitions (into {} (for [A (vertices description-graph)
-                                   :let [def-exp (make-dl-expression language
-                                                                     (list* 'and
-                                                                            (concat (labels A)
-                                                                                    (for [[r B] (neighbours A)]
-                                                                                      (list 'exists r B)))))]]
-                               [A (make-dl-definition A def-exp)]))]
+        definitions (map-by-fn (fn [A]
+                                 (make-dl-definition
+                                  A
+                                  (make-dl-expression language
+                                                      (list* 'and
+                                                             (concat (labels A)
+                                                                     (for [[r B] (neighbours A)]
+                                                                       (list 'exists r B)))))))
+                               (vertices description-graph))]
     (make-tbox language definitions)))
 
 (defn model->description-graph

    (if (empty? deps)
      new-tbox-map
      (let [next-concepts (first deps),
            new-defs (into {} (for [target next-concepts]
                                [target (reduce (fn [result next-thing]
                                                  (if (set? next-thing)
                                                    (into result next-thing)
                                                    (conj result next-thing)))
                                                #{}
                                                (replace new-tbox-map (tbox-map target)))]))]
        (recur (rest deps)
               (merge new-tbox-map new-defs))))))


        pre-1      (:pre G-1)]
    (doseq [v base-set-1,
            r R,
            :when (not-empty (.get remove [v r]))]
      (.add non-empty-removes [v r]))
    (while-let [[v r] (first non-empty-removes)]
      (doseq [w (.get remove [v r]),
