przetwarzenie realizacji z Walentego

Wojciech Jaworski
1 parent af8828aa
Showing 24 changed files with 849 additions and 901 deletions
lexSemantics/.gitignore
lexSemantics/ENIAMlexSemantics.ml
lexSemantics/ENIAMlexSemanticsData.ml
lexSemantics/ENIAMlexSemanticsTypes.ml
lexSemantics/ENIAMvalence.ml
lexSemantics/ENIAMwalFrames.ml
lexSemantics/ENIAMwalParser.ml
lexSemantics/ENIAMwalReduce.ml
lexSemantics/ENIAMwalStringOf.ml
lexSemantics/ENIAMwalTypes.ml
lexSemantics/ENIAMwalenty.ml
lexSemantics/README
lexSemantics/TODO
lexSemantics/entries.ml
lexSemantics/makefile
lexSemantics/test.ml
lexSemantics/test2.ml
subsyntax/README
walenty/ENIAMwalConnect.ml
walenty/ENIAMwalGenerate.ml
+test
 (*
  *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
 (*
  *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
 (*
  *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
+(*
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
+ *
+ *  This library is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU Lesser General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This library is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *)
+
+open ENIAMwalTypes
+open Xstd
+
+let simplify_pos = function
+    "subst" -> "noun"
+  | "depr" -> "noun"
+  | "psubst" -> "noun"
+  | "pdepr" -> "noun"
+  | "adj" -> "adj"
+  | "adjc" -> "adj"
+  | "adjp" -> "adj"
+  | "ger" -> "verb"
+  | "pact" -> "verb"
+  | "ppas" -> "verb"
+  | "fin" -> "verb"
+  | "bedzie" -> "verb"
+  | "praet" -> "verb"
+  | "winien" -> "verb"
+  | "impt" -> "verb"
+  | "imps" -> "verb"
+  | "inf" -> "verb"
+  | "pcon" -> "verb"
+  | "pant" -> "verb"
+  | "pred" -> "verb"
+  | "ppron12" -> "pron"
+  | "ppron3" -> "pron"
+  | "siebie" -> "pron"
+  | s -> s
+
+let transform_zeby = function
+    Aff -> [Comp "że"]
+  | Negation -> [Comp "że";Comp "żeby"]
+  | NegationUndef -> [Comp "że";Comp "żeby"]
+
+let transform_gdy = function
+    "indicative" -> [Comp "gdy"]
+  | "imperative" -> [Comp "gdy"]
+  | "conditional" -> [Comp "gdyby"]
+  | "gerundial" -> [Comp "gdy"]
+  | "" -> [Comp "gdy";Comp "gdyby"]
+  | s -> failwith ("transform_gdy: " ^ s)
+
+let transform_comp negation mood = function
+    Comp comp -> [Comp comp]
+  | Zeby -> transform_zeby negation
+  | Gdy -> transform_gdy mood
+  | CompUndef -> [CompUndef]
+
+let transform_str mood negation =
+  if mood = "gerundial" then [Case "gen"] else
+  match negation with
+    Aff -> [Case "acc"]
+  | Negation -> [Case "gen"]
+  | NegationUndef -> [Case "acc";Case "gen"]
+
+let transform_np_phrase lemma = function
+    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
+  | NP(CaseAgr) -> [NP(CaseAgr)(*;NumP(CaseAgr)*)]
+  | NCP(Case c,ctype,comp) -> [NCP(Case c,ctype,comp)]
+  | AdjP(Case _) as morf -> [morf] (* tylko 'zagłada adjp(postp)' *)
+  | AdjP(CaseAgr) -> [AdjP(AllAgr)]
+  | AdjP(Str) -> [AdjP(AllAgr)] (* chyba błąd walentego, tylko 'barwa', 'bieda', 'głód', 'kolor', 'nędza', 'śmierć', 'usta' *)
+  | CP(ctype,comp) as morf -> [morf]
+  | PrepNP _ as morf -> [morf]
+  | PrepAdjP _ as morf -> [morf] (* to wygląda seryjny błąd w Walentym xp(abl[prepadjp(z,gen)]) *)
+  | ComprepNP _ as morf -> [morf]
+  | ComparP _ as morf -> [morf]
+  | PrepNCP _ as morf -> [morf]
+  | AdvP as morf -> [morf] (* występuje tylko w lematach: cyrk, trwałość x2, zagłada *)
+  | FixedP _ as morf -> [morf]
+  | Or as morf -> [morf]
+  (* | Pro as morf -> [morf] *)
+  | Null as morf -> [morf]
+  | phrase -> print_endline ("transform_np_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_np_pos lemma = function
+  | SUBST(_,Case _) as morf -> [morf]
+  | PPRON3(_,Case _) as morf -> [morf]
+  | SUBST(_,CaseAgr) as morf -> [morf]
+  | SUBST(n,Str) -> [ADJ(n,AllAgr,GenderUndef,Grad "pos")] (* błąd walentym: 'zła godzina' *)
+  | ADJ(_,Case _,_,_) as morf -> [morf]
+  | ADJ(n,CaseAgr,GenderAgr,gr) -> [ADJ(n,AllAgr,GenderAgr,gr)]
+  | PACT(n,CaseAgr,g,a,neg) -> [PACT(n,AllAgr,g,a,neg)]
+  | PPAS(_,Case _,_,_,_) as morf -> [morf]
+  | PPAS(n,CaseAgr,g,a,neg) -> [PPAS(n,AllAgr,g,a,neg)]
+  | ADJ(n,Str,g,gr) -> [ADJ(n,AllAgr,g,gr)]
+  | PPAS(n,Str,g,a,neg) -> [PPAS(n,AllAgr,g,a,neg)]
+  | PREP(Case _) as morf -> [morf]
+  | ADV _ as morf -> [morf] (* tu trafiają przysłówkowe realizacje *)
+  | COMP _ as morf -> [morf]
+  | QUB as morf -> [morf]
+  | PERS _ as morf -> [morf]
+  | pos -> print_endline ("transform_np_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_adj_phrase lemma = function
+    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
+  | NP(Part) -> [NP(Case "gen");NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)] (* jedno wystąpienie 'krewny' *)
+  | NCP(Case c,ctype,comp) -> [NCP(Case c,ctype,comp)]
+  | AdjP(CaseAgr) -> [AdjP(AllAgr)] (* jedno wystąpienie 'cały szczęśliwy', może się przydać podniesienie typu *)
+  | CP(ctype,comp) as morf -> [morf]
+  | PrepNP _ as morf -> [morf]
+  | PrepAdjP _ as morf -> [morf]
+  | ComprepNP _ as morf -> [morf]
+  | ComparP _ as morf -> [morf]
+  | PrepNCP _ as morf -> [morf]
+  | InfP _ as morf -> [morf]
+  | AdvP as morf -> [morf]
+  (*  | FixedP _ as morf -> [morf]*)
+  | Or as morf -> [morf] (* jedno wystąpienie 'jednoznaczny' *)
+  (* | Pro as morf -> [morf] *)
+  | Null as morf -> [morf]
+  | morf -> print_endline ("transform_adj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_adj_pos lemma = function
+  | ADJ(n,CaseAgr,g,gr) -> [ADJ(n,AllAgr,g,gr)]
+  | PREP(Case _) as morf -> [morf]
+  | ADV _ as morf -> [morf]
+  | QUB as morf -> [morf]
+  | morf -> print_endline ("transform_adj_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]
+
+let transform_adv_phrase lemma = function
+    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
+  | NCP(Case c,ctype,comp) -> [NCP(Case c,ctype,comp)]
+  | CP(ctype,comp) as morf -> [morf]
+  | PrepNP _ as morf -> [morf]
+  | PrepAdjP _ as morf -> [morf]
+  | ComprepNP _ as morf -> [morf]
+  | ComparP _ as morf -> [morf]
+  | PrepNCP _ as morf -> [morf]
+  | InfP _ as morf -> [morf]
+  | AdvP as morf -> [morf]
+(*  | Or as morf -> [morf]*)
+  (* | Pro as morf -> [morf] *)
+    | Null as morf -> [morf]
+(*     | AdjP(CaseAgr) as morf -> [morf]*)
+  (*    | FixedP _ as morf -> [morf]*)
+  | morf -> print_endline ("transform_adv_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_adv_pos lemma = function
+    SUBST(_,Case _) as morf -> [morf]
+  (*    | ADJ(_,CaseAgr,_,_) as morf -> [morf]*)
+  | COMP _ as morf -> [morf]
+  | PREP(Case _) as morf -> [morf]
+  | COMPAR _ as morf -> [morf]
+  | ADV _ as morf -> [morf] (* tu trafiają przysłówkowe realizacje *)
+  | morf -> print_endline ("transform_adv_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]
+
+let transform_prep_phrase lemma = function
+  | phrase -> print_endline ("transform_prep_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_prep_pos lemma = function
+  | SUBST(_,Case _) as morf -> [morf]
+  | SIEBIE(Case _) as morf -> [morf]
+  | PPRON12(_,Case _) as morf -> [morf]
+  | PPRON3(_,Case _) as morf -> [morf]
+  | SUBST(n,Str) -> [SUBST(n,CaseAgr)]
+  | NUM(Case _,_) as morf -> [morf]
+  | ADJ(_,Case _,_,_) as morf -> [morf]
+  | GER(_,Case _,_,_,_) as morf -> [morf]
+  | PPAS(_,Case _,_,_,_) as morf -> [morf]
+(*  | ADV _ as morf -> [morf]
+    | QUB as morf -> [morf]*)
+  | pos -> print_endline ("transform_prep_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_comprep_phrase lemma = function
+    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
+  | NCP(Case c,ctype,comp) -> [NCP(Case c,ctype,comp)]
+  | PrepNP _ as morf -> [morf]
+  | PrepNCP _ as morf -> [morf]
+  | phrase -> print_endline ("transform_comprep_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_comprep_pos lemma = function
+  | SUBST(_,Case _) as morf -> [morf]
+(*  | SUBST(n,Str) -> [SUBST(n,CaseAgr)]*)
+  | NUM(Case _,_) as morf -> [morf]
+(*  | ADJ(_,Case _,_,_) as morf -> [morf]
+  | GER(_,Case _,_,_,_,_) as morf -> [morf]
+  | PPAS(_,Case _,_,_,_) as morf -> [morf]
+  | ADV _ as morf -> [morf]
+    | QUB as morf -> [morf]*)
+  | pos -> print_endline ("transform_comprep_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_compar_phrase lemma = function
+  | NP(Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> NP(Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: uzgodnić a komparatywem *)
+  | FixedP _ as morf -> [morf]
+  | phrase -> print_endline ("transform_compar_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_compar_pos lemma = function
+  | SUBST(_,Case _) as morf -> [morf]
+  | ADJ(_,Case _,_,_) as morf -> [morf]
+  | PREP(Case _) as morf -> [morf]
+  | SUBST(Number n,Str) -> [SUBST(Number n,CaseUndef)]
+  | SUBST(NumberAgr,Str) -> [SUBST(NumberUndef,CaseUndef)]
+  | SUBST(NumberUndef,Str) -> [SUBST(NumberUndef,CaseUndef)]
+  | PPAS(_,Case _,_,_,_) as morf -> [morf]
+  | PPAS(NumberAgr,Str,GenderAgr,a,neg) -> [PPAS(NumberUndef,CaseUndef,GenderUndef,a,neg)]  (* FIXME: ta sama sytuacja co w "jako" *)
+  | PPAS(NumberAgr,CaseAgr,GenderAgr,a,neg) -> [PPAS(NumberUndef,CaseUndef,GenderUndef,a,neg)] (* FIXME: ta sama sytuacja co w "jako" *)
+  | ADJ(NumberAgr,Str,GenderAgr,gr) -> [ADJ(NumberUndef,CaseUndef,GenderUndef,gr)] (* FIXME: ta sama sytuacja co w "jako" *)
+  | ADJ(NumberAgr,CaseAgr,GenderAgr,gr) -> [ADJ(NumberUndef,CaseUndef,GenderUndef,gr)] (* FIXME: ta sama sytuacja co w "jako" *)
+  | NUM(Case _,_) as morf -> [morf]
+  | pos -> print_endline ("transform_compar_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_comp_phrase lemma = function
+  | phrase -> print_endline ("transform_comp_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_comp_pos lemma = function
+  | PERS _ as morf -> [morf]
+  | pos -> print_endline ("transform_comp_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_qub_phrase lemma = function
+  | phrase -> print_endline ("transform_qub_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_qub_pos lemma = function
+    | QUB as morf -> [morf]
+  | pos -> print_endline ("transform_qub_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_siebie_phrase lemma = function
+  | phrase -> print_endline ("transform_siebie_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase phrase); [phrase]
+
+let transform_siebie_pos lemma = function
+  | ADJ(NumberAgr,CaseAgr,GenderAgr,gr) -> [ADJ(NumberAgr,AllAgr,GenderAgr,gr)]
+  | pos -> print_endline ("transform_siebie_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos pos); [pos]
+
+let transform_pers_subj_phrase lemma negation mood = function (* FIXME: prepnp(na,loc) *)
+  | NP(Str) -> [NP(NomAgr)(*;NumP(NomAgr)*)]
+  | NP(Part) -> [NP(Case "gen");NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)] (* tylko w 'nalewać', 'nalać', 'ponalewać', 'najechać','uzbierać' *)
+  | NCP(Str,ctype,comp) -> [NCP(NomAgr,ctype,comp)]
+  | CP(ctype,comp) as morf -> [morf]
+  | InfP _ as morf -> [morf]
+  | Or as morf -> [morf]
+    (* | Pro -> [ProNG] *)
+  | Null -> [Null]
+  | morf -> print_endline ("transform_pers_subj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_pers_subj_pos lemma negation mood = function
+  (*    COMP _ as morf -> [morf]*)
+  | SUBST(n,Str) -> [SUBST(n,NomAgr)]
+  | SUBST(n,Case "nom") -> [SUBST(n,NomAgr)] (* wygląda na błąd Walentego, ale nie ma znaczenia *)
+  | NUM(Str,g) -> [NUM(NomAgr,g)]
+  | NUM(Case "nom",g) -> [NUM(NomAgr,g)]
+(*      | ADJ(n,Str,g,gr) -> [ADJ(n,NomAgr,g,gr)]*)
+  | morf -> print_endline ("transform_pers_subj_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]
+
+let transform_ger_subj_phrase lemma negation mood = function
+  | NP(Str) -> [NP(Case "gen");PrepNP("przez",Case "acc")(*;NumP(Case "gen")*)(*;PrepNumP("przez",Case "acc")*)] (* FIXME: czy przez:acc jest możliwe? *)
+  | NP(Part) -> [NP(Case "gen")(*;NP(Case "acc")*)(*;NumP(Case "gen");NumP(Case "acc")*)]
+  | NCP(Str,ctype,comp) -> [NCP(Case "gen",ctype,comp);PrepNCP("przez",Case "acc",ctype,comp)] (* FIXME: czy przez:acc jest możliwe? *)
+  | CP(ctype,comp) as morf -> [morf]
+  | InfP _ as morf -> [morf] (* FIXME: czy to jest możliwe? *)
+  | Or as morf -> [morf]
+  (* | Pro -> if control then [Pro] else [Null] *)
+  | Null -> [Null]
+  | morf -> print_endline ("transform_ger_subj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_ger_subj_pos lemma negation mood = function (* FIXME: ADV(_) *)
+  (*    COMP _ as morf -> [morf] (* FIXME: czy to jest możliwe? *)*)
+  | SUBST(n,Str) -> [SUBST(n,Case "gen")]
+  | SUBST(n,Case "nom") -> [SUBST(n,Case "gen")] (* wygląda na błąd Walentego, ale nie ma znaczenia *)
+  | NUM(Str,g) -> [NUM(Case "gen",g)]
+  | NUM(Case "nom",g) -> [NUM(Case "gen",g)]
+(* | ADJ(n,Str,g,gr) -> [ADJ(n,Case "gen",g,gr)]*)
+  | morf -> print_endline ("transform_pers_subj_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]
+
+let transform_ppas_subj_phrase lemma negation mood control = function
+  | NP(Str) -> [PrepNP("przez",Case "acc")(*;PrepNumP("przez",Case "acc")*)]
+  | NCP(Str,ctype,comp) -> [PrepNCP("przez",Case "acc",ctype,comp)]
+  | CP(ctype,comp) as morf -> [morf]
+    (* | Pro -> if control then [Pro] else [Null] *)
+  | morf -> print_endline ("transform_ppas_subj_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_pers_phrase lemma negation mood = function
+  | NP(Str) -> List.flatten (Xlist.map (transform_str mood negation) (fun case -> [NP case(*;NumP(case)*)]))
+  | NP(Part) -> [NP(Case "gen")] @ (if mood = "gerundial" then [] else [NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)])
+  | NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
+  | NCP(Str,ctype,comp) -> List.flatten (Xlist.map (transform_str mood negation) (fun case -> [NCP(case,ctype,comp)]))
+  | NCP(Part,ctype,comp) -> List.flatten (Xlist.map (transform_str mood negation) (fun case -> [NCP(case,ctype,comp)]))
+  | NCP(Case case,ctype,comp) -> [NCP(Case case,ctype,comp)]
+  | AdjP(Str) -> Xlist.map (transform_str mood negation) (fun case -> AdjP case) (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
+  | AdjP CaseAgr as morf -> if mood = "gerundial" then [AdjP AllAgr] else (print_endline ("transform_pers_phrase2: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf])
+  | AdjP(Case _) as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
+  | CP(ctype,comp) as morf -> [morf]
+  | PrepNP _ as morf -> [morf]
+  | PrepAdjP _ as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
+  | ComprepNP _ as morf -> [morf]
+  | ComparP _ as morf -> [morf]
+  | PrepNCP _ as morf -> [morf]
+  | InfP _ as morf -> [morf]
+  | AdvP -> if mood = "gerundial" then [AdjP AllAgr] else [AdvP]
+  | FixedP _ as morf -> [morf]
+  | Or as morf -> [morf]
+  (* | Pro as morf -> [morf] *)
+  | Null as morf -> [morf]
+  | morf -> print_endline ("transform_pers_phrase: " ^ lemma ^ " " ^ ENIAMwalStringOf.phrase morf); [morf]
+
+let transform_pers_pos lemma negation mood = function
+  | SUBST(n,Str) -> Xlist.map (transform_str mood negation) (fun case -> SUBST(n,case))
+  | PPRON12(n,Str) -> Xlist.map (transform_str mood negation) (fun case -> PPRON12(n,case))
+  | PPRON3(n,Str) -> Xlist.map (transform_str mood negation) (fun case -> PPRON3(n,case))
+  | SIEBIE(Str) -> Xlist.map (transform_str mood negation) (fun case -> SIEBIE(case))
+  | NUM(Str,g) -> Xlist.map (transform_str mood negation) (fun case -> NUM(case,g))
+  | ADJ(n,Str,g,gr) -> Xlist.map (transform_str mood negation) (fun case -> ADJ(n,case,g,gr))
+(*     | PPAS(n,Str,g,a,neg) -> Xlist.map (transform_str negation) (fun case -> PPAS(n,Str,g,a,neg))*)
+  | SUBST(n,Part) -> [SUBST(n,Case "gen");SUBST(n,Case "acc")]
+  | ADJ(n,Part,g,gr) -> [ADJ(n,Case "gen",g,gr);ADJ(n,Case "acc",g,gr)]
+  | ADJ(n,CaseAgr,g,gr) as morf -> if lemma = "siedzieć" then [morf] else (print_endline ("transform_pers_pos2: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]) (* FIXME *)
+  | SUBST(_,Case _) as morf -> [morf]
+  | PPRON12(_,Case _) as morf -> [morf]
+  | PPRON3(_,Case _) as morf -> [morf]
+  | SIEBIE(Case _) as morf -> [morf]
+  | NUM(Case _,_) as morf -> [morf]
+  | PREP _ as morf -> [morf]
+  | ADJ(_,Case _,_,_) as morf -> [morf]
+  | PPAS(_,Case _,_,_,_) as morf -> [morf]
+(*  | SUBST(n,CaseAgr) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> SUBST(n,Case case)) (* FIXME: sprawdzić kto kontroluje! *)
+    | ADJ(n,CaseAgr,g,gr) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ADJ(n,Case case,g,gr))  (* FIXME: sprawdzić kto kontroluje! *)*)
+  | COMPAR _ as morf -> [morf]
+  | COMP _ as morf -> [morf]
+  | INF _ as morf -> [morf]
+  | QUB as morf -> [morf]
+  | ADV grad -> (*if mood = "gerundial" then [ADJ(NumberAgr,AllAgr,GenderAgr,grad)] else*) [ADV grad]  (* FIXME: to nie poprawi lematu *)
+  | PERS _ as morf -> [morf]
+  | morf -> print_endline ("transform_pers_pos: " ^ lemma ^ " " ^ ENIAMwalStringOf.pos morf); [morf]
+
+let rec transform_comps negation mood = function
+  | CP(ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> CP(ctype,comp))
+  | NCP(case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> NCP(case,ctype,comp))
+  | PrepNCP(prep,case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> PrepNCP(prep,case,ctype,comp))
+  | E phrase -> Xlist.map (transform_comps negation mood phrase) (fun phrase -> E phrase)
+  | morf -> [morf]
+
+let compars = StringSet.of_list ["jak"; "jako"; "niż"; "niczym" ;"niby"; "co"; "zamiast"]
+
+let is_compar lex = StringSet.mem compars lex
+
+(* FIXME: pomijam uzgadnianie przypadku, liczby i rodzaju - wykonalne za pomocą kontroli *)
+let transform_preps morf =
+  let morf = match morf with
+      | LexArg(id,lex,PREP c) -> if is_compar lex then LexArg(id,lex,COMPAR c) else LexArg(id,lex,PREP c)
+      | SimpleLexArg(lex,PREP c) -> if is_compar lex then SimpleLexArg(lex,COMPAR c) else SimpleLexArg(lex,PREP c)
+      | PrepNP(prep,c) -> if is_compar prep then ComparP(prep,c) else PrepNP(prep,c)
+      | PrepAdjP(prep,c) -> if is_compar prep then ComparP(prep,c) else PrepAdjP(prep,c)
+      | PrepNCP(prep,case,ctype,comp) as morf -> if is_compar prep then failwith "transform_preps" else morf
+      | morf -> morf in
+  match morf with
+    | ComparP(prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> ComparP(prep,Case case))
+    | ComparP _ -> failwith "transform_preps"
+    | LexArg(id,lex,COMPAR Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> LexArg(id,lex,COMPAR (Case case)))
+    | SimpleLexArg(lex,COMPAR Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst";"postp"] (fun case -> SimpleLexArg(lex,COMPAR (Case case)))
+    | LexArg(id,lex,COMPAR (Case _)) as morf -> [morf]
+    | SimpleLexArg(lex,COMPAR (Case _)) as morf -> [morf]
+    | LexArg(id,lex,COMPAR _) -> failwith "transform_preps"
+    | SimpleLexArg(lex,COMPAR _) -> failwith "transform_preps"
+    | PrepNP("per",Str) -> [PrepNP("per",Case "nom");PrepNP("per",Case "voc")] (* FIXME: voc do poprawienie w leksykonie *)
+    | PrepNP(_,Case _) as morf -> [morf]
+    | PrepAdjP(_,Case _) as morf -> [morf]
+    | PrepNCP(_,Case _,_,_) as morf -> [morf]
+    | PrepNP _ -> failwith "transform_preps"
+    | PrepAdjP _ -> failwith "transform_preps"
+    | PrepNCP _ -> failwith "transform_preps"
+    | LexArg(id,"w",PREP Str) -> [LexArg(id,"w",PREP (Case "acc"));LexArg(id,"w",PREP (Case "loc"));]
+    | SimpleLexArg("w",PREP Str) -> [SimpleLexArg("w",PREP (Case "acc"));SimpleLexArg("w",PREP (Case "loc"))]
+    | LexArg(id,lex,PREP (Case _)) as morf -> [morf]
+    | SimpleLexArg(lex,PREP (Case _)) as morf -> [morf]
+    | LexArg(id,lex,PREP _) -> failwith "transform_preps"
+    | SimpleLexArg(lex,PREP _) -> failwith "transform_preps"
+    | morf -> [morf]
+
+let transform_pers_schema lemma negation mood schema =
+  Xlist.map schema (fun s ->
+      {s with morfs =
+                let morfs = List.flatten (Xlist.map s.morfs (transform_comps negation mood)) in
+                let morfs = List.flatten (Xlist.map morfs transform_preps) in
+                if s.gf = SUBJ then List.flatten (Xlist.map morfs (function
+                    | E phrase -> Xlist.map (transform_pers_subj_phrase lemma negation mood phrase) (fun phrase -> E phrase)
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_pers_subj_pos lemma negation mood pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_pers_subj_pos lemma negation mood pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_pers_subj_phrase lemma negation mood phrase))
+                else List.flatten (Xlist.map s.morfs (function
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_pers_phrase lemma negation mood phrase))})
+
+let transform_nosubj_schema lemma negation mood schema =
+  Xlist.map schema (fun s ->
+      {s with morfs =
+                let morfs = List.flatten (Xlist.map s.morfs (transform_comps negation mood)) in
+                let morfs = List.flatten (Xlist.map morfs transform_preps) in
+                if s.gf = SUBJ then [Null]
+                else List.flatten (Xlist.map morfs (function
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_pers_phrase lemma negation mood phrase))})
+
+(* let transform_ger_adv_lex = function
+  | s -> print_endline ("transform_ger_adv_lex: " ^ s); s
+
+let transform_ger_adv_pos = function
+  | LexArg(id,lex,ADV grad) -> LexArg(id,transform_ger_adv_lex lex,ADJ(NumberAgr,AllAgr,GenderAgr,grad))
+  | SimpleLexArg(lex,ADV grad) -> SimpleLexArg(transform_ger_adv_lex lex,ADJ(NumberAgr,AllAgr,GenderAgr,grad))
+  | morf -> morf *)
+
+let transform_ger_schema lemma negation schema = (* FIXME: zakładam, że ger zeruje mood, czy to prawda? *)
+  Xlist.map schema (fun s ->
+      {s with morfs =
+                let morfs = List.flatten (Xlist.map s.morfs (transform_comps negation "gerundial")) in
+                let morfs = List.flatten (Xlist.map morfs transform_preps) in
+                (* let morfs = Xlist.map morfs transform_ger_adv_pos in *)
+                if s.gf = SUBJ then List.flatten (Xlist.map morfs (function
+                    | E phrase -> Xlist.map (transform_ger_subj_phrase lemma negation "gerundial" phrase) (fun phrase -> E phrase)
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_ger_subj_pos lemma negation "gerundial" pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_ger_subj_pos lemma negation "gerundial" pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_ger_subj_phrase lemma negation "gerundial" phrase))
+                else List.flatten (Xlist.map s.morfs (function
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_pers_pos lemma negation "gerundial" pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_pers_pos lemma negation "gerundial" pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_pers_phrase lemma negation "gerundial" phrase))})
+
+let transform_ppas_schema lemma negation mood schema =
+  if not (Xlist.fold schema false (fun b p -> if p.gf = OBJ then true else b)) then raise Not_found else
+  Xlist.map schema (fun s ->
+        let morfs = List.flatten (Xlist.map s.morfs (transform_comps negation mood)) in
+        let morfs = List.flatten (Xlist.map morfs transform_preps) in
+        {s with morfs =
+                if s.gf = OBJ then [Null] else
+                if s.gf = SUBJ then List.flatten (Xlist.map morfs (function
+                    | E phrase ->  raise Not_found (* tylko 'obladzać' i 'oblodzić', chyba błąd *)
+                    | LexArg(id,lex,SUBST(n,Str)) -> raise Not_found (* FIXME!!! *)
+                    | SimpleLexArg(lex,SUBST(n,Str)) -> raise Not_found (* FIXME!!! *)
+                    | phrase -> transform_ppas_subj_phrase lemma negation mood (s.cr <> [] || s.ce <> []) phrase))
+                else List.flatten (Xlist.map s.morfs (function
+                    | LexArg(id,lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> LexArg(id,lex,pos))
+                    | SimpleLexArg(lex,pos) -> Xlist.map (transform_pers_pos lemma negation mood pos) (fun pos -> SimpleLexArg(lex,pos))
+                    | phrase -> transform_pers_phrase lemma negation mood phrase))})
+
+let transform_num_schema acm schema =
+  Xlist.map schema (fun s ->
+      {s with morfs=List.flatten (Xlist.map s.morfs (function
+           | Null -> [Null]
+           | LexArg(id,lex,SUBST(NumberUndef,CaseUndef)) ->
+             (match acm with
+                "rec" -> [LexArg(id,lex,SUBST(NumberUndef,GenAgr))]
+              | "congr" -> [LexArg(id,lex,SUBST(NumberUndef,AllAgr))]
+              | _ -> failwith "transform_num_schema")
+           | SimpleLexArg(lex,SUBST(NumberUndef,CaseUndef)) ->
+             (match acm with
+                "rec" -> [SimpleLexArg(lex,SUBST(NumberUndef,GenAgr))]
+              | "congr" -> [SimpleLexArg(lex,SUBST(NumberUndef,AllAgr))]
+              | _ -> failwith "transform_num_schema")
+           | morf -> failwith ("transform_num_schema: " ^ ENIAMwalStringOf.phrase morf)))})
+
+let transform_schema pos lemma schema =
+  let phrase_fun,pos_fun = match pos with
+      "subst" -> transform_np_phrase,transform_np_pos
+    | "adj" -> transform_adj_phrase,transform_adj_pos
+    | "adv" -> transform_adv_phrase,transform_adv_pos
+    | "prep" -> transform_prep_phrase,transform_prep_pos
+    | "comprep" -> transform_comprep_phrase,transform_comprep_pos
+    | "compar" -> transform_compar_phrase,transform_compar_pos
+    | "comp" -> transform_comp_phrase,transform_comp_pos
+    | "qub" -> transform_qub_phrase,transform_qub_pos
+    | "siebie" -> transform_siebie_phrase,transform_siebie_pos
+    | _ -> failwith "transform_schema"
+  in
+  Xlist.map schema (fun s ->
+      let morfs = List.flatten (Xlist.map s.morfs (transform_comps NegationUndef "")) in (* FIXME: zależność od trybu warunkowego i negacji *)
+      {s with morfs=List.flatten (Xlist.map morfs (function
+             LexArg(id,lex,pos) -> Xlist.map (pos_fun lemma pos) (fun pos -> LexArg(id,lex,pos))
+           | SimpleLexArg(lex,pos) -> Xlist.map (pos_fun lemma pos) (fun pos -> SimpleLexArg(lex,pos))
+           | phrase -> phrase_fun lemma phrase))})
+
+let rec remove_adj_agr = function
+    [] -> []
+  | {morfs=[Null;AdjP(CaseAgr)]} :: l -> remove_adj_agr l
+  | {morfs=[Null;AdjP(Part)]} :: l -> remove_adj_agr l
+  | s :: l -> (*print_endline (ENIAMwalStringOf.schema [s]);*) s :: (remove_adj_agr l)
+
+let rec get_role gf = function
+    [] -> raise Not_found
+  | s :: l -> if s.gf = gf then s.role,s.role_attr else get_role gf l
+
+let expand_negation = function
+    Negation -> [Negation]
+  | Aff -> [Aff]
+  | NegationUndef -> [Negation;Aff]
+
+let expand_aspect = function
+    Aspect s -> [Aspect s]
+  | AspectUndef -> [Aspect "imperf";Aspect "perf"]
+
+let aspect_sel = function
+    Aspect s -> [ENIAM_LCGlexiconTypes.Aspect,ENIAM_LCGlexiconTypes.Eq,[s]]
+  | AspectUndef -> []
+
+open ENIAM_LCGlexiconTypes
+
+let transform_entry pos lemma negation pred aspect schema =
+  if pos = "subst" || pos = "depr" then (
+    if negation <> NegationUndef || pred <> PredFalse || aspect <> AspectUndef then failwith ("transform_entry 1");
+    [[],transform_schema "subst" lemma schema]) else
+  if pos = "adj" || pos = "adjc" || pos = "adjp" then (
+    if negation <> NegationUndef || aspect <> AspectUndef then failwith ("transform_entry 2");
+    let sel =  match pred with PredTrue -> [Case,Eq,["pred"]] | _ -> [] in
+    [sel,transform_schema "adj" lemma schema]) else
+  if pos = "adv" || pos = "prep" || pos = "comprep" || pos = "comp" || pos = "compar" || pos = "qub" || pos = "siebie" then (
+    if negation <> NegationUndef || (*pred <> PredFalse ||*) aspect <> AspectUndef then failwith ("transform_entry 3"); (* FIXME: typy przysłówków *)
+    [[],transform_schema pos lemma schema]) else
+  if pred <> PredFalse then failwith ("transform_entry 4") else
+  if pos = "num" || pos = "intnum" then (
+    if negation <> NegationUndef || aspect <> AspectUndef then failwith ("transform_entry 5");
+    Xlist.map ["congr";"rec"] (fun acm ->
+        [Acm,Eq,[acm]],transform_num_schema acm schema)) else
+  List.flatten (Xlist.map (expand_negation negation) (fun negation ->
+  let sel = [Negation,Eq,[ENIAMwalStringOf.negation negation]] @ aspect_sel aspect in
+  if pos = "fin" || pos = "bedzie" then
+        [sel @ [Mood,Eq,["indicative"]],transform_pers_schema lemma negation "indicative" schema;
+         sel @ [Mood,Eq,["imperative"]],transform_pers_schema lemma negation "imperative" schema] else
+  if pos = "praet" || pos = "winien" then
+        [sel @ [Mood,Eq,["indicative"]],transform_pers_schema lemma negation "indicative" schema;
+         sel @ [Mood,Eq,["conditional"]],transform_pers_schema lemma negation "conditional" schema] else
+  if pos = "impt" then
+    [sel @ [Mood,Eq,["imperative"]],transform_nosubj_schema lemma negation "imperative" schema] else
+  if pos = "imps" then
+    [sel @ [Mood,Eq,["indicative"]],transform_nosubj_schema lemma negation "indicative" schema] else
+  if pos = "pred" then
+    [sel @ [Mood,Eq,["indicative"]],transform_pers_schema lemma negation "indicative" schema] else
+  if pos = "pcon" || pos = "pant" || pos = "inf" || pos = "pact" then
+      (* let role,role_attr = try get_role SUBJ schema with Not_found -> "Initiator","" in *)
+    [sel, transform_nosubj_schema lemma negation "indicative" schema] else
+  if pos = "ppas" then
+      try
+        (* let role,role_attr = try get_role OBJ schema with Not_found -> "Theme","" in *)
+        [sel, transform_ppas_schema lemma negation "indicative" schema]
+      with Not_found -> [] else
+  if pos = "ger" then
+    [sel,transform_ger_schema lemma negation schema] else
+  failwith ("transform_entry: " ^ pos)))
+
+let transform_lex_entry pos lemma = function
+    SimpleLexEntry(lemma,pos) -> [[],SimpleLexEntry(lemma,pos)]
+  | LexEntry(id,lemma,pos,NoRestr,schema) ->
+    Xlist.map (transform_entry pos lemma NegationUndef PredFalse AspectUndef schema) (fun (sel,schema) ->
+        sel,LexEntry(id,lemma,pos,NoRestr,schema))
+  | ComprepNPEntry(s,NoRestr,schema) ->
+    Xlist.map (transform_entry "comprep" s NegationUndef PredFalse AspectUndef schema) (fun (sel,schema) ->
+        sel,ComprepNPEntry(s,NoRestr,schema))
+  | LexEntry(id,lemma,pos,_,[]) as entry -> [[],entry] (* FIXME *)
+        | entry -> print_endline ("transform_lex_entry:" ^ ENIAMwalStringOf.lex_entry entry); [[],entry]
+
+(*let reduce_frame_negation lexemes = function
+    Negation -> StringMap.mem lexemes "nie"
+  | _ -> true
+
+let reduce_frame_mood lexemes = function
+    "conditional" -> StringMap.mem lexemes "by"
+  | _ -> true
+
+let reduce_frame_aux lexemes = function
+    NoAux -> true
+  | PastAux -> (try let poss = StringMap.find lexemes "być" in StringSet.mem poss "praet" with Not_found -> false)
+  | FutAux  -> (try let poss = StringMap.find lexemes "być" in StringSet.mem poss "bedzie" with Not_found -> false)
+  | ImpAux -> StringMap.mem lexemes "niech" || StringMap.mem lexemes "niechaj" || StringMap.mem lexemes "niechże" || StringMap.mem lexemes "niechajże"
+
+let reduce_frame_atrs pos lexemes = function
+    Frame(NounAtrs _,_) -> true
+  | Frame(AdjAtrs _,_) -> true
+  | Frame(EmptyAtrs _,_) -> true
+  | Frame(PersAtrs(_,_,negation,mood,_,aux,_),_) -> reduce_frame_negation lexemes negation && reduce_frame_mood lexemes mood && reduce_frame_aux lexemes aux
+  | Frame(NonPersAtrs(_,_,_,_,negation,_),_) -> if pos = "pact" || pos = "ppas" then true else reduce_frame_negation lexemes negation
+  | Frame(GerAtrs(_,_,negation,_),_) -> reduce_frame_negation lexemes negation
+  | Frame(_,_) as frame -> failwith ("reduce_frame_atrs: " ^ ENIAMwalStringOf.frame "" frame)
+  | LexFrame _ -> true
+  | ComprepFrame _ -> true
+
+let rec reduce_frame_atrs_list pos lexemes = function
+    [] -> []
+  | frame :: l -> (if reduce_frame_atrs pos lexemes frame then [frame] else []) @ reduce_frame_atrs_list pos lexemes l
+*)
+
+let _ =
+  let schemata = ENIAMwalReduce.merge_entries ENIAMwalParser.phrases ENIAMwalParser.schemata in
+  Entries.iter schemata (fun pos lemma (opinion,neg,pred,aspect,schema) ->
+      match pos with
+        "noun" -> ignore (transform_entry "subst" lemma neg pred aspect schema)
+      | "adj" -> ignore (transform_entry "adj" lemma neg pred aspect schema)
+      | "adv" -> ignore (transform_entry "adv" lemma neg pred aspect schema)
+      | "verb" ->
+          ignore (transform_entry "fin" lemma neg pred aspect schema);
+          ignore (transform_entry "praet" lemma neg pred aspect schema);
+          ignore (transform_entry "impt" lemma neg pred aspect schema);
+          ignore (transform_entry "imps" lemma neg pred aspect schema);
+          ignore (transform_entry "ger" lemma neg pred aspect schema);
+          ignore (transform_entry "pact" lemma neg pred aspect schema);
+          ignore (transform_entry "ppas" lemma neg pred aspect schema);
+          ignore (transform_entry "inf" lemma neg pred aspect schema);
+          ignore (transform_entry "pcon" lemma neg pred aspect schema);
+          ignore (transform_entry "pant" lemma neg pred aspect schema);
+          ignore (transform_entry "bedzie" lemma neg pred aspect schema);
+          ignore (transform_entry "winien" lemma neg pred aspect schema);
+          ignore (transform_entry "pred" lemma neg pred aspect schema);
+          ()
+      | _ -> failwith "unknown pos");
+  ignore (Entries.map ENIAMwalParser.entries transform_lex_entry);
+  ()
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -525,752 +525,6 @@ let remove_pro_args schema = (* FIXME: sprawdzić czy Pro i Null są zawsze na p
     | s -> s :: schema))
  
  
-let simplify_pos = function
-    "subst" -> "noun"
-  | "depr" -> "noun"
-  | "psubst" -> "noun"
-  | "pdepr" -> "noun"
-  | "adj" -> "adj"
-  | "adjc" -> "adj"
-  | "ger" -> "verb"
-  | "pact" -> "verb"
-  | "ppas" -> "verb"
-  | "fin" -> "verb"
-  | "bedzie" -> "verb"
-  | "praet" -> "verb"
-  | "winien" -> "verb"
-  | "impt" -> "verb"
-  | "imps" -> "verb"
-  | "inf" -> "verb"
-  | "pcon" -> "verb"
-  | "pant" -> "verb"
-  | "pred" -> "verb"
-  | "ppron12" -> "pron"
-  | "ppron3" -> "pron"
-  | "siebie" -> "pron"
-  | s -> s
-
-let transform_zeby = function
-    Aff -> [Comp "że"]
-  | Negation -> [Comp "że";Comp "żeby"]
-  | NegationUndef -> [Comp "że";Comp "żeby"]
-  | _ -> failwith "transform_zeby"
-
-let transform_gdy = function
-    "indicative" -> [Comp "gdy"]
-  | "imperative" -> [Comp "gdy"]
-  | "conditional" -> [Comp "gdyby"]
-  | "gerundial" -> [Comp "gdy"]
-  | "" -> [Comp "gdy";Comp "gdyby"]
-  | s -> failwith ("transform_gdy: " ^ s)
-
-let transform_comp negation mood = function
-    Comp comp -> [Comp comp]
-  | Zeby -> transform_zeby negation
-  | Gdy -> transform_gdy mood
-  | CompUndef -> [CompUndef](*failwith "transform_comp"*)
-
-let transform_str = function
-    Aff -> [Case "acc"]
-  | Negation -> [Case "gen"]
-  | NegationUndef -> [Case "acc";Case "gen"]
-  | _ -> failwith "transform_str"
-
-(* FIXME: wstawić wszędzie adj jako wariant PrepNP, ComprepNP i NP *)
-let transform_np_phrase = function
-    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
-  | NP(CaseAgr) -> [NP(CaseAgr)(*;NumP(CaseAgr)*)]
-  | AdjP(Case _) as morf -> [morf]
-  | AdjP(CaseAgr) -> [AdjP(AllAgr)]
-  | AdjP(AllAgr) -> [AdjP(AllAgr)]
-  | AdjP(Str) -> [AdjP(AllAgr)]
-  | PrepNP(sem,prep,Case case) -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)]
-(*   | PrepNumP(_,Case _) as morf -> [morf]  *)
-  | ComprepNP _ as morf -> [morf]
-  | ComparNP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ComparNP(sem,prep,Case case))
-  | ComparPP _ as morf -> [morf]
-  | CP(ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> CP(ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | NCP(Case c,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> NCP(Case c,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | PrepNCP(sem,prep,Case case,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> PrepNCP(sem,prep,Case case,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji *)
-  | PrepAdjP(sem,_,Case _) as morf -> [morf] (* to wygląda seryjny błąd w Walentym xp(abl[prepadjp(z,gen)]) *)
-  | PrepNP(sem,prep,Str) -> List.flatten (Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)])) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | PrepAdjP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> PrepAdjP(sem,prep,Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | AdvP as morf -> [morf] (* FIXME: tu trafiają przysłówkowe realizacje, trzeba by je przetłumaczyć na przymiotniki *)
-  | FixedP _ as morf -> [morf]
-  | PrepP as morf -> [morf]
-  | Or as morf -> [morf]
-  | Pro as morf -> [morf]
-  | Null as morf -> [morf]
-  | phrase -> print_endline ("transform_np_phrase: " ^ ENIAMwalStringOf.phrase phrase); [phrase]
-
-let transform_np_pos = function
-  | SUBST(_,Case _) as morf -> [morf]
-  | SUBST(_,CaseAgr) as morf -> [morf]
-  | ADJ(_,Case _,_,_) as morf -> [morf]
-  | ADJ(n,CaseAgr,g,gr) -> [ADJ(n,AllAgr,g,gr)]
-  | PACT(n,CaseAgr,g,a,neg,r) -> [PACT(n,AllAgr,g,a,neg,r)]
-  | PPAS(_,Case _,_,_,_) as morf -> [morf]
-  | PPAS(n,CaseAgr,g,a,neg) -> [PPAS(n,AllAgr,g,a,neg)]
-  | ADJ(n,Str,g,gr) -> [ADJ(n,AllAgr,g,gr)]
-  | PPAS(n,Str,g,a,neg) -> [PPAS(n,AllAgr,g,a,neg)]
-  | PREP(Case _) as morf -> [morf]
-  | ADV _ as morf -> [morf] (* FIXME: tu trafiają przysłówkowe realizacje, trzeba by je przetłumaczyć na przymiotniki *)
-  | COMP _ as morf -> [morf]
-  | QUB as morf -> [morf]
-  | pos -> print_endline ("transform_np_pos: " ^ ENIAMwalStringOf.pos pos); [pos]
-
-let transform_adj_phrase = function
-    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
-  | NP(Part) -> [NP(Case "gen");NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)]
-  | AdjP(CaseAgr) -> [AdjP(AllAgr)] (* jedno wystąpienie 'cały szczęśliwy', może się przydać podniesienie typu *)
-  | PrepNP(sem,prep,Case case) -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)]
-  | ComprepNP _ as morf -> [morf]
-  | ComparNP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ComparNP(sem,prep,Case case))
-  | ComparPP _ as morf -> [morf]
-  | CP(ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> CP(ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | NCP(Case c,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> NCP(Case c,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | PrepNCP(sem,prep,Case case,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> PrepNCP(sem,prep,Case case,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji *)
-  | PrepAdjP(sem,_,Case _) as morf -> [morf]
-  | PrepNP(sem,prep,Str) -> List.flatten (Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)])) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | PrepAdjP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> PrepAdjP(sem,prep,Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | InfP _ as morf -> [morf]
-  | AdvP as morf -> [morf]
-  | FixedP _ as morf -> [morf]
-  | PrepP as morf -> [morf]
-  | Or as morf -> [morf]
-  | Pro as morf -> [morf]
-  | Null as morf -> [morf]
-  | morf -> print_endline ("transform_adj_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_adj_pos = function
-  | SUBST(_,Case _) as morf -> [morf]
-  | ADJ(n,CaseAgr,g,gr) -> [ADJ(n,AllAgr,g,gr)]
-  | PREP(Case _) as morf -> [morf]
-  | ADV _ as morf -> [morf]
-  | morf -> print_endline ("transform_adj_pos: " ^ ENIAMwalStringOf.pos morf); [morf]
-
-let transform_prep_pos = function
-  | SUBST(_,Case _) as morf -> [morf]
-  | SUBST(n,Str) -> [SUBST(n,CaseAgr)]
-  | NUM(Case _,_,_) as morf -> [morf]
-  | ADJ(_,Case _,_,_) as morf -> [morf]
-  | GER(_,Case _,_,_,_,_) as morf -> [morf]
-  | PPAS(_,Case _,_,_,_) as morf -> [morf]
-  | ADV _ as morf -> [morf]
-  | QUB as morf -> [morf]
-  | pos -> print_endline ("transform_prep_pos: " ^ ENIAMwalStringOf.pos pos); [pos]
-
-let transform_compar_phrase = function
-    NP(Str) -> [NP CaseUndef(*;NumP(CaseUndef)*)] (* FIXME: ta sama sytuacja co w "jako" *)
-  | FixedP _ as morf -> [morf]
-  | phrase -> print_endline ("transform_compar_phrase: " ^ ENIAMwalStringOf.phrase phrase); [phrase]
-
-let transform_compar_pos = function
-  | SUBST(_,Case _) as morf -> [morf]
-  | ADJ(_,Case _,_,_) as morf -> [morf]
-  | PREP(Case _) as morf -> [morf]
-  | PPAS(_,Case _,_,_,_) as morf -> [morf]
-  | SUBST(Number n,Str) -> [SUBST(Number n,CaseUndef)]
-  | SUBST(NumberAgr,Str) -> [SUBST(NumberUndef,CaseUndef)]
-  | SUBST(NumberUndef,Str) -> [SUBST(NumberUndef,CaseUndef)]
-  | PPAS(NumberAgr,Str,GenderAgr,a,neg) -> [PPAS(NumberUndef,CaseUndef,GenderUndef,a,neg)]  (* FIXME: ta sama sytuacja co w "jako" *)
-  | PPAS(NumberAgr,CaseAgr,GenderAgr,a,neg) -> [PPAS(NumberUndef,CaseUndef,GenderUndef,a,neg)] (* FIXME: ta sama sytuacja co w "jako" *)
-  | ADJ(NumberAgr,Str,GenderAgr,gr) -> [ADJ(NumberUndef,CaseUndef,GenderUndef,gr)] (* FIXME: ta sama sytuacja co w "jako" *)
-  | ADJ(NumberAgr,CaseAgr,GenderAgr,gr) -> [ADJ(NumberUndef,CaseUndef,GenderUndef,gr)] (* FIXME: ta sama sytuacja co w "jako" *)
-  | NUM(Case _,_,_) as morf -> [morf]
-  | pos -> print_endline ("transform_compar_pos: " ^ ENIAMwalStringOf.pos pos); [pos]
-
-let transform_adv_phrase = function
-    NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
-  | PrepNP(sem,prep,Case case) -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)]
-  | PrepNCP(sem,prep,Case case,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> PrepNCP(sem,prep,Case case,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji *)
-  | ComprepNP _ as morf -> [morf]
-  | CP(ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> CP(ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | InfP _ as morf -> [morf]
-  | AdvP as morf -> [morf]
-  | Or as morf -> [morf]
-  | Pro as morf -> [morf]
-  | Null as morf -> [morf]
-  | PrepAdjP(sem,_,Case _) as morf -> [morf]
-  | PrepNP(sem,prep,Str) -> List.flatten (Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)])) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | PrepAdjP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> PrepAdjP(sem,prep,Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | ComparNP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ComparNP(sem,prep,Case case))
-  | ComparPP _ as morf -> [morf]
-(*   | AdjP(CaseAgr) as morf -> [morf]  *)
-(*  | NCP(Case c,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> NCP(Case c,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji*)
-  | PrepNCP(prep,Case case,ctype,comp) -> Xlist.map (transform_comp NegationUndef "" comp) (fun comp -> PrepNCP(prep,Case case,ctype,comp)) (* FIXME zależność od trybu warunkowego*) (* FIXME zależność od negacji *)
-  | FixedP _ as morf -> [morf]*)
-  | morf -> print_endline ("transform_adv_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_adv_pos = function
-(*  | SUBST(_,Case _) as morf -> [morf]
-  | ADJ(_,CaseAgr,_,_) as morf -> [morf]*)
-    COMP _ as morf -> [morf]
-  | PREP(Case _) as morf -> [morf]
-  | ADV _ as morf -> [morf]
-  | morf -> print_endline ("transform_adv_pos: " ^ ENIAMwalStringOf.pos morf); [morf]
-
-(*| Prepnp("jako",Str) as morf -> morf
-  | Prepnp("jak",Str) as morf -> morf
-  | Prepnp("niczym",Str) as morf -> morf
-  | Prepadjp("jako",Str) as morf -> morf
-  | Prepadjp("jak",Str) as morf -> morf
-  | Prepadjp("niczym",Str) as morf -> morf
-  | Compar "jako" as morf -> morf
-  | Compar "jak" as morf -> morf
-  | Compar "niczym" as morf -> morf
-  | Compar "niż" as morf -> morf*)
-
-let transform_pers_subj_phrase negation mood = function (* FIXME: prepnp(na,loc) *)
-  | NP(Str) -> [NP(NomAgr)(*;NumP(NomAgr)*)]
-  | NCP(Str,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> NCP(NomAgr,ctype,comp))
-  | CP(ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> CP(ctype,comp))
-  | InfP _ as morf -> [morf]
-  | Or as morf -> [morf]
-  | NP(Part) -> [NP(Case "gen")(*;NP(Case "acc")*)(*;NumP(Case "gen");NumP(Case "acc")*)]
-  | Pro -> [ProNG]
-  | morf -> print_endline ("transform_pers_subj_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_pers_subj_pos negation mood = function
-    COMP _ as morf -> [morf]
-  | SUBST(n,Str) -> [SUBST(n,NomAgr)]
-  | SUBST(n,Case "nom") -> [SUBST(n,NomAgr)] (* wygląda na błąd Walentego, ale nie ma znaczenia *)
-  | NUM(Str,g,AcmUndef) -> [NUM(NomAgr,g,AcmUndef)]
-  | ADJ(n,Str,g,gr) -> [ADJ(n,NomAgr,g,gr)]
-  | morf -> print_endline ("transform_ger_subj_pos: " ^ ENIAMwalStringOf.pos morf); [morf]
-
-let transform_ger_subj_phrase negation mood control = function
-  | NP(Str) -> [NP(Case "gen");PrepNP(NoSem,"przez",Case "acc")(*;NumP(Case "gen")*)(*;PrepNumP("przez",Case "acc")*)] (* FIXME: czy przez:acc jest możliwe? *)
-  | NCP(Str,ctype,comp) -> List.flatten (Xlist.map (transform_comp negation mood comp) (fun comp -> [NCP(Case "gen",ctype,comp);PrepNCP(NoSem,"przez",Case "acc",ctype,comp)])) (* FIXME: czy przez:acc jest możliwe? *)
-  | CP(ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> CP(ctype,comp)) (* FIXME: czy to jest możliwe? *)
-  | InfP _ as morf -> [morf] (* FIXME: czy to jest możliwe? *)
-  | Or as morf -> [morf]
-  | NP(Part) -> [NP(Case "gen")(*;NP(Case "acc")*)(*;NumP(Case "gen");NumP(Case "acc")*)]
-  | Pro -> if control then [Pro] else [Null]
-  | morf -> print_endline ("transform_ger_subj_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_ger_subj_pos negation mood = function (* FIXME: ADV(_) *)
-    COMP _ as morf -> [morf] (* FIXME: czy to jest możliwe? *)
-  | SUBST(n,Str) -> [SUBST(n,Case "gen")]
-  | SUBST(n,Case "nom") -> [SUBST(n,Case "gen")] (* wygląda na błąd Walentego, ale nie ma znaczenia *)
-  | NUM(Str,g,AcmUndef) -> [NUM(Case "gen",g,AcmUndef)]
-  | ADJ(n,Str,g,gr) -> [ADJ(n,Case "gen",g,gr)]
-  | morf -> print_endline ("transform_pers_subj_pos: " ^ ENIAMwalStringOf.pos morf); [morf]
-
-let transform_ppas_subj_phrase negation mood control = function
-  | NP(Str) -> [PrepNP(NoSem,"przez",Case "acc")(*;PrepNumP("przez",Case "acc")*)]
-  | NCP(Str,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> PrepNCP(NoSem,"przez",Case "acc",ctype,comp))
-  | CP(ctype,comp) -> [Null] (* zakładam, że w ramie jest też NCP *)
-  | Pro -> if control then [Pro] else [Null]
-  | morf -> print_endline ("transform_ppas_subj_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_pers_phrase negation mood = function
-  | NP(Str) -> List.flatten (Xlist.map (transform_str negation) (fun case -> [NP case(*;NumP(case)*)]))
-  | AdjP(Str) -> Xlist.map (transform_str negation) (fun case -> AdjP case) (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
-  | NCP(Str,ctype,comp) -> List.flatten (Xlist.map (transform_str negation) (fun case -> Xlist.map (transform_comp negation mood comp) (fun comp -> NCP(case,ctype,comp))))
-  | NP(Part) -> [NP(Case "gen");NP(Case "acc")(*;NumP(Case "gen");NumP(Case "acc")*)]
-  | NCP(Part,ctype,comp) -> List.flatten (Xlist.map (transform_comp negation mood comp) (fun comp -> [NCP(Case "gen",ctype,comp);NCP(Case "acc",ctype,comp)]))
-  | NP(Case case) -> [NP(Case case)(*;NumP(Case case)*)]
-  | PrepNP(sem,prep,Case case) -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)]
-(*   | PrepNumP(_,Case _) as morf -> [morf] *)
-  | ComprepNP _ as morf -> [morf]
-  | NCP(Case case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> NCP(Case case,ctype,comp))
-  | PrepNCP(sem,prep,Case case,ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> PrepNCP(sem,prep,Case case,ctype,comp))
-  | AdjP(Case _) as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
-  | PrepAdjP(sem,_,Case _) as morf -> [morf] (* FIXME: pomijam uzgadnianie liczby i rodzaju - wykonalne za pomocą kontroli *)
-  | PrepNP(sem,prep,Str) -> List.flatten (Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> [PrepNP(sem,prep,Case case)(*;PrepNumP(prep,Case case)*)])) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | PrepAdjP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> PrepAdjP(sem,prep,Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | ComparNP(sem,prep,Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ComparNP(sem,prep,Case case))
-  | ComparPP _ as morf -> [morf]
-  | CP(ctype,comp) -> Xlist.map (transform_comp negation mood comp) (fun comp -> CP(ctype,comp))
-  | InfP _ as morf -> [morf]
-  | PadvP as morf -> [morf]
-  | AdvP -> if mood = "gerundial" then [AdjP AllAgr] else [AdvP]
-  | FixedP _ as morf -> [morf]
-  | PrepP as morf -> [morf]
-  | Or as morf -> [morf]
-  | Lex "się" as morf -> [morf]
-(*   | Refl as morf -> [morf] *)
-(*   | Recip as morf -> [morf] *)
-  | Pro as morf -> [morf]
-  | Null as morf -> [morf]
-  | morf -> print_endline ("transform_pers_phrase: " ^ ENIAMwalStringOf.phrase morf); [morf]
-
-let transform_pers_pos negation mood = function
-  | SUBST(n,Str) -> Xlist.map (transform_str negation) (fun case -> SUBST(n,case))
-  | NUM(Str,g,a) -> Xlist.map (transform_str negation) (fun case -> NUM(case,g,a))
-  | ADJ(n,Str,g,gr) -> Xlist.map (transform_str negation) (fun case -> ADJ(n,case,g,gr))
-  | PPAS(n,Str,g,a,neg) -> Xlist.map (transform_str negation) (fun case -> PPAS(n,Str,g,a,neg))
-  | SUBST(n,Part) -> [SUBST(n,Case "gen");SUBST(n,Case "acc")]
-  | SUBST(_,Case _) as morf -> [morf]
-  | NUM(Case _,_,_) as morf -> [morf]
-  | PREP(Case _) as morf -> [morf]
-  | ADJ(_,Case _,_,_) as morf -> [morf]
-  | PREP(Str) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> PREP(Case case)) (* FIXME: sprawdzić kto kontroluje! *) (* FIXME: pomijam uzgodnienie liczby i rodzaju *) (* zakładam, że nie jest kontrolowany przez SUBJ w czasowikach z OBJ *)
-  | SUBST(n,CaseAgr) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> SUBST(n,Case case)) (* FIXME: sprawdzić kto kontroluje! *)
-  | ADJ(n,CaseAgr,g,gr) -> Xlist.map ["nom";"gen";"dat";"acc";"inst"] (fun case -> ADJ(n,Case case,g,gr))  (* FIXME: sprawdzić kto kontroluje! *)
-  | COMPAR as morf -> [morf]
-  | COMP _ as morf -> [morf]
-  | INF _ as morf -> [morf]
-  | ADV grad -> if mood = "gerundial" then [ADJ(NumberAgr,AllAgr,GenderAgr,grad)] else [ADV grad]
-  | morf -> print_endline ("transform_pers_pos: " ^ ENIAMwalStringOf.pos morf); [morf]
-
-let transform_pers_schema negation mood schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_subj_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> Xlist.map (transform_pers_subj_phrase negation mood phrase) (fun phrase -> E phrase)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_subj_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_fin_schema"))
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_fin_schema"))})
-
-let transform_impt_schema negation mood schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then [Phrase ProNG]
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_impt_schema"))})
-
-let transform_imps_schema negation mood schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then [Phrase Pro]
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_imps_chema"))})
-
-let transform_ger_schema negation schema = (* FIXME: zakładam, że ger zeruje mood, czy to prawda? *)
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_ger_subj_phrase negation "gerundial" (s.cr <> [] || s.ce <> []) phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> Xlist.map (transform_ger_subj_phrase negation "gerundial" (s.cr <> [] || s.ce <> []) phrase) (fun phrase -> E phrase)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_ger_subj_pos negation "gerundial" pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_fin_schema"))
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation "gerundial" phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation "gerundial" pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_fin_schema"))})
-
-let transform_padv_schema negation mood pro schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then if s.ce = [] then if pro then [Phrase Pro] else [Phrase Null] else [Phrase Null] else
-       List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_fin_schema"))})
-
-let transform_pact_schema negation mood schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = SUBJ then [Phrase Null]
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_pact_schema"))})
-
-let transform_ppas_schema negation mood schema =
-  Xlist.map schema (fun s ->
-    {s with morfs =
-       if s.gf = OBJ then [Phrase Null] else
-       if s.gf = SUBJ then List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_ppas_subj_phrase negation mood (s.cr <> [] || s.ce <> []) phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> Xlist.map (transform_ppas_subj_phrase negation mood (s.cr <> [] || s.ce <> []) phrase) (fun phrase -> E phrase)
-         | LexArg(id,SUBST(n,Str),lex) -> raise Not_found (* FIXME!!! *)
-         | _ -> failwith "transform_ppas_schema"))
-       else List.flatten (Xlist.map s.morfs (function
-           Phrase phrase -> Xlist.map (transform_pers_phrase negation mood phrase) (fun phrase -> Phrase phrase)
-         | E phrase -> [Phrase Null] (*E(List.flatten (Xlist.map phrases (transform_pers_phrase negation mood)))*) (* FIXME *)
-         | LexArg(id,pos,lex) -> Xlist.map (transform_pers_pos negation mood pos) (fun pos -> LexArg(id,pos,lex))
-         | _ -> failwith "transform_ppas_schema"))})
-
-let add_padv schema =
-  List.flatten (Xlist.map schema (fun s ->
-    if s.gf = SUBJ then
-      match s.cr with
-        [] -> [{s with cr=["3"]}; let s = adjunct_schema_field "" Both [Phrase Null;Phrase PadvP] in {s with ce=["3"]}]
-      | [cr] -> [s; let s = adjunct_schema_field "" Both [Phrase Null;Phrase PadvP] in {s with ce=[cr]}]
-      | _ -> failwith "add_padv"
-    else [s]))
-
-let transform_np_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-      Phrase phrase -> Xlist.map (transform_np_phrase phrase) (fun phrase -> Phrase phrase)
-(*     | LexArg(id,ADV _,lex) as morf -> print_endline (ENIAMwalStringOf.morf morf); [morf] *)
-    | LexArg(id,pos,lex) -> Xlist.map (transform_np_pos pos) (fun pos -> LexArg(id,pos,lex))
-    | Multi[AdjP AllAgr] -> [Multi[AdjP AllAgr]]
-    | _ -> failwith "transform_np_schema"))})
-
-let transform_num_schema acm schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function (* kierunek argumentu został dodany w expand_lexicalizations_morfs *)
-    | Phrase Pro -> [Phrase Pro]
-    | LexArg(id,SUBST(NumberUndef,CaseUndef),lex) ->
-         (match acm with
-            Acm "rec" -> [LexArg(id,SUBST(NumberUndef,GenAgr),lex)]
-          | Acm "congr" -> [LexArg(id,SUBST(NumberUndef,AllAgr),lex)]
-          | _ -> failwith "transform_num_schema")
-    | morf -> failwith ("transform_num_schema: " ^ ENIAMwalStringOf.morf morf)))})
-
-let transform_adj_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-      Phrase phrase -> Xlist.map (transform_adj_phrase phrase) (fun phrase -> Phrase phrase)
-    | LexArg(id,pos,lex) -> Xlist.map (transform_adj_pos pos) (fun pos -> LexArg(id,pos,lex))
-    | _ -> failwith "transform_adj_schema"))})
-
-let transform_adv_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-      Phrase phrase -> Xlist.map (transform_adv_phrase phrase) (fun phrase -> Phrase phrase)
-    | LexArg(id,pos,lex) -> Xlist.map (transform_adv_pos pos) (fun pos -> LexArg(id,pos,lex))
-    | _ -> failwith "transform_adv_schema"))})
-
-let transform_prep_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-      Phrase(NumP(case)) -> [Phrase(NumP(case))]
-    | LexArg(id,pos,lex) -> Xlist.map (transform_prep_pos pos) (fun pos -> LexArg(id,pos,lex))
-    | morf -> failwith ("transform_prep_schema: " ^ ENIAMwalStringOf.morf morf)))})
-
-let transform_compar_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-      Phrase phrase -> Xlist.map (transform_compar_phrase phrase) (fun phrase -> Phrase phrase)
-    | LexArg(id,pos,lex) -> Xlist.map (transform_compar_pos pos) (fun pos -> LexArg(id,pos,lex))
-    | morf -> failwith ("transform_compar_schema: " ^ ENIAMwalStringOf.morf morf)))})
-
-let transform_comp_schema schema = (* kierunek argumentu został dodany w expand_lexicalizations_morfs *)
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-    | LexArg(_,PERS _,_) as morf -> [morf]
-    | morf -> failwith ("transform_comp_schema: " ^ ENIAMwalStringOf.morf morf)))})
-
-let transform_qub_schema schema =
-  Xlist.map schema (fun s ->
-    {s with morfs=List.flatten (Xlist.map s.morfs (function
-    | LexArg(_,PERS _,_) as morf -> [morf]
-    | morf -> failwith ("transform_qub_schema: " ^ ENIAMwalStringOf.morf morf)))})
-
-let rec remove_adj_agr = function
-    [] -> []
-  | {morfs=[Phrase Null;Phrase(AdjP(CaseAgr))]} :: l -> remove_adj_agr l
-  | {morfs=[Phrase Null;Phrase(AdjP(Part))]} :: l -> remove_adj_agr l
-  | s :: l -> (*print_endline (ENIAMwalStringOf.schema [s]);*) s :: (remove_adj_agr l)
-
-let rec get_role gf = function
-    [] -> raise Not_found
-  | s :: l -> if s.gf = gf then s.role,s.role_attr else get_role gf l
-
-let expand_negation = function
-    Negation -> [Negation]
-  | Aff -> [Aff]
-  | NegationUndef -> [Negation;Aff]
-  | NegationNA -> failwith "expand_negation"
-
-let expand_aspect = function
-    Aspect s -> [Aspect s]
-  | AspectUndef -> [Aspect "imperf";Aspect "perf"]
-  | AspectNA -> failwith "expand_aspect"
-
-let load_list filename =
-  Str.split (Str.regexp "\n") (File.load_file filename)
-
-let subst_uncountable_lexemes = StringSet.of_list (load_list subst_uncountable_lexemes_filename)
-let subst_uncountable_lexemes2 = StringSet.of_list (load_list subst_uncountable_lexemes_filename2)
-let subst_container_lexemes = StringSet.of_list (load_list subst_container_lexemes_filename)
-let subst_numeral_lexemes = StringSet.of_list (load_list subst_numeral_lexemes_filename)
-let subst_time_lexemes = StringSet.of_list (load_list subst_time_lexemes_filename)
-
-let subst_pronoun_lexemes = StringSet.of_list ["co"; "kto"; "cokolwiek"; "ktokolwiek"; "nic"; "nikt"; "coś"; "ktoś"; "to"]
-let adj_pronoun_lexemes = StringSet.of_list ["czyj"; "jaki"; "który"; "jakiś"; "ten"; "taki"]
-
-(* let adj_quant_lexemes = StringSet.of_list ["każdy"; "wszelki"; "wszystek"; "żaden"; "jakiś"; "pewien"; "niektóry"; "jedyny"; "sam"] *)
-
-let empty_valence_lexemes = StringSet.union subst_pronoun_lexemes adj_pronoun_lexemes
-
-
-let noun_type lemma pos =
-  let nsyn =
-    if pos = "ppron12" || pos = "ppron3" || pos = "siebie" then "pronoun" else
-    if pos = "psubst" || pos = "pdepr" || pos = "date" then "proper" else
-    if StringSet.mem subst_pronoun_lexemes lemma then "pronoun" else
-    "common" in
-  let nsem =
-    if pos = "ppron12" || pos = "ppron3" || pos = "siebie" then [Common "count"] else
-    if StringSet.mem subst_time_lexemes lemma then [Time] else
-    let l = ["count"] in
-    let l = if StringSet.mem subst_uncountable_lexemes lemma || StringSet.mem subst_uncountable_lexemes2 lemma then "mass" :: l else l in
-    let l = if StringSet.mem subst_container_lexemes lemma then "measure" :: l else l in
-    Xlist.map l (fun s -> Common s) in
-  nsyn,nsem
-
-let adj_type lemma = (* FIXME: typy przymiotników wymagają zbadania - przejrzenia listy przymiotników *)
-  let adjsyn = if StringSet.mem adj_pronoun_lexemes lemma then "pronoun" else "common" in  (* FIXME: dodać heurystykę uwzględniającą wielkość liter aby wykrywać proper np. Oświęcimski*)
-  adjsyn
-
-let transform_frame lexeme pos = function (* FIXME: dodać tutaj typy rzeczowników *)
-    Frame(DefaultAtrs(meanings,refl,opinion,negation,pred,aspect),schema) as frame ->
-      if pos = "subst" || pos = "depr" || pos = "psubst" || pos = "pdepr" || pos = "ppron12" || pos = "ppron3" || pos = "siebie" then (
-        if refl <> ReflEmpty || negation <> NegationNA || pred <> PredNA || aspect <> AspectNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let nsyn,nsem(*,typ*) = noun_type lexeme pos in
-        let schema = if nsyn = "pronoun" then [] else (remove_adj_agr schema) @ noun_adjuncts in (* FIXME: remove_adj_agr jest w słowniku tymczasowo *)
-(*         List.flatten (Xlist.map typ (fun typ ->  *)
-          Xlist.map nsem (fun nsem -> Frame(NounAtrs(meanings,nsyn,nsem(*,typ*)),transform_np_schema schema)))(* ))*) else
-      if pos = "symbol" || pos = "date" || pos = "date-interval" || pos = "hour" || pos = "hour-minute" || pos = "hour-interval" || pos = "hour-minute-interval" ||
-         pos = "year" || pos = "year-interval" || pos = "day" || pos = "day-interval" || pos = "day-month" || pos = "day-month-interval" ||
-         pos = "match-result" || pos = "month-interval" || pos = "roman" || pos = "roman-interval" || pos = "url" || pos = "email" || pos = "obj-id" then
-        let nsyn,nsem = "proper",[Common "count"] in
-        Xlist.map nsem (fun nsem -> Frame(NounAtrs(meanings,nsyn,nsem),transform_np_schema schema)) else
-      if pos = "adj" || pos = "adjc" || pos = "adjp" || pos = "ordnum" then (
-        if refl <> ReflEmpty || negation <> NegationNA || aspect <> AspectNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let adjsyn(*,adjsem,typ*) = adj_type lexeme in
-        let schema = if pos = "adjp" || pos = "ordnum" then schema else if adjsyn = "pronoun" then [] else schema @ adj_adjuncts in
-        let case = match pred with Pred -> Case "pred" | PredNA -> CaseUndef in
-(*         Xlist.map typ (fun typ ->  *)
-          [Frame(AdjAtrs(meanings,case,adjsyn(*,adjsem,typ*)),transform_adj_schema schema)])(* )*) else
-      if pos = "adv" then (
-        if refl <> ReflEmpty || negation <> NegationNA || pred <> PredNA || aspect <> AspectNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame); (* FIXME: typy przysłówków *)
-        [Frame(EmptyAtrs meanings,transform_adv_schema (remove_adj_agr schema))]) else
-      if pos = "fin" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        List.flatten (Xlist.map (expand_negation negation) (fun negation ->
-          Xlist.map (expand_aspect aspect) (function
-            Aspect "imperf" -> Frame(PersAtrs(meanings,s,negation,"indicative","pres",NoAux,Aspect "imperf"), transform_pers_schema negation "indicative" schema)
-          | Aspect "perf" -> Frame(PersAtrs(meanings,s,negation,"indicative","fut",NoAux,Aspect "perf"), transform_pers_schema negation "indicative" schema)
-          | _ -> failwith "transform_frame") @
-          [Frame(PersAtrs(meanings,s,negation,"imperative","fut",ImpAux,aspect), transform_pers_schema negation "imperative" schema)]))) else
-      if pos = "bedzie" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        List.flatten (Xlist.map (expand_negation negation) (fun negation ->
-          Xlist.map (expand_aspect aspect) (function
-            Aspect "imperf" -> Frame(PersAtrs(meanings,s,negation,"indicative","fut",NoAux,Aspect "imperf"), transform_pers_schema negation "indicative" schema)
-          | Aspect "perf" -> Frame(PersAtrs(meanings,s,negation,"indicative","fut",NoAux,Aspect "perf"), transform_pers_schema negation "indicative" schema) (* FIXME: niepotrzebne *)
-          | _ -> failwith "transform_frame")))) else
-      if pos = "praet" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        List.flatten (Xlist.map (expand_negation negation) (fun negation ->
-          List.flatten (Xlist.map (expand_aspect aspect) (function
-            Aspect "imperf" ->
-              [Frame(PersAtrs(meanings,s,negation,"indicative","past",NoAux,Aspect "imperf"), transform_pers_schema negation "indicative" schema);
-               Frame(PersAtrs(meanings,s,negation,"conditional","past",NoAux,Aspect "imperf"), transform_pers_schema negation "conditional" schema);
-               Frame(PersAtrs(meanings,s,negation,"indicative","fut",FutAux,Aspect "imperf"), transform_pers_schema negation "indicative" schema)]
-          | Aspect "perf" ->
-              [Frame(PersAtrs(meanings,s,negation,"indicative","past",NoAux,Aspect "perf"), transform_pers_schema negation "indicative" schema);
-               Frame(PersAtrs(meanings,s,negation,"conditional","past",NoAux,Aspect "perf"), transform_pers_schema negation "conditional" schema)]
-          | _ -> failwith "transform_frame"))))) else
-      if pos = "winien"  then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        List.flatten (Xlist.map (expand_negation negation) (fun negation ->
-          List.flatten (Xlist.map (expand_aspect aspect) (fun aspect ->
-              [Frame(PersAtrs(meanings,s,negation,"indicative","pres",NoAux,aspect), transform_pers_schema negation "indicative" schema);
-               Frame(PersAtrs(meanings,s,negation,"conditional","past",NoAux,aspect), transform_pers_schema negation "conditional" schema);
-               Frame(PersAtrs(meanings,s,negation,"indicative","past",PastAux,aspect), transform_pers_schema negation "indicative" schema)]))))) else
-      if pos = "impt" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        Xlist.map (expand_negation negation) (fun negation ->
-            Frame(PersAtrs(meanings,s,negation,"imperative","fut",NoAux,aspect),transform_impt_schema negation "imperative" schema))) else
-      if pos = "imps" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        Xlist.map (expand_negation negation) (fun negation ->
-            Frame(PersAtrs(meanings,s,negation,"indicative","past",NoAux,aspect),transform_imps_schema negation "indicative" schema))) else
-      if pos = "pred" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = (add_padv schema) @ verb_adjuncts in
-        List.flatten (Xlist.map (expand_negation negation) (fun negation ->
-              [Frame(PersAtrs(meanings,s,negation,"indicative","pres",NoAux,aspect), transform_pers_schema negation "indicative" schema);
-               Frame(PersAtrs(meanings,s,negation,"indicative","fut",FutAux,aspect), transform_pers_schema negation "indicative" schema);
-               Frame(PersAtrs(meanings,s,negation,"indicative","past",PastAux,aspect), transform_pers_schema negation "indicative" schema)]))) else
-      if pos = "pcon" || pos = "pant" || pos = "inf" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let role,role_attr = try get_role SUBJ schema with Not_found -> "Initiator","" in
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-        let schema = schema @ verb_adjuncts in
-        Xlist.map (expand_negation negation) (fun negation ->
-            Frame(NonPersAtrs(meanings,s,role,role_attr,negation,aspect),transform_padv_schema negation "indicative" true schema))) else
-      if pos = "pact" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        try
-          let role,role_attr = try get_role SUBJ schema with Not_found -> "Initiator","" in
-          let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in
-          let schema = schema @ verb_adjuncts in
-          Xlist.map (expand_negation negation) (fun negation ->
-              Frame(NonPersAtrs(meanings,s,role,role_attr,negation,aspect),transform_pact_schema negation "indicative" schema))
-        with Not_found -> []) else
-      if pos = "ppas" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        try
-          let role,role_attr = try get_role OBJ schema with Not_found -> "Theme","" in
-          let s,schema = if refl = ReflSie then raise Not_found else lexeme, schema in
-          let schema = schema @ verb_adjuncts in
-          Xlist.map (expand_negation negation) (fun negation ->
-              Frame(NonPersAtrs(meanings,s,role,role_attr,negation,aspect),transform_ppas_schema negation "indicative" schema))
-        with Not_found -> []) else
-      if pos = "ger" then (
-        if pred <> PredNA then failwith ("transform_frame: " ^ ENIAMwalStringOf.frame lexeme frame);
-        let s,schema = if refl = ReflSie then lexeme ^ " się", nosem_refl_schema_field :: schema else lexeme, schema in (* FIXME: czy ger może mieć niesemantyczne się? *)
-        let schema = schema @ verb_adjuncts in
-        Xlist.map (expand_negation negation) (fun negation ->
-            Frame(GerAtrs(meanings,s,negation,aspect),transform_ger_schema negation schema))) else
-      failwith ("transform_frame: " ^ pos)
-  | LexFrame(id,pos,NoRestr,schema) as frame ->
-      (match pos with
-         SUBST _ -> [LexFrame(id,pos,NoRestr,transform_np_schema schema)]
-       | PREP _ -> [LexFrame(id,pos,NoRestr,transform_prep_schema schema)]
-       | NUM(c,g,AcmUndef) ->
-            Xlist.map [Acm "congr";Acm "rec"] (fun acm ->
-              LexFrame(id,NUM(c,g,acm),NoRestr,transform_num_schema acm schema))
-       | ADJ(n,c,g,gr) -> [LexFrame(id,pos,NoRestr,transform_adj_schema schema)]
-       | ADV(gr) -> [LexFrame(id,pos,NoRestr,transform_adv_schema schema)]
-       | GER(n,c,g,a,negation,ReflEmpty) ->
-            Xlist.map (expand_negation negation) (fun negation ->
-              LexFrame(id,GER(n,c,g,a,negation,ReflEmpty),NoRestr,transform_ger_schema negation schema))
-       | PACT(n,c,g,a,negation,ReflEmpty) ->
-            Xlist.map (expand_negation negation) (fun negation ->
-              LexFrame(id,PACT(n,c,g,a,negation,ReflEmpty),NoRestr,transform_pact_schema negation "indicative" schema))
-       | PPAS(n,c,g,a,negation) ->
-            Xlist.map (expand_negation negation) (fun negation ->
-              LexFrame(id,PPAS(n,c,g,a,negation),NoRestr,transform_ppas_schema negation "indicative" schema))
-       | INF(a,negation,r) ->
-            Xlist.map (expand_negation negation) (fun negation ->
-              LexFrame(id,INF(a,negation,r),NoRestr,transform_padv_schema negation "indicative" false schema))
-       | QUB -> [LexFrame(id,pos,NoRestr,transform_qub_schema schema)]
-       | COMPAR -> [LexFrame(id,pos,NoRestr,transform_compar_schema schema)]
-       | COMP _ -> [LexFrame(id,pos,NoRestr,transform_comp_schema schema)]
-       | PERS(negation,r) ->
-            Xlist.map (expand_negation negation) (fun negation ->
-              LexFrame(id,PERS(negation,r),NoRestr,transform_pers_schema negation "indicative" schema))
-       | _ -> failwith ("transform_frame:" ^ ENIAMwalStringOf.frame lexeme frame))
-  | ComprepFrame(s,pos,NoRestr,schema) as frame ->
-      (match pos with
-         PREP _ -> [ComprepFrame(s,pos,NoRestr,transform_prep_schema schema)]
-       | ADV _ -> [ComprepFrame(s,pos,NoRestr,transform_adv_schema schema)]
-       | _ -> failwith ("transform_frame:" ^ ENIAMwalStringOf.frame lexeme frame))
-  | frame -> failwith ("transform_frame:" ^ ENIAMwalStringOf.frame lexeme frame)
-
-let reduce_frame_negation lexemes = function
-    Negation -> StringMap.mem lexemes "nie"
-  | _ -> true
-
-let reduce_frame_mood lexemes = function
-    "conditional" -> StringMap.mem lexemes "by"
-  | _ -> true
-
-let reduce_frame_aux lexemes = function
-    NoAux -> true
-  | PastAux -> (try let poss = StringMap.find lexemes "być" in StringSet.mem poss "praet" with Not_found -> false)
-  | FutAux  -> (try let poss = StringMap.find lexemes "być" in StringSet.mem poss "bedzie" with Not_found -> false)
-  | ImpAux -> StringMap.mem lexemes "niech" || StringMap.mem lexemes "niechaj" || StringMap.mem lexemes "niechże" || StringMap.mem lexemes "niechajże"
-
-let reduce_frame_atrs pos lexemes = function
-    Frame(NounAtrs _,_) -> true
-  | Frame(AdjAtrs _,_) -> true
-  | Frame(EmptyAtrs _,_) -> true
-  | Frame(PersAtrs(_,_,negation,mood,_,aux,_),_) -> reduce_frame_negation lexemes negation && reduce_frame_mood lexemes mood && reduce_frame_aux lexemes aux
-  | Frame(NonPersAtrs(_,_,_,_,negation,_),_) -> if pos = "pact" || pos = "ppas" then true else reduce_frame_negation lexemes negation
-  | Frame(GerAtrs(_,_,negation,_),_) -> reduce_frame_negation lexemes negation
-  | Frame(_,_) as frame -> failwith ("reduce_frame_atrs: " ^ ENIAMwalStringOf.frame "" frame)
-  | LexFrame _ -> true
-  | ComprepFrame _ -> true
-
-let rec reduce_frame_atrs_list pos lexemes = function
-    [] -> []
-  | frame :: l -> (if reduce_frame_atrs pos lexemes frame then [frame] else []) @ reduce_frame_atrs_list pos lexemes l
-
-let find_frames lexemes =
-(*   print_endline "find_frames 1"; *)
-  let valence = StringMap.fold lexemes StringMap.empty (fun valence lexeme poss ->
-(*     let poss = StringSet.fold poss StringSet.empty (fun poss pos -> StringSet.add poss (simplify_pos pos)) in *)
-(*   Printf.printf "find_frame: %s |%s|\n" s (String.concat " " (StringSet.to_list lexemes));   *)
-    StringSet.fold poss valence (fun valence pos ->
-      let valence =
-        let frames_sem = try StringMap.find (StringMap.find walenty (simplify_pos pos)) lexeme with Not_found -> [] in
-(*         if frames_sem <> [] then Printf.printf "%s %s in TEI\n%!" lexeme pos; *)
-        if frames_sem <> [] then
-          Xlist.fold frames_sem valence (fun valence frame ->
-            convert_frame_sem expands subtypes equivs lexemes valence lexeme pos frame)
-        else
-          let frames = match simplify_pos pos with
-              "verb" -> ((*try StringMap.find verb_frames lexeme with Not_found ->*) ["verb","","","","",""])
-            | "noun" -> ((*try StringMap.find noun_frames lexeme with Not_found ->*) if StringSet.mem empty_valence_lexemes lexeme then ["empty","","","","",""] else ["noun","","","","",""])
-            | "adj" -> ((*try StringMap.find adj_frames lexeme with Not_found ->*) if StringSet.mem empty_valence_lexemes lexeme then ["empty","","","","",""] else ["adj","","","","",""])
-            | "adv" -> ((*try StringMap.find adv_frames lexeme with Not_found ->*) ["adv","","","","",""])
-            | "pron" -> ["empty","","","","",""]
-            | "adjp" -> ["empty","","","","",""]
-            | "ordnum" -> ["empty","","","","",""]
-            | "symbol" -> ["empty","","","","",""]
-            | "date" -> ["date","","","","",""]
-            | "date-interval" -> ["empty","","","","",""]
-            | "hour" -> ["hour","","","","",""]
-            | "hour-minute" -> ["hour","","","","",""]
-            | "hour-interval" -> ["empty","","","","",""]
-            | "hour-minute-interval" -> ["empty","","","","",""]
-            | "year" -> ["empty","","","","",""]
-            | "year-interval" -> ["empty","","","","",""]
-            | "day" -> ["day","","","","",""]
-            | "day-interval" -> ["day","","","","",""]
-            | "day-month" -> ["date2","","","","",""]
-            | "day-month-interval" -> ["empty","","","","",""]
-            | "match-result" -> ["empty","","","","",""]
-            | "month-interval" -> ["empty","","","","",""]
-            | "roman" -> ["empty","","","","",""]
-            | "roman-interval" -> ["empty","","","","",""]
-            | "url" -> ["empty","","","","",""]
-            | "email" -> ["empty","","","","",""]
-            | "obj-id" -> ["empty","","","","",""]
-            | _ -> [] in
-(*          if frames = [] then valence else
-   Printf.printf "find_frame: %s |l|=%d\n" s (Xlist.size l); *)
-          Xlist.fold frames valence (fun valence frame ->
-            convert_frame expands subtypes equivs lexemes valence lexeme pos frame) in
-      Xlist.fold ((*try StringMap.find compreps lexeme with Not_found ->*) []) valence (fun valence (cpos,frame) -> (* FIXME: na razie przyimki złożone są wyłączone *)
-        if cpos = pos then convert_comprep_frame expands subtypes equivs lexemes valence lexeme pos frame else valence))) in
-(*   print_endline "find_frames 2"; *)
-  let valence = StringMap.mapi valence (fun lexeme poss ->
-    StringMap.mapi poss (fun pos frames ->
-      List.flatten (Xlist.map frames (fun frame ->
-(*         print_endline ("find_frames: " ^ ENIAMwalStringOf.frame lexeme frame); *)
-        expand_restr valence lexeme pos frame)))) in
-(*   print_endline "find_frames 3"; *)
-  let valence = StringMap.mapi valence (fun lexeme poss ->
-    StringMap.mapi poss (fun pos frames ->
-      reduce_frame_atrs_list pos lexemes (List.flatten (Xlist.map frames (transform_frame lexeme pos))))) in
-(*  let valence = StringMap.mapi valence (fun lexeme poss ->
-    StringMap.mapi poss (fun pos frames ->
-      Xlist.map frames (assign_thematic_role pos))) in*)
-(*  StringMap.iter valence (fun lexeme poss ->
-    StringMap.iter poss (fun pos frames ->
-      Xlist.iter frames (fun frame -> print_endline (ENIAMwalStringOf.frame lexeme frame))));*)
-(*   print_endline "find_frames 4"; *)
-  valence
  
 (*let _ =
   let valence = Xlist.fold all_frames StringMap.empty (fun valence (pos,frame_map) ->
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -156,7 +156,7 @@ let parse_negation = function
   (* | [Text ""] -> NegationNA *)
   | l -> failwith ("parse_negation: " ^ string_of_token_list l)
  
-let parse_refl = function
+(* let parse_refl = function
       (* [] -> ReflEmpty
     | [Text "się"] -> ReflSie
     | [Text ""] -> ReflEmpty
@@ -164,7 +164,7 @@ let parse_refl = function
     | [Text "true"] -> ReflSie *)
   | [Text "nosię"] -> ReflFalse
   | [Text "się"] -> ReflTrue
-  | l -> failwith ("parse_refl: " ^ string_of_token_list l)
+  | l -> failwith ("parse_refl: " ^ string_of_token_list l) *)
  
 let parse_ctype = function
     [Text "int"] -> Int
@@ -172,11 +172,11 @@ let parse_ctype = function
   | [Text "_"] -> CompTypeUndef
   | l -> failwith ("parse_ctype: " ^ string_of_token_list l)
  
-let parse_acm = function
+(* let parse_acm = function
     (* [Text "int"] -> Int
   | [Text "rel"] -> Rel *)
   | [Text "_"] -> AcmUndef
-  | l -> failwith ("parse_acm: " ^ string_of_token_list l)
+  | l -> failwith ("parse_acm: " ^ string_of_token_list l) *)
  
 let parse_comp = function
     | [Text "co"] -> Comp "co" (* subst qub prep comp *)
@@ -234,17 +234,17 @@ let parse_pos = function
   | "PPRON3",[number;case] -> PPRON3(parse_number number,parse_case case)
   | "SIEBIE",[case] -> SIEBIE(parse_case case)
   | "PREP",[case] -> PREP(parse_case case)
-  | "NUM",[case;gender;acm] -> NUM(parse_case case,parse_gender gender,parse_acm acm)
+  | "NUM",[case;gender] -> NUM(parse_case case,parse_gender gender)
   | "ADJ",[number;case;gender;grad] -> ADJ(parse_number number,parse_case case,parse_gender gender,parse_grad grad)
   | "ADV",[grad] -> ADV(parse_grad grad)
-  | "GER",[number;case;gender;aspect;negation;refl] -> GER(parse_number number,parse_case case,parse_gender gender,parse_aspect aspect,parse_negation negation,parse_refl refl)
+  | "GER",[number;case;gender;aspect;negation] -> GER(parse_number number,parse_case case,parse_gender gender,parse_aspect aspect,parse_negation negation)
   | "PPAS",[number;case;gender;aspect;negation] -> PPAS(parse_number number,parse_case case,parse_gender gender,parse_aspect aspect,parse_negation negation)
-  | "PACT",[number;case;gender;aspect;negation;refl] -> PACT(parse_number number,parse_case case,parse_gender gender,parse_aspect aspect,parse_negation negation,parse_refl refl)
-  | "INF",[aspect;negation;refl] -> INF(parse_aspect aspect,parse_negation negation,parse_refl refl)
+  | "PACT",[number;case;gender;aspect;negation] -> PACT(parse_number number,parse_case case,parse_gender gender,parse_aspect aspect,parse_negation negation)
+  | "INF",[aspect;negation] -> INF(parse_aspect aspect,parse_negation negation)
   | "QUB",[] -> QUB
-  | "COMPAR",[] -> COMPAR
+  | "COMPAR",[] -> COMPAR Str
   | "COMP",[ctype] -> COMP(parse_ctype ctype)
-  | "PERS",[negation;refl] -> PERS(parse_negation negation,parse_refl refl)
+  | "PERS",[negation] -> PERS(parse_negation negation)
   | s,ll -> failwith ("parse_pos: " ^ s ^ "(" ^ String.concat "," (Xlist.map ll string_of_token_list) ^ ")")
  
 let rec parse_phrase = function
@@ -253,7 +253,7 @@ let rec parse_phrase = function
   | "adjp",[case] -> AdjP(parse_case case)
   | "prepadjp",[[Text prep]; case] -> PrepAdjP(prep,parse_case case)
   | "comprepnp",[[Text prep]] -> ComprepNP prep
-  | "comparp",[[Text prep]] -> ComparP prep
+  | "comparp",[[Text prep]] -> ComparP(prep,Str)
   | "cp",[ctype;comp] -> CP(parse_ctype ctype,parse_comp comp)
   | "ncp",[case;ctype;comp] -> NCP(parse_case case,parse_ctype ctype,parse_comp comp)
   | "prepncp",[[Text prep];case;ctype;comp] -> PrepNCP(prep,parse_case case,parse_ctype ctype,parse_comp comp)
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -24,7 +24,7 @@ let create_phrase_reqs s (reqs,noreqs) = function
   | PrepNP(prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepAdjP(prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepNCP(prep,_,_,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
-  | ComparP(prep) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
+  | ComparP(prep,_) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | FixedP(prep) -> StringMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | SimpleLexArg(lex,_) -> StringMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
   | LexArg(_,lex,_) -> StringMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
@@ -35,7 +35,7 @@ let create_phrase_reqs2 s (reqs,noreqs) = function
   | PrepNP(prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepAdjP(prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | PrepNCP(prep,_,_,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
-  | ComparP(prep) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
+  | ComparP(prep,_) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | FixedP(prep) -> IntMap.add_inc reqs s (StringSet.singleton prep) (fun set -> StringSet.add set prep), noreqs
   | SimpleLexArg(lex,_) -> IntMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
   | LexArg(_,lex,_) -> IntMap.add_inc reqs s (StringSet.singleton lex) (fun set -> StringSet.add set lex), noreqs
@@ -105,7 +105,7 @@ let reduce_phrase (test_comprep_reqs,test_comprep_reqs2,test_lexarg_reqs,test_le
   | PrepNP(prep,case) as phrase -> if test_lexemes prep then phrase else raise Not_found
   | PrepAdjP(prep,case) as phrase -> if test_lexemes prep then phrase else raise Not_found
   | ComprepNP(prep) as phrase  -> if test_comprep_reqs prep && test_comprep_reqs2 prep then phrase else raise Not_found
-  | ComparP(prep) as phrase  -> if test_lexemes prep then phrase else raise Not_found
+  | ComparP(prep,case) as phrase  -> if test_lexemes prep then phrase else raise Not_found
   | CP(ctype,comp) -> CP(ctype,reduce_comp test_lexemes comp)
   | NCP(case,ctype,comp) -> if test_lexemes "to" then NCP(case,ctype,reduce_comp test_lexemes comp) else raise Not_found
   | PrepNCP(prep,case,ctype,comp) -> if test_lexemes prep && test_lexemes "to" then PrepNCP(prep,case,ctype,reduce_comp test_lexemes comp) else raise Not_found
@@ -204,7 +204,10 @@ let entries,schemata,connected =
    - usunięcie adjunctów
    - uwzględnienie cech morfoskładniowych
    - scalenie schematów
-   - dodanie adjunctów
+   - dodanie adjunctów - pamiętać o padvp
+*)
+(* TODO
+   - leksykalizacje bez schema
 *)
  
 (* let _ =
 (*
- *  ENIAMwalenty, a converter for Polish Valence Dictionary "Walenty".
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
  *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
  *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
@@ -55,11 +55,11 @@ let case = function
   | Part -> "part"
   | CaseAgr -> "agr"
   (* | CaseUAgr -> "uagr"
-  | NomAgr -> "nomagr"
-  | GenAgr -> "genagr"
-  | AllAgr -> "allagr"
   | AllUAgr -> "alluagr" *)
   | CaseUndef -> "_"
+  | AllAgr -> "allagr"
+  | NomAgr -> "nomagr"
+  | GenAgr -> "genagr"
  
 let rec comp = function
     Comp s -> s
@@ -87,15 +87,15 @@ let grad = function
     Grad s -> s
   | GradUndef -> "_"
  
-let refl = function
+(* let refl = function
     (* ReflEmpty -> "" *)
   | ReflTrue -> "się"
   | ReflFalse -> "nosię"
-  | ReflUndef -> "_"
+  | ReflUndef -> "_" *)
  
-let acm = function
+(* let acm = function
     Acm s -> s
-  | AcmUndef -> "_"
+  | AcmUndef -> "_" *)
  
 let gf = function
     SUBJ -> "subj"
@@ -108,17 +108,17 @@ let pos = function
   | PPRON3(n,c) -> "PPRON3(" ^ number n ^ "," ^ case c ^ ")"
   | SIEBIE(c) -> "SIEBIE(" ^ case c ^ ")"
   | PREP(c) -> "PREP(" ^ case c ^ ")"
-  | NUM(c,g,a) -> "NUM(" ^ case c ^ "," ^ gender g ^ "," ^ acm a ^ ")"
+  | NUM(c,g) -> "NUM(" ^ case c ^ "," ^ gender g ^ ")"
   | ADJ(n,c,g,gr) -> "ADJ(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ grad gr ^ ")"
   | ADV(gr) -> "ADV(" ^ grad gr ^ ")"
-  | GER(n,c,g,a,neg,r) -> "GER(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ "," ^ refl r ^ ")"
-  | PACT(n,c,g,a,neg,r) -> "PACT(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ "," ^ refl r ^ ")"
+  | GER(n,c,g,a,neg) -> "GER(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ ")"
+  | PACT(n,c,g,a,neg) -> "PACT(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ ")"
   | PPAS(n,c,g,a,neg) -> "PPAS(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ ")"
-  | INF(a,n,r) -> "INF(" ^ aspect a ^ "," ^ negation n ^ "," ^ refl r ^ ")"
+  | INF(a,n) -> "INF(" ^ aspect a ^ "," ^ negation n ^ ")"
   | QUB -> "QUB"
-  | COMPAR -> "COMPAR"
+  | COMPAR c -> "COMPAR(" ^ case c ^ ")"
   | COMP(c) -> "COMP(" ^ comp_type c ^ ")"
-  | PERS(n,r) -> "PERS(" ^ negation n ^ "," ^ refl r ^ ")"
+  | PERS(n) -> "PERS(" ^ negation n ^ ")"
   | FIXED -> "FIXED"
  
 let rec phrase = function
@@ -129,7 +129,7 @@ let rec phrase = function
   (* | NumP(c) -> "nump(" ^ case c ^ ")"
   | PrepNumP(prep,c) -> "prepnump(" ^ prep ^ "," ^ case c ^ ")" *)
   | ComprepNP(prep) -> "comprepnp(" ^ prep ^ ")"
-  | ComparP(prep) -> "comparp(" ^ prep ^ ")"
+  | ComparP(prep,c) -> "comparp(" ^ prep ^ "," ^ case c ^ ")"
   | CP(ct,co) -> "cp(" ^ comp_type ct ^ "," ^ comp co ^ ")"
   | NCP(c,ct,co) -> "ncp(" ^ case c ^ "," ^ comp_type ct ^ "," ^ comp co ^ ")"
   | PrepNCP(prep,c,ct,co) -> "prepncp(" ^ prep ^ "," ^ case c ^ "," ^ comp_type ct ^ "," ^ comp co ^ ")"
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -24,14 +24,14 @@ type opinion = Pewny | Potoczny | Watpliwy | Archaiczny | Zly | Wulgarny | Nieok
 type negation = Negation | Aff | NegationUndef (*| NegationNA*)
 type pred = PredTrue | PredFalse | PredUndef (*| PredNA*)
 type aspect = Aspect of string | AspectUndef (*| AspectNA*)
-type case = Case of string | Str | Part | CaseAgr (*| NomAgr | GenAgr | AllAgr*) | CaseUndef (*| AllUAgr | CaseUAgr*)
+type case = Case of string | Str | Part | CaseAgr | CaseUndef (*| AllUAgr | CaseUAgr*) | GenAgr | NomAgr | AllAgr
 type comp = Comp of string | Zeby | Gdy | CompUndef
 type comp_type = Int | Rel | CompTypeUndef (*| CompTypeAgr*)
 type number = Number of string | NumberUndef | NumberAgr
 type gender = Gender of string | GenderUndef | GenderAgr | Genders of string list
 type grad = Grad of string | GradUndef
-type refl = (*ReflEmpty |*) ReflTrue | ReflFalse | ReflUndef
-type acm = Acm of string | AcmUndef
+(* type refl = (*ReflEmpty |*) ReflTrue | ReflFalse | ReflUndef *)
+(* type acm = Acm of string | AcmUndef *)
  
 (*type mood = (*Mood of*) string (*| MoodUndef*)
 type tense = string
@@ -47,17 +47,17 @@ type pos =
   | PPRON3 of number * case
   | SIEBIE of case
   | PREP of case
-  | NUM of case * gender * acm
+  | NUM of case * gender
   | ADJ of number * case * gender * grad
   | ADV of grad
-  | GER of number * case * gender * aspect * negation * refl
-  | PACT of number * case * gender * aspect * negation * refl
+  | GER of number * case * gender * aspect * negation
+  | PACT of number * case * gender * aspect * negation
   | PPAS of number * case * gender * aspect * negation
-  | INF of aspect * negation * refl
+  | INF of aspect * negation
   | QUB
-  | COMPAR
+  | COMPAR of case
   | COMP of comp_type
-  | PERS of (*number * gender * aspect * person * *)negation * refl
+  | PERS of (*number * gender * aspect * person * *)negation
   | FIXED
  
 type phrase =
@@ -68,7 +68,7 @@ type phrase =
   (* | NumP of case
   | PrepNumP of string * case *)
   | ComprepNP of string
-  | ComparP of string (** case*)
+  | ComparP of string * case
   | CP of comp_type * comp
   | NCP of case * comp_type * comp
   | PrepNCP of string * case * comp_type * comp
@@ -128,8 +128,8 @@ let empty_meaning = {mng_id = (-1);
   | GerAtrs of meaning list * string * negation * aspect
   | NonPersAtrs of meaning list * string * string * string * negation * aspect *)
  
-type schema = {sch_id: int; opinion: opinion; reflexiveMark: refl; aspect: aspect;
-               negativity: negation; predicativity: pred; positions: position list; text_rep: string}
+(* type schema = {sch_id: int; opinion: opinion; reflexiveMark: refl; aspect: aspect;
+               negativity: negation; predicativity: pred; positions: position list; text_rep: string} *)
  
 type lex_entry =
     (* Frame of frame_atrs * position list *)
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -2,8 +2,7 @@ ENIAMsemValence Version 1.0 :
 -----------------------
  
 ENIAMsemValence is a library that assigns tokens with lexicosemantic information.
-It recognizes named entities and assigns thematic roles,
-senses, valence and other semantic information to tokens.
+It assigns thematic roles, word senses, valence and other semantic information to tokens.
  
 Install
 -------
@@ -3,3 +3,56 @@
 - sprawdzić czy walencja nazw własnych jest dobrze zrobiona.
 - trzeba zrobić słownik nazw własnych
 - trzeba poprawić selekcję preferencji selecyjnych: jeśli podrzędnikiem jest zaimek nie muszą jawnie występować wśród sensów.
+
+- błędy w realizacjach
+xp(abl[prepadjp(z,gen)]
+na korzyść - na niekorzyść
+xp(mod[prepnp(jako,str)]) -> xp(mod[compar(jako)])
+xp(mod[prepadjp(jako,str)]) -> xp(mod[compar(jako)])
+na sposób - zgłoszone
+
+cyrk advp(misc) [54480]
+banalnie - pred
+subst	woda	lex(880,woda,subst)	{lex(święcony,ADJ(agr,gen,agr,pos))}
+
+uciąć: pewny: _: : perf: subj{np(str)} + obj{lex(np(str),sg,'gałąź',ratr1({lex(cp(rel[który]),aff,'siedzieć',,ratr(subj{np(str)}+{lex(adjp(agr),agr,agr,pos,'sam',natr)}+{lex(prepadjp(na,loc),sg,f,pos,'który',natr)}))}))}
+
+np(str) -> adjp(agr)
+przychodzić: pewny: _: : imperf: subj{lex(np(str),sg,'godzina',ratr1({lex(np(str),agr,'zły',natr)}))} + {prepnp(na,acc)}
+
+Czym jest podmiot podniesiony w poniższych ramach i jak się zachowuje w stronie biernej?
+obladzać: pewny: _: : imperf: subj{E} + obj{np(str)} + {np(dat)}
+oblodzić: pewny: _: : perf: subj{E} + obj{np(str)} + {np(dat)}
+
+Czy 'zły' nie powinien być tu przymiotnikiem?
+przychodzić: pewny: _: : imperf: subj{lex(np(str),sg,'godzina',ratr1({lex(np(str),agr,'zły',natr)}))} + {prepnp(na,acc)}
+przyjść: pewny: _: : perf: subj{lex(np(str),sg,'godzina',ratr1({lex(np(str),agr,'zły',natr)}))} + {prepnp(na,acc)}
+
+Czy zamiast adjp(str) -> adjp(agr)
+kreślić: pewny: _: : imperf: subj{np(str)} + obj{np(str)} + {lex(np(inst),pl,XOR('barwa','kolor'),ratr({adjp(str)}))}
+malować: pewny: _: : imperf: subj{np(str)} + obj{np(str)} + {lex(np(inst),pl,XOR('barwa','kolor'),ratr({adjp(str)}))}
+namalować: pewny: _: : perf: subj{np(str)} + obj{np(str)} + {lex(np(inst),pl,XOR('barwa','kolor'),ratr({adjp(str)}))}
+odmalować: pewny: _: : perf: subj{np(str)} + obj{np(str)} + {lex(np(inst),pl,XOR('barwa','kolor'),ratr({adjp(str)}))}
+odmalowywać: pewny: _: : imperf: subj{np(str)} + obj{np(str)} + {lex(np(inst),pl,XOR('barwa','kolor'),ratr({adjp(str)}))}
+zajrzeć: pewny: _: : perf: subj{lex(np(str),sg,XOR('bieda','głód','nędza','śmierć'),atr({adjp(str)}))} + {np(dat)} + {lex(prepnp(w,acc),pl,'oko',natr)}
+chwycić: pewny: _: : perf: subj{np(str)} + {lex(np(inst),pl,'usta',atr({adjp(str)}))} + {lex(np(str),sg,'powietrze',atr({adjp(agr)}))}
+chwytać: pewny: _: : imperf: subj{np(str)} + {lex(np(inst),pl,'usta',atr({adjp(str)}))} + {lex(np(str),sg,'powietrze',atr({adjp(agr)}))}
+łapać: pewny: _: : imperf: subj{np(str)} + obj{lex(np(str),sg,'powietrze',atr({adjp(agr)}))} + {lex(np(inst),pl,'usta',atr({adjp(str)}))}
+złapać: pewny: _: : perf: subj{np(str)} + obj{lex(np(str),sg,'powietrze',atr({adjp(agr)}))} + {lex(np(inst),pl,'usta',atr({adjp(str)}))}
+
+
+Jak się zachowuje podmiot zdaniowy w stronie biernej? - o to już pytałem
+podciąć: pewny: _: : perf: subj{cp(gdy)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+podciąć: pewny: _: : perf: subj{cp(jak)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+podciąć: pewny: _: : perf: subj{cp(kiedy)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+podcinać: pewny: _: : imperf: subj{cp(gdy)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+podcinać: pewny: _: : imperf: subj{cp(jak)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+podcinać: pewny: _: : imperf: subj{cp(kiedy)} + obj{lex(np(str),pl,'skrzydło',natr)} + {np(dat)}
+sprawiać: pewny: _: : imperf: subj{np(str);cp(że);ncp(str,że)} + obj{np(str)} + {np(dat)}
+sprawić: pewny: _: : perf: subj{np(str);cp(że);ncp(str,że)} + obj{np(str)} + {np(dat)}
+zaskakiwać: pewny: _: : imperf: subj{np(str);cp(int);cp(że);ncp(str,int);ncp(str,że)} + obj{np(str)}
+zaskoczyć: pewny: _: : perf: subj{np(str);cp(int);cp(że);ncp(str,int);ncp(str,że)} + obj{np(str)}
+zwracać: pewny: _: : imperf: subj{cp(int)} + obj{lex(np(str),sg,'uwaga',atr({possp}))}
+zwracać: pewny: _: : imperf: subj{cp(że)} + obj{lex(np(str),sg,'uwaga',atr({possp}))}
+zwrócić: pewny: _: : perf: subj{cp(int)} + obj{lex(np(str),sg,'uwaga',atr({possp}))}
+zwrócić: pewny: _: : perf: subj{cp(że)} + obj{lex(np(str),sg,'uwaga',atr({possp}))}
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -3,7 +3,7 @@ OCAMLOPT=ocamlopt
 OCAMLDEP=ocamldep
 INCLUDES=-I +xml-light -I +xlib -I +zip -I +bz2 -I +eniam
 OCAMLFLAGS=$(INCLUDES) -g
-OCAMLOPTFLAGS=$(INCLUDES) unix.cmxa xml-light.cmxa str.cmxa nums.cmxa zip.cmxa bz2.cmxa xlib.cmxa #eniam-tokenizer.cmxa eniam-morphology.cmxa eniam-subsyntax.cmxa eniam-plWordnet.cmxa eniam-lcg-parser.cmxa #eniam-lcg-grammar-pl.cmxa #eniam-lexSemantics.cmxa
+OCAMLOPTFLAGS=$(INCLUDES) unix.cmxa xml-light.cmxa str.cmxa nums.cmxa zip.cmxa bz2.cmxa xlib.cmxa eniam-lcg-parser.cmxa eniam-lcg-lexicon.cmxa #eniam-tokenizer.cmxa eniam-morphology.cmxa eniam-subsyntax.cmxa eniam-plWordnet.cmxa #eniam-lexSemantics.cmxa
 INSTALLDIR=`ocamlc -where`/eniam
  
 SOURCES= ENIAMlexSemanticsTypes.ml ENIAMcategories.ml ENIAMlexSemanticsData.ml ENIAMlexSemantics.ml
@@ -28,8 +28,8 @@ eniam-lexSemantics.cmxa: $(SOURCES)
  
 # test: test.ml
 # 	$(OCAMLOPT) -o test $(OCAMLOPTFLAGS) test.ml
-test: entries.ml ENIAMwalTypes.ml ENIAMwalStringOf.ml ENIAMwalParser.ml ENIAMwalReduce.ml test.ml
-	$(OCAMLOPT) -o test $(OCAMLOPTFLAGS) entries.ml ENIAMwalTypes.ml ENIAMwalStringOf.ml ENIAMwalParser.ml ENIAMwalReduce.ml test.ml
+test: entries.ml ENIAMwalTypes.ml ENIAMwalStringOf.ml ENIAMwalParser.ml ENIAMwalReduce.ml ENIAMvalence.ml test.ml
+	$(OCAMLOPT) -o test $(OCAMLOPTFLAGS) entries.ml ENIAMwalTypes.ml ENIAMwalStringOf.ml ENIAMwalParser.ml ENIAMwalReduce.ml ENIAMvalence.ml test.ml
  
  
 .SUFFIXES: .mll .mly .ml .mli .cmo .cmi .cmx
 (*
  *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
 (*
- *  ENIAMwalenty, an interface for Polish Valence Dictionary "Walenty".
- *  Copyright (C) 2016 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
- *  Copyright (C) 2016 Institute of Computer Science Polish Academy of Sciences
+ *  ENIAMlexSemantics is a library that assigns tokens with lexicosemantic information.
+ *  Copyright (C) 2016-2017 Wojciech Jaworski <wjaworski atSPAMfree mimuw dot edu dot pl>
+ *  Copyright (C) 2016-2017 Institute of Computer Science Polish Academy of Sciences
  *
  *  This library is free software: you can redistribute it and/or modify
  *  it under the terms of the GNU Lesser General Public License as published by
@@ -4,6 +4,7 @@ ENIAMsubsyntax Version 1.1 :
 ENIAMsubsyntax is a library that
 - performs tokenization, lemmatization, part of speech tagging;
 - detects MWE and abbreviations;
+- recognizes named entities;
 - splits text into sentences.
  
 Install
@@ -72,7 +72,7 @@ let connect entry =
           let phrases = process_morfs position.morfs in
           let morfs = Xlist.fold phrase_ids [] (fun morfs phrase_id ->
               try IntMap.find phrases phrase_id :: morfs
-              with Not_found -> Printf.printf "%s\n%!" entry.form_orth;morfs) in
+              with Not_found -> if entry.form_orth <> "podobać" then Printf.printf "connect: %s\n%!" entry.form_orth;morfs) in
           {position with role=arg.role; role_attr=arg.role_attribute; sel_prefs=sel_prefs;
                          morfs=List.rev morfs} :: conn_positions)) in
     (* let meanings = List.rev (Xlist.rev_map frame.meanings (fun id ->
@@ -20,8 +20,19 @@
 open ENIAMwalTypes
 open Xstd
  
+let correct_walenty entry =
+  if entry.form_orth = "podobać" then
+    {entry with schemata=Xlist.map entry.schemata (fun s ->
+         {s with positions=Xlist.map s.positions (fun p ->
+              if p.gf=SUBJ then {p with morfs=List.flatten (Xlist.map p.morfs (function
+                    MorfId 126 -> []
+                  | m -> [m]))}
+              else p)})}
+  else entry
+
 let load_walenty walenty_filename expands_filename =
   let walenty,phrases = ENIAMwalTEI.load_walenty walenty_filename in
+  let walenty = Xlist.rev_map walenty correct_walenty in
   let expands = ENIAMwalTEI.load_expands expands_filename in
   let meanings =
     Xlist.fold walenty IntMap.empty (fun meanings entry ->
@@ -41,6 +41,39 @@ let rec split_elexeme = function
     genders,[ORcoord(List.rev l)]
   | Elexeme gender -> [gender],[]
  
+let rec get_lexemes = function
+    Lexeme s -> [s]
+  | ORconcat l -> List.flatten (Xlist.map l get_lexemes)
+  | ORcoord l -> List.flatten (Xlist.map l get_lexemes)
+  | XOR l -> List.flatten (Xlist.map l get_lexemes)
+  | Elexeme gender -> failwith "get_lexemes"
+
+let rec remove_list set = function
+    [] -> []
+  | s :: l -> if Xlist.mem set s then remove_list set l else s :: (remove_list set l)
+
+let rec check_lexemes_morfs l = function
+    LexPhrase(lexs,(_,schema)) ->
+              let l = Xlist.fold lexs l (fun l (_,lex) ->
+                  remove_list (get_lexemes lex) l) in
+              check_lexemes_schema l schema
+  | _ -> l
+
+and check_lexemes_schema l schema =
+  Xlist.fold schema l (fun l s ->
+      Xlist.fold s.morfs l check_lexemes_morfs)
+
+let add_refl_restr (restr,schema) =
+    (match restr with
+      Natr -> Ratr
+    | Atr1 -> Atr
+    | Atr -> Atr
+    | Ratr1 -> Ratr
+    | Ratr -> Ratr
+    | Ratrs -> Ratrs
+    | NoRestr -> failwith "add_refl_restr"),
+    position [LexPhrase([QUB,Lexeme "się"],(Natr,[]))] :: schema
+
 let rec expand_lexicalizations_schema schema =
   Xlist.map schema (fun s ->
       {s with morfs=expand_lexicalizations_morfs s.morfs})
@@ -51,15 +84,7 @@ and expand_lexicalizations_morfs morfs = (* uproszczenie polegające na zezwolen
           LexPhrase(pos_lex,(restr,schema)) -> LexPhrase(pos_lex,(restr,expand_lexicalizations_schema schema))
         | morf -> morf in
       match morf with
-      (*         LexPhrase([ADV _,_],(_,_::_)) -> print_endline (ENIAMwalStringOf.morf morf); [morf] *)
-      (*       | LexPhrase([PREP _,_;SUBST _,_],(_,schema)) -> if remove_trivial_args schema <> [] then print_endline (ENIAMwalStringOf.morf morf); [morf] *)
-      (*       | LexPhrase([PREP _,_;GER _,_],(_,schema)) -> if remove_trivial_args schema <> [] then print_endline (ENIAMwalStringOf.morf morf); [morf] *)
-      (*       | LexPhrase([NUM _,_;_],(_,schema)) -> if remove_trivial_args schema <> [] then print_endline (ENIAMwalStringOf.morf morf); [morf]  *)
-      (*       | LexPhrase([PREP _,_;NUM _,_;_],(_,schema)) -> if remove_trivial_args schema <> [] then print_endline (ENIAMwalStringOf.morf morf); [morf]  *)
-      (*      | LexPhrase([PREP _,_;ADJ _,_],(_,_::_)) -> print_endline (ENIAMwalStringOf.morf morf); [morf]
-              | LexPhrase([PREP _,_;PPAS _,_],(_,_::_)) -> print_endline (ENIAMwalStringOf.morf morf); [morf]
-              | LexPhrase([PREP _,_;PACT _,_],(_,_::_)) -> print_endline (ENIAMwalStringOf.morf morf); [morf] *)
-      (* | Phrase(PrepNumP(prep,case)) -> [LexPhrase([PREP case,Lexeme prep],(Ratrs,[position(*2*) [Phrase(NumP(case))]]))] *)
+(* | Phrase(PrepNumP(prep,case)) -> [LexPhrase([PREP case,Lexeme prep],(Ratrs,[position(*2*) [Phrase(NumP(case))]]))] *)
       | Phrase(PrepNumP(prep,case)) -> [Phrase(PrepNP(prep,case))] (* FIXME: celowe uproszczenie *)
       | LexPhrase([PREP pcase,plex;SUBST(n,c),slex],(Atr1,[{morfs=[LexPhrase([QUB,_],_)]} as s])) ->
         (*            print_endline (ENIAMwalStringOf.morf morf);  *)
@@ -74,62 +99,30 @@ and expand_lexicalizations_morfs morfs = (* uproszczenie polegające na zezwolen
         [LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([SUBST(n,c),slex],(Natr,[]))];s(*{s with dir=Backward}*)]))]
       | LexPhrase([PREP pcase,plex;pos,lex],restr) ->
         [LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([pos,lex],restr)]]))]
-      | LexPhrase([PREP pcase,plex;NUM(c,g,a),nlex;pos,lex],restr) ->
+      | LexPhrase([PREP pcase,plex;NUM(c,g),nlex;pos,lex],restr) ->
         let genders,lexs = split_elexeme lex in
         Xlist.map genders (fun gender ->
-            LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([NUM(c,gender,a),nlex],(Ratrs,[(*num*)position [Phrase Null(*Pro*)]]))]]))) @ (*FIXME*)
+            LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([NUM(c,gender),nlex],(Ratrs,[(*num*)position [Phrase Null(*Pro*)]]))]]))) @ (*FIXME*)
         Xlist.map lexs (fun lex ->
-            LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([NUM(c,g,a),nlex],(Ratrs,[(*num*)position [LexPhrase([pos,lex],restr)]]))]])))
-      | LexPhrase([NUM(c,g,a),nlex;pos,lex],restr) ->
+            LexPhrase([PREP pcase,plex],(Ratrs,[position [LexPhrase([NUM(c,g),nlex],(Ratrs,[(*num*)position [LexPhrase([pos,lex],restr)]]))]])))
+      | LexPhrase([NUM(c,g),nlex;pos,lex],restr) ->
         let genders,lexs = split_elexeme lex in
         Xlist.map genders (fun gender ->
-            LexPhrase([NUM(c,gender,a),nlex],(Ratrs,[(*num*)position [Phrase Null(*Pro*)]]))) @
+            LexPhrase([NUM(c,gender),nlex],(Ratrs,[(*num*)position [Phrase Null(*Pro*)]]))) @
         Xlist.map lexs (fun lex ->
-            LexPhrase([NUM(c,g,a),nlex],(Ratrs,[(*num*)position [LexPhrase([pos,lex],restr)]])))
+            LexPhrase([NUM(c,g),nlex],(Ratrs,[(*num*)position [LexPhrase([pos,lex],restr)]])))
+      | LexPhrase([INF(a,n),lex;QUB,Lexeme "się"],restr) -> [LexPhrase([INF(a,n),lex],add_refl_restr restr)]
+      | LexPhrase([COMP ctype,clex;pos,lex;QUB,Lexeme "się"],restr) ->
+        if Xlist.size (check_lexemes_schema (get_lexemes clex) (snd restr)) = 0 then
+          [LexPhrase([pos,lex],add_refl_restr restr)]
+        else [LexPhrase([COMP ctype,clex],(Ratrs,[(*std*)position (*Forward*) [LexPhrase([pos,lex],add_refl_restr restr)]]))]
       | LexPhrase([COMP ctype,clex;pos,lex],restr) ->
