                                          att-map
                                          attributes))))),
         
-	new-model (make-interpretation language (union old-objects new-objects) new-att-map)]
+        new-model (make-interpretation language (union old-objects new-objects) new-att-map)]
+
     (if (holds-in-interpretation? new-model subsumption)
       (do
-	(println (str "New model does not contradict subsumption " (print-str subsumption) ", restarting."))
-	(recur model subsumption))
+        (println (str "New model does not contradict subsumption " (print-str subsumption) ", restarting."))
+        (recur model subsumption))
       new-model)))
 
 ;;;


(ns conexp.contrib.dl.languages.interaction
  (:use conexp.main
	conexp.contrib.dl.framework.syntax
	conexp.contrib.dl.framework.semantics))

;;;


                      (print-str subsumption)
                      " is already wrong in model."))
  (let [language    (interpretation-language model),
        old-objects (interpretation-base-set model),

        new-objects (loop []
                      (println "Please enter your new objects:")
                      (let [new-objects (read-string (str "#{" (first (drop-while empty? (repeatedly read-line))) "}"))]
                        (cond
                         (not-empty (intersection old-objects new-objects))
                         (do
                           (println "The objects " (difference new-objects old-objects)
                                    " are already definied in the given model. Please use other names.")
                           (recur)),

                         (some #(not (Character/isUpperCase ^Character (first (str %))))
                                 new-objects)
                         (do
                           (println (str "New objects need to start with a capital letter."))
                           (recur)),

                         :else
                         new-objects))),
        
        interpretation (loop [objects (seq new-objects),
                              attributes {}]
                         (if (empty? objects)
                           attributes
                           (let [next-object (first objects),
                                 new-attributes
                                 (loop []
                                   (println (str "Please enter concept- and role-names which are satisfied by " next-object ":"))
                                   (let [new-attributes (read-string (str "(" (read-line) ")"))]
                                     (if-let [invalid (first (filter #(not (or (symbol? %)
                                                                               (and (seq? %) (= 2 (count %)))))
                                                                     new-attributes))]
                                       (do
                                         (println (str "Attribute " invalid " is invalid, i.e. it's neither a symbol nor a pair."))
                                         (recur))
                                       (if-let [invalid (first (for [att new-attributes
                                                                     :when (or (and (symbol? att)
                                                                                    (not (contains? (concept-names language) att)))
                                                                               (and (seq? att)
                                                                                    (or (not (contains? (role-names language) (first att)))
                                                                                        (not (contains? new-objects (second att))))))]
                                                                 att))]
                                         (do
                                           (if (symbol? invalid)
                                             (println (str invalid
                                                           " is not a valid concept name"))
                                             (println (str invalid
                                                           " does not contain a valid role name or has an invalid object\n"
                                                           "(note that you can only use new objects in role specifications.")))
                                           (recur))
                                         new-attributes))))]
                             (recur (rest objects)
                                    (assoc attributes next-object new-attributes))))),
        
        new-att-map (loop [pairs   interpretation,
                           att-map (interpretation-function model)]
                      (if (empty? pairs)
                        att-map
                        (let [[object attributes] (first pairs)]
                          (recur (rest pairs)
                                 (reduce (fn [att-map att]
                                           (if (symbol? att)
                                             (update-in att-map [att] conj object)
