                         lexeme-set))
               (vals @lexicon)))
 
-        alzarsi
+        tutti
         (reduce concat
                 (map (fn [key]
                        (get root-verbs key))
-                     (filter #(= % "alzarsi")
-                             (sort (keys root-verbs)))))]
+                     (sort (keys root-verbs))))]
 
-    (delete-from-expressions "it" {:root {:italiano {:italiano "alzarsi"}}})
-
-;    (write-lexicon "it" @lexicon)
-;    (log/info (str "done writing lexicon."))
+    (write-lexicon "it" @lexicon)
+    (log/info (str "done writing lexicon."))
     (log/info (str "generating examples with this many verbs:"
-                   (.size alzarsi)))
+                   (.size tutti)))
     (.size (map (fn [verb]
                   (log/trace (str "verb: " (strip-refs verb)))
                   (let [root-form (get-in verb [:italiano :italiano])]

(defn rewrite-lexicon []
  (write-lexicon "it" @lexicon))

(defn camminare [ & [count]]
  (let [count (if count (Integer. count) 10)
        ;; subset of the lexicon: only verbs which are infinitives and that can be roots:
        ;; (i.e. those that have a specific (non- :top) value for [:synsem :sem :pred])
        root-verbs 
        (zipmap
         (keys @lexicon)
         (map (fn [lexeme-set]
                (filter (fn [lexeme]
                          (and
                           (= (get-in lexeme [:synsem :cat]) :verb)
                           (= (get-in lexeme [:synsem :infl]) :top)
                           (not (= :top (get-in lexeme [:synsem :sem :pred] :top)))))
                        lexeme-set))
              (vals @lexicon)))]

    (delete-from-expressions "it" {:root {:italiano {:italiano "camminare"}}})

    (write-lexicon "it" @lexicon)
    (log/info (str "done writing lexicon."))
    (.size (map (fn [verb]
                  (let [root-form (get-in verb [:italiano :italiano])]
                    (log/debug (str "generating from root-form:" root-form))
                    (.size (map (fn [tense]
                                  (let [spec (unify {:root {:italiano {:italiano root-form}}}
                                                    tense)]
                                    (log/debug (str "generating from: " spec))
                                    (process [{:fill
                                               {:spec spec
                                                :source-model en/small-plus-vp-pronoun
                                                :target-model small
                                                :count count}}] "it")))
                                (list {:synsem {:sem {:tense :conditional}}}
                                      {:synsem {:sem {:tense :future}}}
                                      {:synsem {:sem {:tense :present}}}
                                      {:synsem {:sem {:aspect :progressive
                                                      :tense :past}}}
                                      {:synsem {:sem {:aspect :perfect
                                                      :tense :past}}})))))
                (reduce concat
                        (map (fn [key]
                               (get root-verbs key))
                             (filter #(= % "camminare")
                                     (sort (keys root-verbs)))))))))


(defn alzarsi [ & [count]]
  (let [count (if count (Integer. count) 10)
        ;; subset of the lexicon: only verbs which are infinitives and that can be roots:
        ;; (i.e. those that have a specific (non- :top) value for [:synsem :sem :pred])

                                                 {:gender :fem}]
                                                true
                                                [:top])))))
                                (list {:synsem {:sem {:tense :conditional}}}
                                      {:synsem {:sem {:tense :future}}}
                                      {:synsem {:sem {:tense :present}}}
                                      {:synsem {:sem {:aspect :progressive
                                                      :tense :past}}}
                                      {:synsem {:sem {:aspect :perfect
                                                      :tense :past}}}
                                      )))))
                tutti))))