-        [LexPhrase([COMP ctype,clex],(Ratrs,[(*std*)position (*Forward*) [LexPhrase([pos,lex],restr)]]))]
-      | LexPhrase([SUBST(n,c),slex;COMP ctype,clex;pos,lex],restr) ->
-        [LexPhrase([SUBST(n,c),slex],(Ratrs,[(*std*)position (*Forward*) [LexPhrase([COMP ctype,clex],(Ratrs,[(*std*)position (*Forward*) [LexPhrase([pos,lex],restr)]]))]]))] (* FIXME: poprawić po zrobieniu NCP *)
+        if Xlist.size (check_lexemes_schema (get_lexemes clex) (snd restr)) = 0 then
+          [LexPhrase([pos,lex],restr)]
+        else [LexPhrase([COMP ctype,clex],(Ratrs,[(*std*)position (*Forward*) [LexPhrase([pos,lex],restr)]]))]
       | LexPhrase(_::_::_,_) -> failwith ("expand_lexicalizations_morfs: " ^ ENIAMwalStringOf.morf morf)
-      (*      | LexPhrase([PREP pcase,plex;SUBST(n,c),slex],(Atr1,[gf,cr,ce,[LexPhrase([QUB,lex],arestr)]])) ->
-              (*            print_endline (ENIAMwalStringOf.morf morf);  *)
-                 [LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([SUBST(n,c),slex],(Natr,[]))]]));
-                  LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([SUBST(n,c),slex],(Natr,[]))];gf,cr,ce,[LexPhrase([QUB,lex],arestr)]]))]
-              | LexPhrase([PREP(pcase),plex;SUBST(n,c),slex],(Atr1,[gf,cr,ce,[LexPhrase([ADV gr,lex],arestr)]])) ->
-              (*            print_endline (ENIAMwalStringOf.morf morf);  *)
-                 [LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([SUBST(n,c),slex],(Natr,[]))]]));
-                  LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([SUBST(n,c),slex],(Natr,[]))];gf,cr,ce,[LexPhrase([ADV gr,lex],arestr)]]))]
-              | LexPhrase([PREP pcase,plex;SUBST(n,c),slex],(Ratr1,[gf,cr,ce,[LexPhrase([ADV gr,lex],arestr)]])) ->
-              (*            print_endline (ENIAMwalStringOf.morf morf);  *)
-                 [LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([SUBST(n,c),slex],(Natr,[]))];gf,cr,ce,[LexPhrase([ADV gr,lex],arestr)]]))]
-              | LexPhrase([PREP pcase,plex;pos,lex],restr) ->
-                 [LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([pos,lex],restr)]]))]
-              | LexPhrase([PREP pcase,plex;NUM(c,g,a),nlex;pos,lex],restr) ->
-                 let genders,lexs = split_elexeme lex in
-                 Xlist.map genders (fun gender ->
-                   LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([NUM(c,gender,a),nlex],(Ratrs,[("OBJ","QUANT-ARG",["T"]),[],[],[Phrase Pro]]))]]))) @
-                 Xlist.map lexs (fun lex ->
-                   LexPhrase([PREP pcase,plex],(Ratrs,[("OBJ","Ref",["T"]),[],[],[LexPhrase([NUM(c,g,a),nlex],(Ratrs,[("OBJ","QUANT-ARG",["T"]),[],[],[LexPhrase([pos,lex],restr)]]))]])))
-              | LexPhrase([NUM(c,g,a),nlex;pos,lex],restr) ->
-                 let genders,lexs = split_elexeme lex in
-                 Xlist.map genders (fun gender ->
-                   LexPhrase([NUM(c,gender,a),nlex],(Ratrs,[("OBJ","QUANT-ARG",["T"]),[],[],[Phrase Pro]]))) @
-                 Xlist.map lexs (fun lex ->
-                   LexPhrase([NUM(c,g,a),nlex],(Ratrs,[("OBJ","QUANT-ARG",["T"]),[],[],[LexPhrase([pos,lex],restr)]])))
-              | LexPhrase([COMP ctype,clex;pos,lex],restr) ->
-                 [LexPhrase([COMP ctype,clex],(Ratrs,[("C","",["T"]),[],[],[LexPhrase([pos,lex],restr)]]))]
-              | LexPhrase([SUBST(n,c),slex;COMP ctype,clex;pos,lex],restr) ->
-                 [LexPhrase([SUBST(n,c),slex],(Ratrs,[("OBJ","",["T"]),[],[],[LexPhrase([COMP ctype,clex],(Ratrs,[("C","",["T"]),[],[],[LexPhrase([pos,lex],restr)]]))]]))]
-              | LexPhrase(_::_::_,_) -> failwith ("expand_lexicalizations_morfs: " ^ ENIAMwalStringOf.morf morf)*)
       | morf -> [morf]))
  
