     "vp-pronoun-nonphrasal"})
 
 (defn create-index-fn [verb-set grammar]
-  (let [future-grammar
-        #{"sentence-phrasal-head"
-          "vp-pronoun-nonphrasal"}
-
-        verbcoach-pronouns
+  (let [verbcoach-pronouns
         (fn [v]
-          (or 
+          (or
            (and (= :noun (u/get-in v [:synsem :cat]))
                 (not (= :acc (u/get-in v [:synsem :case]))))
+           (and (= :noun (u/get-in v [:synsem :cat]))
+                (= true (u/get-in v [:synsem :propernoun])))
            (and (= :noun (u/get-in v [:synsem :cat]))
                 (= :acc (u/get-in v [:synsem :case]))
                 (= true (u/get-in v [:synsem :reflexive])))))

              (get rule-matcher key-in-rule-matcher))))
        (keys rule-matcher))))

(defn generate-arrabbiarsi
  "generate sentences efficiently given specific constraints."
  []
  (let [verb-set #{"arrabbiarsi"}
        specs
        (map (fn [root]
               {:root {:italiano {:italiano root}}})
             verb-set)
        tense-specs [{:synsem {:cat :verb
                               :sem {:tense :present
                                     :aspect :perfect}
                               :subcat []}}]]
                                        ;                     {:synsem {:cat :verb
                                        ;                               :sem {:tense :future}
                                        ;                               :subcat []}}]]
                                        ;                     {:synsem {:cat :verb
                                        ;                               :sem {:tense :present
                                        ;                                     :aspect :simple}}]]
    
    (let [chosen-spec
          (unify (first (shuffle specs))
                 (first (shuffle tense-specs)))]
      (let [generate-with-grammar-set
            (rule-matcher-reducer chosen-spec)
            grammar
            (filter (fn [rule-structure]
                      (contains? generate-with-grammar-set
                                 (u/get-in rule-structure [:rule])))
                    (:grammar model))]
        (println (str "grammar-set for spec:" (strip-refs chosen-spec) ":" generate-with-grammar-set))
        (binding [babel.generate/println? true
                  babel.generate/truncate? false
                  babel.generate/index-fn (create-index-fn verb-set grammar)
                  babel.generate/grammar grammar]
          (time (generate chosen-spec model)))))))

(defn generate-for-verbcoach
  "generate sentences efficiently given specific constraints."
  []
  (let [verb-set #{"arrabbiarsi"}
        
        specs
        (map (fn [root]
               {:root {:italiano {:italiano root}}})
             verb-set)
        tense-specs [{:synsem {:cat :verb
                               :sem {:tense :present
                                     :aspect :perfect}
                               :subcat []}}]]
                                        ;                     {:synsem {:cat :verb
                                        ;                               :sem {:tense :future}
                                        ;                               :subcat []}}]]
                                        ;                     {:synsem {:cat :verb
                                        ;                               :sem {:tense :present
                                        ;                                     :aspect :simple}}]]
    
    (repeatedly
     #(do ;;(println "")
        (println
         (let [chosen-spec
               (unify (first (shuffle specs))

   [babel.directory] ;; this is needed even though there are no references to directory in here.
   [babel.generate :as g :refer [frontier generate]]
   [babel.index :refer [create-indices lookup-spec]]
   [babel.italiano :as italiano :refer [model morph morph-ps]]
   #?(:cljs [babel.logjs :as log])
   #?(:clj [clojure.tools.logging :as log])
   #?(:clj [clojure.repl :refer [doc]])
