             rel-vec
             (let [rel-uname (t (mykey "Relation-uname" num))]
               (recur (conj rel-vec
-                         (->Iyye_Relation
-                           (->Iyye_Atom (t (mykey "Relation-name" num))
-                                        rel-uname
-                                        false)
-                           (->Iyye_ModalPredicate
-                             (t (mykey "Relation-AccordingTo" num))
-                             (t (mykey "Relation-When" num))
-                             (t (mykey "Relation-Time" num))
-                             (t (mykey "Relation-Prob" num)))
-                           (create-types num)
-                           (:Function (@action-words (t (mykey "Relation-uname" num))))
-                           (:PredicateFunction (@action-words (t (mykey "Relation-uname" num))))
-                           (create-data num)))
-                   (inc num)))))]
-    (->Iyye_Type (->Iyye_Atom (:Name t) (:Uname t) false) relations-list)))
+                           (->Iyye_Relation
+                             (->Iyye_Name (t (mykey "Relation-name" num))
+                                          rel-uname
+                                          "relation"
+                                          nil {})
+                             []
+                             (->Iyye_ModalPredicate
+                               (t (mykey "Relation-AccordingTo" num))
+                               (t (mykey "Relation-When" num))
+                               (t (mykey "Relation-Time" num))
+                               (t (mykey "Relation-Prob" num)))
+                             nil
+                             ;  (create-types num)
+                             ; (:Function (@verb-words (t (mykey "Relation-uname" num))))
+                             (:PredicateFunction (@builtin-words (t (mykey "Relation-uname" num))))
+                             (create-data num)))
+                     (inc num)))))]
+    (->Iyye_Type (->Iyye_Name (:Name t) (:Uname t) "type" nil {}) relations-list str)))
+
+(defn create-iyye-verb [Name Types Result Function & builtin]
+  (let [action-atom (create-iyye-type Name "verb" builtin)
+        relation (->Iyye_Verb action-atom Types Result Function [])]
+    relation))
 
 (defn create-iyye-relation [Name Predicate Types Function PredicateFunction & builtin]
-  (let [action-atom (create-iyye-atom Name builtin)
-        relation (->Iyye_Relation action-atom Predicate Types Function PredicateFunction [])]
+  (let [action-atom (create-iyye-name Name "relation" builtin)
+        relation (->Iyye_Relation action-atom Types Predicate Function PredicateFunction [])]
     relation))
 
 (def time-start (persistence/local-time-to-string))
+
 (defn get-supertypes [atype]
-  "gets types: self, type, immidiate parents"               ; FIXME Yumzia:0 get all parents
+  "gets types: self, type, immediate parents"               ; FIXME Yumzia:0 get all parents
   (if-not (:UNKNOWN atype)
-    (let [rels (:Relations atype)]
-      (conj (for [supertype rels :when (:super (:Data supertype))]
-              {:Name (:super (:Data supertype)) :Predicate (:Predicate supertype)})
-              {:Name "type" :Predicate (->Iyye_ModalPredicate :IYE :AXIOM time-start :ALWAYS)}
-              {:Name (:Name (:atom atype)) :Predicate (->Iyye_ModalPredicate :IYE :AXIOM time-start :ALWAYS)}))
+    (if-not (and (= "type" (:Name (:name atype))) (not= "relation" (:Type (:name atype))))
+      (let [rels (:Relations atype)]
+       (conj (for [supertype rels :when (:super (:Data supertype))]
+                {:Name (:super (:Data supertype)) :Predicate (:Predicate supertype)})
+             {:Name (:Type (:name atype)) :Predicate (->Iyye_ModalPredicate :IYE :AXIOM time-start :ALWAYS)}
+             {:Name (:Name (:name atype)) :Predicate (->Iyye_ModalPredicate :IYE :AXIOM time-start :ALWAYS)}))
+      (list {:Name "type" :Predicate (->Iyye_ModalPredicate :IYE :AXIOM time-start :ALWAYS)}))
     {:UNKNOWN (:UNKNOWN atype)}))
 
 (defn create-iyye-instance [values])

  (:require
    [clojure.tools.logging :as log]
    [iyye.bios.ioframes :as ioframes]
    [iyye.bios.persistence :as persistence]
    ;[iyye.subcon.knowledge.relation :as relation]
    ))

(def dbg-IO (ref nil))

(def action-words (ref {}))
(def noun-words (ref {}))
;(def types-words (ref []))
;(def relations-words (ref []))
;(def instances-words (ref []))
;(def adjective-words (ref []))

(defrecord Iyye_ModalPredicate [AccordingTo When Time Prob])
(defrecord Iyye_Atom [Name Uname Builtin])
(defrecord Iyye_Relation [atom Predicate Types Function PredicateFunction Data])
(defrecord Iyye_Type [atom Relations])
(defrecord Iyye_Instance [atom type])

(def atoms-number (ref 0))
(defn inc-atoms! []
  (dosync (ref-set atoms-number (inc @atoms-number)))
  @atoms-number)

(defn create-iyye-atom [name & builtin]
  (let [uname (str name (inc-atoms!))
        b (if (nil? builtin) false (first builtin))
        atom (->Iyye_Atom name uname b)]
    atom))

(defn create-iyye-type [Name & builtin]
  (let [type-atom (create-iyye-atom Name builtin)
        type (->Iyye_Type type-atom [])]
    type))

(defn create-iyye-type-from-db [t]

  (let [mykey #(keyword (str %1 %2))
        create-types #(clojure.string/split (t (mykey "Relation-Types-List" %1)) #"_")
        create-data #(hash-map (keyword (t (mykey "Relation-Data-List1" %1))) ; Only 2 now
                               (t (mykey "Relation-Data-List2" %1)))
        relations-list
        (loop [rel-vec []
               num 0]