-let rec get_lexemes = function
-    Lexeme s -> [s]
-  | ORconcat l -> List.flatten (Xlist.map l get_lexemes)
-  | ORcoord l -> List.flatten (Xlist.map l get_lexemes)
-  | XOR l -> List.flatten (Xlist.map l get_lexemes)
-  | Elexeme gender -> failwith "get_lexemes"
-
 let winien = StringSet.of_list ["winien"; "rad"; "powinien"; "nierad"; "niekontent"; "kontent"; "gotów"]
 let pred = StringSet.of_list ["żal"; "śmiech"; "znać"; "wstyd"; "wolno"; "widać"; "wiadomo";
 "warto"; "trzeba"; "trza"; "słychać"; "szkoda"; "strach"; "stać"; "sposób"; "potrzeba"; "pora";
@@ -148,7 +141,11 @@ let get_pos lex = function
      | "się" -> ["qub"]
      | _ -> ["subst"])
   | PREP _ -> ["prep"]
-  | NUM _ -> ["num"]
+  | NUM _ ->
+    (try
+       let _ = int_of_string lex in
+       ["intnum"]
+     with _ -> ["num"])
   | ADV _ -> ["adv"]
   | ADJ _ -> ["adj"]
   | GER _ -> ["ger"]
@@ -93,9 +93,9 @@ let refl = function
   | ReflFalse -> "nosię"
   | ReflUndef -> "_"
  
