          :lookup (fn [arg]
                    (analyze arg lexicon))
          :morph morph
-         :morph-ps fo-ps}]
+         :morph-ps fo-ps
+
+         :vocab2model (fn [vocab-items filter-lexicon-fn]
+                        (model-with-vocab-items vocab-items filter-lexicon-fn model))}]
     (assoc model
           :generate-fn
           (fn [spec]
             (generate/generate spec model)))))
 
 (defn model-with-vocab-items [vocab-items filter-lexicon-fn model]
-  (let [input-lexicon (reduce merge (map vocab-entry-to-lexeme vocab-items))
-        synthetic-noun (babel.lexiconfn/edn2lexicon input-lexicon)
-        new-lexicon (merge-with concat
-                                synthetic-noun
-                                (babel.lexiconfn/filtered-lexicon
-                                 (:lexicon model)
-                                 filter-lexicon-fn))]
+  (let [input-lexicon (transform-with-english-lexical-rules
+                       (reduce merge (map vocab-entry-to-lexeme vocab-items)))
+        model (merge model
+                     {:lexicon
+                      (merge-with concat
+                                  input-lexicon
+                                  (filtered-lexicon
+                                   (:lexicon model)
+                                   filter-lexicon-fn))})]
     (merge model
-           {:lexicon new-lexicon})))
+           {:generate-fn (fn [spec]
+                           (generate/generate spec model))})))
+
+
+

    [result]))

(declare cache)

(defn fo-ps [expr]
  (parse/fo-ps expr fo))

   (if (get-in tree [:head])
     {:head (morph-walk-tree (get-in tree [:head]))})))

(defn model []
  (let [debug (log/info "  loading lexicon..")
        lexicon (read-lexicon "en")