-let acm = function
+(* let acm = function
     Acm s -> s
-  | AcmUndef -> "_"
+  | AcmUndef -> "_" *)
  
 let gf = function
     SUBJ -> "subj"
@@ -108,17 +108,17 @@ let pos = function
   | PPRON3(n,c) -> "PPRON3(" ^ number n ^ "," ^ case c ^ ")"
   | SIEBIE(c) -> "SIEBIE(" ^ case c ^ ")"
   | PREP(c) -> "PREP(" ^ case c ^ ")"
-  | NUM(c,g,a) -> "NUM(" ^ case c ^ "," ^ gender g ^ "," ^ acm a ^ ")"
+  | NUM(c,g) -> "NUM(" ^ case c ^ "," ^ gender g ^ (*"," ^ acm a ^*) ")"
   | ADJ(n,c,g,gr) -> "ADJ(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ grad gr ^ ")"
   | ADV(gr) -> "ADV(" ^ grad gr ^ ")"
-  | GER(n,c,g,a,neg,r) -> "GER(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ "," ^ refl r ^ ")"
-  | PACT(n,c,g,a,neg,r) -> "PACT(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ "," ^ refl r ^ ")"
+  | GER(n,c,g,a,neg) -> "GER(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg (*^ "," ^ refl r*) ^ ")"
+  | PACT(n,c,g,a,neg) -> "PACT(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg (*^ "," ^ refl r*) ^ ")"
   | PPAS(n,c,g,a,neg) -> "PPAS(" ^ number n ^ "," ^ case c ^ "," ^ gender g ^ "," ^ aspect a ^ "," ^ negation neg ^ ")"
-  | INF(a,n,r) -> "INF(" ^ aspect a ^ "," ^ negation n ^ "," ^ refl r ^ ")"
+  | INF(a,n) -> "INF(" ^ aspect a ^ "," ^ negation n (*^ "," ^ refl r*) ^ ")"
   | QUB -> "QUB"
   | COMPAR -> "COMPAR"
   | COMP(c) -> "COMP(" ^ comp_type c ^ ")"
-  | PERS(n,r) -> "PERS(" ^ negation n ^ "," ^ refl r ^ ")"
+  | PERS(n) -> "PERS(" ^ negation n ^ (*"," ^ refl r ^*) ")"
   | FIXED -> "FIXED"
  
 let phrase = function
@@ -136,7 +136,7 @@ let phrase = function
   | InfP(a) -> "infp(" ^ aspect a (*^ req r*) ^ ")"
   | AdvP -> "advp"
   | FixedP s -> "fixed(" ^ s ^ ")"
-  | Num(c,a) -> "num(" ^ case c ^ "," ^ acm a ^ ")"
+  (* | Num(c,a) -> "num(" ^ case c ^ "," ^ acm a ^ ")" *)
   | Or -> "or"
   | Qub -> "qub"
   (* | Pro -> "pro"
@@ -225,11 +225,14 @@ let process_lex_phrase lemma = function
   | PrepNP(prep,case),number,GenderUndef,GradUndef,NegationUndef,ReflUndef -> [PREP case,Lexeme prep;SUBST(number,case),lemma]
   | AdjP(case),number,gender,grad,NegationUndef,ReflUndef -> [ADJ(number,case,gender,grad),lemma]
   | PrepAdjP(prep,case),number,gender,grad,NegationUndef,ReflUndef -> [PREP case,Lexeme prep;ADJ(number,case,gender,grad),lemma]
-  | InfP(aspect),NumberUndef,GenderUndef,GradUndef,negation,refl -> [INF(aspect,negation,refl),lemma]
+  | InfP(aspect),NumberUndef,GenderUndef,GradUndef,negation,ReflTrue -> [INF(aspect,negation),lemma;QUB,Lexeme "się"]
+  | InfP(aspect),NumberUndef,GenderUndef,GradUndef,negation,refl -> [INF(aspect,negation),lemma]
   | PpasP(case),number,gender,GradUndef,negation,ReflUndef -> [PPAS(number,case,gender,AspectUndef,negation),lemma]
   | PrepPpasP(prep,case),number,gender,GradUndef,negation,ReflUndef -> [PREP case,Lexeme prep;PPAS(number,case,gender,AspectUndef,negation),lemma]
-  | PactP(case),number,gender,GradUndef,negation,refl -> [PACT(number,case,gender,AspectUndef,negation,refl),lemma]
-  | PrepGerP(prep,case),number,GenderUndef,GradUndef,negation,refl -> [PREP case,Lexeme prep;GER(number,case,GenderUndef,AspectUndef,negation,refl),lemma]
+  | PactP(case),number,gender,GradUndef,negation,ReflTrue -> [PACT(number,case,gender,AspectUndef,negation),lemma;QUB,Lexeme "się"]
+  | PactP(case),number,gender,GradUndef,negation,refl -> [PACT(number,case,gender,AspectUndef,negation),lemma]
+  | PrepGerP(prep,case),number,GenderUndef,GradUndef,negation,ReflTrue -> [PREP case,Lexeme prep;GER(number,case,GenderUndef,AspectUndef,negation),lemma;QUB,Lexeme "się"]
+  | PrepGerP(prep,case),number,GenderUndef,GradUndef,negation,refl -> [PREP case,Lexeme prep;GER(number,case,GenderUndef,AspectUndef,negation),lemma]
   | Qub,NumberUndef,GenderUndef,GradUndef,NegationUndef,ReflUndef -> [QUB,lemma]
   | AdvP,NumberUndef,GenderUndef,grad,NegationUndef,ReflUndef -> [ADV grad,lemma]
   | phrase,number,gender,grad,negation,reflex ->
@@ -248,10 +251,14 @@ let rec process_lex lex = function
   | PhraseAbbr(Advp mode,[]),[],lemma,Lexeme ""  ->
     let poss = process_lex_phrase lemma (AdvP,lex.lex_number,lex.lex_gender,lex.lex_degree,lex.lex_negation,lex.lex_reflex) in
     LexPhrase(poss,lex.lex_modification)
-  | Phrase (NumP(case)),[],lemma,num_lemma -> LexPhrase([NUM(case,GenderUndef,AcmUndef),num_lemma;SUBST(NumberUndef,CaseUndef),lemma],lex.lex_modification)
-  | Phrase (PrepNumP(prep,case)),[],lemma,num_lemma  -> LexPhrase([PREP case,Lexeme prep;NUM(case,GenderUndef,AcmUndef),num_lemma;SUBST(NumberUndef,CaseUndef),lemma],lex.lex_modification)
-  | PhraseComp(Cp,(ctype,[Comp comp])),[],lemma,Lexeme "" -> LexPhrase([COMP ctype,Lexeme comp;PERS(lex.lex_negation,lex.lex_reflex),lemma],lex.lex_modification)
-  | PhraseComp(Cp,(ctype,[Comp comp1;Comp comp2])),[],lemma,Lexeme "" -> LexPhrase([COMP ctype,XOR[Lexeme comp1;Lexeme comp2];PERS(lex.lex_negation,lex.lex_reflex),lemma],lex.lex_modification)
+  | Phrase (NumP(case)),[],lemma,num_lemma -> LexPhrase([NUM(case,GenderUndef),num_lemma;SUBST(NumberUndef,CaseUndef),lemma],lex.lex_modification)
+  | Phrase (PrepNumP(prep,case)),[],lemma,num_lemma  -> LexPhrase([PREP case,Lexeme prep;NUM(case,GenderUndef),num_lemma;SUBST(NumberUndef,CaseUndef),lemma],lex.lex_modification)
+  | PhraseComp(Cp,(ctype,[Comp comp])),[],lemma,Lexeme "" ->
+    if lex.lex_reflex = ReflTrue then LexPhrase([COMP ctype,Lexeme comp;PERS(lex.lex_negation),lemma;QUB,Lexeme "się"],lex.lex_modification)
+        else LexPhrase([COMP ctype,Lexeme comp;PERS(lex.lex_negation),lemma],lex.lex_modification)
+  | PhraseComp(Cp,(ctype,[Comp comp1;Comp comp2])),[],lemma,Lexeme "" ->
+    if lex.lex_reflex = ReflTrue then LexPhrase([COMP ctype,XOR[Lexeme comp1;Lexeme comp2];PERS(lex.lex_negation),lemma;QUB,Lexeme "się"],lex.lex_modification)
+        else LexPhrase([COMP ctype,XOR[Lexeme comp1;Lexeme comp2];PERS(lex.lex_negation),lemma],lex.lex_modification)
   | Phrase phrase,[],lemma,Lexeme ""  ->
     let poss = process_lex_phrase lemma (phrase,lex.lex_number,lex.lex_gender,lex.lex_degree,lex.lex_negation,lex.lex_reflex) in
     LexPhrase(poss,lex.lex_modification)
@@ -31,7 +31,7 @@ type number = Number of string | NumberUndef | NumberAgr
 type gender = Gender of string | GenderUndef | GenderAgr | Genders of string list
 type grad = Grad of string | GradUndef
 type refl = ReflEmpty | ReflTrue | ReflFalse | ReflUndef
-type acm = Acm of string | AcmUndef
+(* type acm = Acm of string | AcmUndef *)
  
 type gf = SUBJ | OBJ | ARG
  
@@ -41,17 +41,17 @@ type pos =
   | PPRON3 of number * case
   | SIEBIE of case
   | PREP of case
-  | NUM of case * gender * acm
+  | NUM of case * gender (* acm*)
   | ADJ of number * case * gender * grad
   | ADV of grad
-  | GER of number * case * gender * aspect * negation * refl
-  | PACT of number * case * gender * aspect * negation * refl
+  | GER of number * case * gender * aspect * negation (** refl*)
+  | PACT of number * case * gender * aspect * negation (* refl*)
   | PPAS of number * case * gender * aspect * negation
-  | INF of aspect * negation * refl
+  | INF of aspect * negation (* refl*)
   | QUB
   | COMPAR
   | COMP of comp_type
-  | PERS of (*number * gender * aspect * person * *)negation * refl
+  | PERS of (*number * gender * aspect * person * *)negation (* refl*)
   | FIXED
  
 type phrase =
@@ -69,7 +69,7 @@ type phrase =
   | InfP of aspect
   | AdvP
   | FixedP of string
-  | Num of case * acm
+  (* | Num of case (* acm*) *)
   | Or
   | Qub
   (* | Pro