% -*- prolog -*-
%
% Gramatyka formalna języka polskiego — wersja 2
%
% Copyright © 2008–2016 by Marcin Woliński
%
% This program is free software; you can redistribute it and/or modify
% it under the terms of the GNU General Public License version 3 as
% published by the Free Software Foundation.
%
% This program 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 General Public License for more details.
%
% You should have received a copy of the GNU General Public License
% along with this program; if not, write to the Free Software
% Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 
% MA 02110-1301, USA 
%

:-op(550, xfy, '.').
:-style_check(-singleton).

% \section{Wstęp}
% \subsection{Jednostki nieterminalne}
%
% zdanie(Wf, A, C, T, R/L, O, Neg, Dest, I, Pk, Sub)
% ff(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub)
% fw(Tfw, A, C, R/L, O, Poz, Neg, Dest, I, Pk, Sub)
% fl(A, C, R/L, O, Neg, Dest, I, Pk, Sub)
%
% fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub)
% fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub)
% fpt(P, R/L, St, WymA, Kl, Zap, Neg, Dest, I, Pk, Sub)
% flicz(P, R/L, Akom, Zap, Dest, I, Pk, Sub)
% fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub)
% fpmpt(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub)
% fps(St, Kl, Neg, Dest, I, Pk, Sub)
% fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub)
%
% posiłk(Kl, R/L, Dest, I, Pk, Sub)
% modpart(Kl, Neg, Dest, I, Pk, Sub)
% przec(Pk,Sub)
% partykuła(H, Sub)
%
%
% \subsection{Parametry}
%
%
% \subsection{Kl (klasa)}
% – m.in.: nuzg, uzg (dla liczebników); rzecz, os, co, kto, 
% 					   który, jaki
% Predestynacja [Zk/Wsad (zakotwiczenie kontekstowe)] – neut, pyt, pz, wz(Tfz,RL), agl
% Zap (d. Tak) (zapowiednikowość)	– tk, tyle
% Sub	(nadrzędność)		– na, po
% Pk (przecinkowość)
% Poz (pozycja)			
%         post — fw stojąca po formie finitywnej i fno stanowiące jej centrum wszystkich poziomów 
%         pre — każda inna fw i fno
% 
%
% \subsection{Predestynacja (Dest)}
% obldest(Dest, Dest1, Dest2) (obliczenie predestynacji)
%

obldest(neut,neut,neut).
obldest(pyt,pyt,neut).
obldest(pyt,neut,pyt).
obldest(pyt,pyt,pyt).
obldest(pz,pz,pyt).
obldest(pz,pz,neut).
obldest(wz(Tfz,RL),wz(Tfz,RL),neut).

% Nowe sformułowanie warunku obldest:
% Postać potrzebna w warunkach iterowanych:

obldest_iter(Dest, Dest1, Dest) :- var(Dest1), !. % może przyjść z iteracji np. w noa1
obldest_iter(neut,neut,neut).
obldest_iter(neut,pyt,pyt).
obldest_iter(pyt,neut,pyt).
obldest_iter(pyt,pyt,pyt).
obldest_iter(wz(Tfz,RL),neut,wz(Tfz,RL)).
obldest_iter(pz,neut,pz).
obldest_iter(pz,pyt,pz).

% gdy jeden składnik — jego przecinkowość równa przecinkowości całości:
obldest(Dest, [Dest]) :- !.
% gdy więcej — sprawdzamy zgodność pierwszych dwóch składników i
% sprowadzamy rzecz do sprawdzenia dla listy o jeden krótszej:
obldest(Dest, [Dest0, Dest1 | Destn]) :-
	obldest_iter(Dest0, Dest1, Dest2),
	obldest(Dest, [Dest2 | Destn]).

% Następujący warunek służy do ograniczania wartości predestynacji
% tylko do neutralnej lub pytajnej.  Przyłożony do predestynacji
% pierwszego składnika w połączeniu z obldest wyklucza wynikową
% predestynację względną lub pytajnozależną (np. w konstrukcjach
% równorzędnych):

tylko_neut_pyt(neut).
tylko_neut_pyt(pyt).

% oblzap(Zap, Zap1, Zap2) obliczenie zapowiednika
% 
% Spełniony, gdy (równe(Zap1, tk.tyle) lub równe(Zap2, tk.tyle)) i
% równe(Zap, Zap1.Zap2)

oblzap_iter(bzap,bzap,bzap).
oblzap_iter(bzap,Zap,Zap1) :- nonvar(Zap), member(Zap, [tk,tyle]), Zap=Zap1, !.
oblzap_iter(Zap,bzap,Zap1) :- nonvar(Zap), member(Zap, [tk,tyle]), Zap=Zap1, !.

% gdy jeden składnik — jego zapowość równa zapowości całości:
oblzap(Zap, [Zap]) :- !.  
% gdy więcej — sprawdzamy zgodność pierwszych dwóch składników i
% sprowadzamy rzecz do sprawdzenia dla listy o jeden krótszej:
oblzap(Zap, [Zap0, Zap1 | Zapn]) :-
	oblzap_iter(Zap0, Zap1, Zap2),
	oblzap(Zap, [Zap2 | Zapn]).

% oblneg(Ozn, Neg, Neg1, Neg2) (obliczenie negacji)
% 
%Spełniony, gdy(równe(Ozn,  ani) lub równe(Neg, ani.nie)) i równe(Neg1, Neg2); 
%poza tym Neg=-ani TAK!!!.

oblneg(ani,nie(ani),nie(ani),nie(ani)) :-!.
oblneg(Ozn,Neg,Neg,Neg) :- Ozn \= ani.
% w szczególności: oblneg(-ani,Neg,Neg,Neg).

% nowa wersja dla fno koor (oblneg prawdopodobnie do wyrugowania):
sprawdz_neg(ani,nie(ani)) :- !.
sprawdz_neg(Ozn,_) :- Ozn \= ani.

% a tutaj dla koordynowanych fraz zdaniowych, w których składniki mogą
% się różnić negacją, ale jeśli przyjdzie spójnik «ani», bierze
% wszystkich za frak i wymusza zaprzeczenie:
sprawdz_neg_fzd(ani,[]) :- !.
sprawdz_neg_fzd(ani,[nie(ani) | Negs]) :- !, sprawdz_neg_fzd(ani,Negs).
sprawdz_neg_fzd(Ozn,_) :- Ozn \= ani.

% oblink(I, I1, I2)
% 
% Spełniony, gdy oba składniki są nieinkorporacyjne lub dokładnie
% jeden jest inkorporacyjny.  W tym ostatnim wypadku wartość
% inkorporacyjna pełznie w górę struktury:

oblink(ni,ni,ni) :- !.
oblink(i(TI,OI), i(TI,OI), ni) :- !.
oblink(i(TI,OI), ni, i(TI,OI)).

% Nowe sformułowanie warunku oblink:
% Postać potrzebna w warunkach iterowanych:

oblink_iter(ni,ni,ni) :- !.
oblink_iter(ni,i(TI,OI),i(TI,OI)) :- !.
oblink_iter(i(TI,OI),ni,i(TI,OI)).

% gdy jeden składnik — jego przecinkowość równa przecinkowości całości:
oblink(I, [I]) :- !.
% gdy więcej — sprawdzamy zgodność pierwszych dwóch składników i
% sprowadzamy rzecz do sprawdzenia dla listy o jeden krótszej:
oblink(I, [I0, I1 | In]) :-
	oblink_iter(I0, I1, I2),
	oblink(I, [I2 | In]).

% \subsection{Przecinkowość (Pk)}
%
% Parametr przecinkowości zdaje sprawę w obecności przecinków na
% początku i~końcu frazy.  Jest on parą wartości rozdzielonych
% funktorem |.  Jak łatwo zgadnąć, pierwsza wartość opisuje obecność
% przecinka jako inicjalnego elementu jednostki, druga zaś —
% finalnego.  Wartościami mogą być następujące symbole:
% p  — sygnalizuje, że w danej pozycji jest przecinek;
% bp — sygnalizuje, że przecinka nie ma, ale jest konieczny do pełności frazy;
% 0  − przecinka nie ma, ale nie ma i oczekiwania przecinka (neutralność).
%
% Terminal przec ma wartość przecinkowości p|p.  Frazy nie zawierające
% przecinków typowo mają 0|0.
%
% Zasady uzgadniania przecinkowości między sąsiadującymi frazami są
% następujące: Nie mogą spotkać się dwa przecinki, czyli wartości p
% przecinkowości końcowej pewnej frazy i przecinkowości początkowej
% frazy następnej.  „Luka na przecinek” musi zostać wypełniona, czyli
% wartość bp musi spotkać się z wartością p.  Wartość neutralna 0 może
% spotkać się z neutralną lub p.  Przy spotkaniu p i bp dla uniknięcia
% nieciekawie powielonych drzew wymagamy, żeby luka była na końcu, a
% przecinek na początku frazy następnej (we wszystkich regułach
% produkujących lukę będzie też wariant z przecinkiem w tym miejscu).

zgodne_pk(p,0).
zgodne_pk(bp,p).
zgodne_pk(0,0).
zgodne_pk(0,p).
% Mamy nadal problem z wymuszonymi przecinkami.  Na przykład na
% początku wypowiedzenia jest wymuszony przecinek, który nie może
% przejść do wnętrza pierwszej frazy, wbrew ogólnej zasadzie. Próbuję
% to rozwiązać za pomocą dodatkowej wartości sygnalizującej wymuszony
% przecinek, który nie może się ruszyć:
zgodne_pk(wp,bp).
zgodne_pk(wp,0).
% Kolejny problem: w skoordynowanych frazach zdaniowych z korelatem
% chcemy czasem wymagać przecinka przed spójnikiem współrzędnym.
% Wprowadzam więc kolejną wartość specjalną: wb, czyli wymuszony brak.
zgodne_pk(p,wb).
% To teraz odwrotnie: chcemy dopuścić niechlujne pominięcie przecinka
% przed spójnikiem (zob. s3).  Wartość lewej przecinkowości db oznacza
% dopuszczalny brak przecinka, zachowuje się jak 0, ale dopuszcza
% też bp.  Wystarczy zablokować tę pierwszą klauzulę, żeby wycofać się
% ze zgubnego permisywizmu.
zgodne_pk(bp,db).
zgodne_pk(p,db).
zgodne_pk(0,db).
% Kolejne wartości specjalne potrzebne dla oratio recta, które
% (zakładamy) mogą się pojawić wyłącznie na początku albo końcu całego
% wypowiedzenia.  Fraza or inicjalna będzie miała początkową
% przecinkowość wpw (wymagany początek wypowiedzenia), która będzie
% mogła się dopasować wyłącznie do pw (początek wypowiedzenia)
% występującej na początku wypowiedzenia.  Analogicznie wkw (wymagany
% koniec wypowiedzenia) jako prawostronna przecinkowość or i kw
% (koniec wypowiedzenia).  Oprócz tego pw i kw zachowują się,
% odpowiednio, jak wp i p.
zgodne_pk(pw, wpw).
zgodne_pk(wkw, kw).
zgodne_pk(pw,bp).
zgodne_pk(pw,0).
zgodne_pk(bp,kw).
zgodne_pk(0,kw).

% Poniższy warunek iterowany służy do uzgadniania przecinkowości.
% Pierwszym argumentem jest przecinkowość pewnej dotychczas
% rozpatrzonej frazy, drugim argumentem przecinkowość kolejnego
% członu, trzecim — wynikowa przecinkowość całej frazy.

sprawdz_pk_iter(Pkp0|Pkk0, Pkp1|Pkk1, Pkp0|Pkk1) :- zgodne_pk(Pkk0,Pkp1).

% Warunek oblpk będzie stosowany rutynowo w prawie wszystkich regułach
% gramatyki do sprawdzenia zgodności przecinkowości lewej strony z
% przecinkowością fraz składowych.  Ponieważ reguły miewają różną
% liczbę fraz składowych, jego drugim argumentem będzie lista
% przecinkowości tych fraz.  Pierwszym argumentem jest przecinkowość
% lewej strony reguły.

% gdy jeden składnik — jego przecinkowość równa przecinkowości całości:
oblpk(Pk, [Pk]) :- !.
% gdy więcej — sprawdzamy zgodność pierwszych dwóch składników i
% sprowadzamy rzecz do sprawdzenia dla listy o jeden krótszej:
oblpk(Pk, [Pk0, Pk1 | Pkn]) :-
	sprawdz_pk_iter(Pk0, Pk1, Pk2),
	oblpk(Pk, [Pk2 | Pkn]).

% \subsection{Klasa formy posiłkowej (KlPosiłk)}
%
% Następujący warunek jest iterowany po wszystkich elementach
% sekwencji poprzedzającej ff w zdaniu.  Ma on następujące zadania:
% zdać sprawę, czy wystąpiła forma posiłkowa i jaka, zapewnić, żeby
% mogła wystąpić co najwyżej jedna forma posiłkowa, wreszcie zapewnić,
% żeby forma posiłkowa nie wystąpiła bezpośrednio przed ff — taka
% forma zostanie wchłonięta przez formaczas (z wyjątkiem aglutynantu w
% zdaniach typu „gdyby”, który zawsze jest posił).  Z tego ostatniego
% powodu warunek jest iterowany po wszystkich elementach sekwencji, a
% nie tylko po posiłkach.
%
% Wartością początkową iteracji jest bezpo(siłkowa).  Wartość ost(_),
% sygnalizująca, że ostatnim elementem sekwencji jest posił, nie
% będzie akceptowana jako dobre zakończenie.

sprawdz_posiłk(bezpo, X, bezpo) :- 
	var(X). % to nie jest wystąpienie posiłk
sprawdz_posiłk(bezpo, P, TP) :- 
	nonvar(P), % to jest wystąpienie posiłk
	(P=agl(_) -> TP=posiłk(P) ; TP=ost(P)).
sprawdz_posiłk(ost(P), X, posiłk(P)) :- var(X).
sprawdz_posiłk(posiłk(P), X, posiłk(P)) :- var(X).

% Kolejny warunek będzie stosowany do elementów występujących po ff.
% W postpozycji dopuszczamy tylko analityczny czas przyszły i tryb
% warunkowy.
%%%* Czytają to niech.
%%%* Czytał toś?
% Na początku iteracji KlPosiłk będzie ustawione na pierw(KP), gdzie
% KP jest wynikiem iteracji po poprzedzających ff.  Pierwsze użycie
% warunku przepuści ten term, o ile pierwszym elementem nie jest
% posiłk:

sprawdz_post_posiłk(pierw(KP), X, KP) :- var(X), !.
sprawdz_post_posiłk(bezpo, X, bezpo) :- var(X), !.
sprawdz_post_posiłk(bezpo, P, posiłk(P)) :- nonvar(P), !,
	(P = by(_) ; P = bedzie(_,_) ).
sprawdz_post_posiłk(posiłk(P), X, posiłk(P)) :- var(X).

% Następujący warunek jest używany, gdy był już posiłk i ff.  Ma on
% przetłumaczyć parametry ff i posiłk na parametry dla zdania jako
% całości.

%              ff:                zdanie:
% oblposiłk(Tp, Wf2/A2/C2/T2/O2/Neg2, Wf/A/C/T/O/Neg)
% jeśli nie było posiłk, parametry ff przepisują się bez zmian:
%oblposiłk(_,_,_) :- trace, fail.
oblposiłk(bezpo, Param, Param).
% Jeżeli druga sekwencja była pusta, to obliczenie dla wyniku pierwszej sekwencji:
oblposiłk(pierw(KP), KP1, KP2) :- oblposiłk(KP, KP1, KP2).
% jeśli było posiłk, działamy zależnie od jego typu:
oblposiłk(posiłk(agl(O)), os/A/prze/ozn/3/Neg, os/A/prze/ozn/O/Neg).
%%%% Gdybym to czytał.
oblposiłk(posiłk(niech), os/nd/ter/ozn/O/Neg, os/nd/C/roz/O/Neg) :- 
	member(O,[1,3]).
%%%% Niech to czytają.
oblposiłk(posiłk(niech), os/dk/przy/ozn/O/Neg, os/dk/C/roz/O/Neg) :-
	member(O,[1,3]).
%%%% Niech to przeczytają.
oblposiłk(posiłk(niech), os/nd/przy/ozn/O/Neg, os/nd/_C/roz/O/Neg) :-
	member(O,[1,3]).
%%%% Niech ci będzie.
% Powyższe bardzo potrzebne, a poniższe dopuszczone w związku z tym.
% Przy leksykalizacji można by ograniczyć do „bedzie:”
%%%? Niech duch Twój będzie zstępować!
%%%? Niech o tym będzie świadczyć fakt, że umarł.
oblposiłk(posiłk(by(O)), Wf/A/prze/ozn/3/Neg, Wf/A/ter/war/O/Neg) :- 
	member(Wf/O,[os/_,bos/3]).
%%%% Byście to czytali.
%%%% By to czytali.
%%%* Byście to czytać.
%%%% By to czytać.
%%%% Czytali to byście?
% Nie jestem pewien, gdzie jest możliwe «nie» w przeszłym warunkowym.
% Na razie zakładam, że „byłby tego nie czytał.”, ale nie „nie byłby tego czytał”:
oblposiłk(posiłk(byłby(O,tak)), os/A/prze/ozn/3/Neg, os/A/prze/war/O/Neg).
% W analitycznym czasie przyszłym «nie» idzie przy posile:
%%%% Nie będzie tego czytać.
%%%* Będzie tego nie czytać.
oblposiłk(posiłk(bedzie(O,Neg)), os/nd/prze/ozn/3/tak, os/nd/przy/ozn/O/Neg).
oblposiłk(posiłk(bedzie(O,Neg)), bok/nd/C2/T2/O2/tak, os/nd/przy/ozn/O/Neg).

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% REGUŁY GRAMATYKI %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

% \section{WYPOWIEDZENIE}

% Reguła ta zawiera nietypowe obliczenie przecinkowości: zdanie w tym
% kontekście zachowuje się tak, jakby było otoczone przecinkami — może
% mieć lukę na przecinek na początku lub końcu, ale nie może mieć
% faktycznego przecinka.

% Ze względu na reguły podziału na zdania w NKJP dopuszczamy
% niesparowane cudzysłowy i nawiasy (oczywiście tylko na początku i
% końcu wypowiedzenia).  W NKJP są w ten sposób traktowane ciągi kilku
% zdań ujętych w cudzysłowy/nawiasy: znaki interpunkcyjne zostają
% włączone do pierwszego i ostatniego zdania w ciągu.

wypowiedzenie --> s(w),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	optional(cudz(z,po),{C1=t},{}),
	znakkonca(Dest2, po),
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) },
	optional(cudz(z,po),{C1=f},{}),
	optional(nawias(z,_TN,po),{},{}).

zgodnyznakk(neut,neut).
zgodnyznakk(neut,pyt).
zgodnyznakk(pyt,pyt).

wypowiedzenie --> s(w2),
	pauza(po),
	optional(cudz(o,po),{C1=t},{C1=f}),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	optional(cudz(z,po),{C1=t, C2=t},{C2=f}),
	znakkonca(Dest2, po),
	optional(cudz(z,po),{C2=f},{}),
%	optional(cudz(z,po),{C1=t, C2=f},{C1=f; C2=t}), % jeśli parowanie
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

%%%% - Gdzie teraz pójdziesz?”

wypowiedzenie --> s(w3),
	cudz(o,po),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	optional(cudz(z,po),{C1=t},{C1=f}),
	znakkonca(Dest2, po),
	optional(cudz(z,po),{C1=f},{}),
%	optional(cudz(z,po),{C1=f},{C1=t}), % jeśli parowanie
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

wypowiedzenie --> s(w4),
	nawias(o,TN,po),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	optional(nawias(z,TN,po),{C1=t},{C1=f}),
	znakkonca(Dest2, po),
	optional(nawias(z,TN,po),{C1=f},{}),
%	optional(nawias(z,TN,po),{C1=f},{C1=t}), % jeśli parowanie
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

spójnik_obrzynotwórczy(Tsp,Oz) :-
	member(Tsp/Oz, [szk/i, szk/albo, szk/bądź, szk/lub, szk/ani,
			rc/natomiast,rc/alei,rc/a,rc/czyli,rc/względnie,rc/tymczasem,
			po/żeby, po/że, po/zanim, po/ponieważ, po/podczas, po/jeśli,
			po/gdyby, po/gdy, po/dopóki, po/choćby, po/chociaż, po/aż,
			pc/więc, pc/bo, pc/to]).

wypowiedzenie --> s(w5),
	spójnik(Tsp,Oz,ni,na),
	{ spójnik_obrzynotwórczy(Tsp,Oz) },
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, po),
	znakkonca(Dest2, po),
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

wypowiedzenie --> s(w6),
	pauza(po),
	optional(cudz(o,po),{C1=t},{C1=f}),
	spójnik(Tsp,Oz,ni,na),
	{ spójnik_obrzynotwórczy(Tsp,Oz) },
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, po),
	optional(cudz(z,po),{C1=t, C2=t},{C2=f}),
	znakkonca(Dest2, po),
	optional(cudz(z,po),{C1=t, C2=f},{C1=f; C2=t}),
	{ zgodnyznakk(Dest1,Dest2),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

% Wypowiedzenie z didaskaliami:
wypowiedzenie --> s(w7),
%	fno(mian, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, neut, Pk, po),
	fno(mian, R/L, O, WymN, Kl, Zap, Poz, Neg, neut, ni, Pk, po),
	{ wymagania_zamknij(WymN) },
	[morf(I,_,interp)], { member(I, [':','-','–','—']) },
	wypowiedzenie.

wypowiedzenie --> s(w8),
	nawias(o,TN,po),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	nawias(z,TN,po),
	{ zgodnyznakk(Dest1,neut),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

%%%% (Gazeta Wyborcza)

% Tę regułę pewnie trzeba wywalić, jeśliby przetwarzać tekst
% ciągły. Ale dopóki kto inny dzieli na zdania, możemy sobie pozwolić:
wypowiedzenie --> s(w9),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest1, I, Pk, na),
	{ zgodnyznakk(Dest1,neut),
	  oblpk(_, [ (p|pw), Pk, (kw|p) ]) }.

%%%% OBYCZAJOWY
%%%% Czytam

%  \section{ZDANIE}
% \subsection{Realizacje finitywne}

zdanie(Wf, A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) --> 
	s(ze1),
	ff(Wf1, A1, C1, T1, Rl, O1, Wym, Neg1, Dest1, I1, Pk1, na),
	sequence_of([
		    fw(W2, A, C, Rl, O, post, Neg, Dest2, I2, Pk2, po)
		        ^[oblwym_iter, Wym, W2, ResztaWym],
		    fl(A, C, Rl, O, Neg, Dest2, I2, Pk2, po)
		        ^[najwyżej3, 0, _, _],
		    posiłk(KlPosiłk, Rl, Dest2, I2, Pk2, po)
		    ]
		    ^[obldest_iter, Dest1, Dest2, Dest]
		    ^[oblink_iter, I1, I2, I]
		    ^[sprawdz_pk_iter, Pk1, Pk2, Pk]
		    ^[conajmniej1, 0, _, CN1]
		    ^[sprawdz_post_posiłk, pierw(bezpo), KlPosiłk, TP]
		   ),
	{ oblposiłk(TP, Wf1/A1/C1/T1/O1/Neg1, Wf/A/C/T/O/Neg),
	  wymagania_zamknij(ResztaWym),
	  wyklucz_podmiot_bezokolicznika(Wf,Wym) },
	{ wymagania_skoordynowane(Wym) *-> CN1=1; true }.

%%%% Gotować mieszaninę dwie godziny.
%%%* Gotować Jan mieszaninę dwie godziny.
%%%% Chciał ja bym to czytać…
%%%% Gardzić nim będzie jego nowy pan.

zdanie(Wf, A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) --> 
	s(ze2),
	fw(W1, A, C, Rl, O, pre, Neg, Dest1, I1, Pk1, po),
	sequence_of([ 
		      fw(W2, A, C, Rl, O, pre, Neg, Dest2, I2, Pk2, po)
		        ^[zroblistę_iter, [W1], W2, PreFfWym],
		      fl(A, C, Rl, O, Neg, Dest2, I2, Pk2, po)
		        ^[najwyżej3, 0, _, IleFl],
		      posiłk(KlPosiłk2, Rl, Dest2, I2, Pk2, po)
		    ]
		    ^[obldest_iter, Dest1, Dest2, DestPreF]
		    ^[oblink_iter, I1, I2, IPreF]
		    ^[sprawdz_pk_iter, Pk1, Pk2, PkPreF]
		    ^[sprawdz_posiłk, bezpo, KlPosiłk2, TP4]
		   ),
	ff(Wf4, A4, C4, T4, Rl, O4, Wym, Neg4, Dest4, I4, Pk4, na),
	{ obldest_iter(DestPreF, Dest4, DestPostF),
	  oblink_iter(IPreF, I4, IPostF),
	  sprawdz_pk_iter(PkPreF, Pk4, PkPostF),
	  wyjmijl(PreFfWym, Wym, PostFfWym) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
		        ^[oblwym_iter, PostFfWym, W5, ResztaWym],
		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
		        ^[najwyżej3, IleFl, _, _],
		      posiłk(KlPosiłk5, Rl, Dest5, I5, Pk5, po)
		    ]
		    ^[obldest_iter, DestPostF, Dest5, Dest]
		    ^[oblink_iter, IPostF, I5, I]
		    ^[sprawdz_pk_iter, PkPostF, Pk5, Pk]
		    ^[sprawdz_post_posiłk, pierw(TP4), KlPosiłk5, TP]
		   ),
	{ oblposiłk(TP, Wf4/A4/C4/T4/O4/Neg4, Wf/A/C/T/O/Neg),
	  wymagania_zamknij(ResztaWym),
	  wyklucz_podmiot_bezokolicznika(Wf,Wym)  }.

%%%% ‹Jan byłby na to nie narzekał›.
%%%% ‹Jan będzie się tego bardzo bał›.
%%%% Zima była słaba, ‹roztopy | występują więc | wcześniej›.
%%%* Jan narzekać.
%%%% Jan narzekać na to będzie.
%%%% ‹Tyś to uczynił›.

zdanie(Wf, A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(ze3),
	fl(A, C, Rl, O, Neg, Dest1, I1, Pk1, po),
	sequence_of([ 
		      fw(W2, A, C, Rl, O, pre, Neg, Dest2, I2, Pk2, po)
		        ^[zroblistę_iter, [], W2, PreFfWym],
		      fl(A, C, Rl, O, Neg, Dest2, I2, Pk2, po)
		        ^[najwyżej3, 0, _, IleFl],
		      posiłk(KlPosiłk2, Rl, Dest2, I2, Pk2, po)
		    ]
		    ^[obldest_iter, Dest1, Dest2, DestPreF]
		    ^[oblink_iter, I1, I2, IPreF]
		    ^[sprawdz_pk_iter, Pk1, Pk2, PkPreF]
		    ^[sprawdz_posiłk, bezpo, KlPosiłk2, TP4]
		   ),
	ff(Wf4, A4, C4, T4, Rl, O4, Wym, Neg4, Dest4, I4, Pk4, na),
	{ obldest_iter(DestPreF, Dest4, DestPostF),
	  oblink_iter(IPreF, I4, IPostF),
	  sprawdz_pk_iter(PkPreF, Pk4, PkPostF),
	  wyjmijl(PreFfWym, Wym, PostFfWym) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
		        ^[oblwym_iter, PostFfWym, W5, ResztaWym],
		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
		        ^[najwyżej3, IleFl, _, _],
		      posiłk(KlPosiłk5, Rl, Dest5, I5, Pk5, po)
		    ]
		    ^[obldest_iter, DestPostF, Dest5, Dest]
		    ^[oblink_iter, IPostF, I5, I]
		    ^[sprawdz_pk_iter, PkPostF, Pk5, Pk]
		    ^[sprawdz_post_posiłk, pierw(TP4), KlPosiłk5, TP]
		   ),
	{ oblposiłk(TP, Wf4/A4/C4/T4/O4/Neg4, Wf/A/C/T/O/Neg),
	  wymagania_zamknij(ResztaWym),
	  wyklucz_podmiot_bezokolicznika(Wf,Wym)  }.

%%%% ‹Raczej bym na to nie liczył›.
%%%% Raczej liczyć na nich będzie.

zdanie(Wf, A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(ze4),
	posiłk(KlPosiłk, Rl, Dest1, I1, Pk1, po),
	{ sprawdz_posiłk(bezpo, KlPosiłk, TP1) },
	sequence_of([ 
		      fw(W2, A, C, Rl, O, pre, Neg, Dest2, I2, Pk2, po)
		        ^[zroblistę_iter, [], W2, PreFfWym],
		      fl(A, C, Rl, O, Neg, Dest2, I2, Pk2, po)
		        ^[najwyżej3, 0, _, IleFl]
		    ]
		    ^[obldest_iter, Dest1, Dest2, DestPreF]
		    ^[oblink_iter, I1, I2, IPreF]
		    ^[sprawdz_pk_iter, Pk1, Pk2, PkPreF]
		    ^[sprawdz_posiłk, TP1, _, TP4]
		   ),
	ff(Wf4, A4, C4, T4, Rl, O4, Wym, Neg4, Dest4, I4, Pk4, na),
	{ oblposiłk(TP4, Wf4/A4/C4/T4/O4/Neg4, Wf/A/C/T/O/Neg),
	  obldest_iter(DestPreF, Dest4, DestPostF),
	  oblink_iter(IPreF, I4, IPostF),
	  sprawdz_pk_iter(PkPreF, Pk4, PkPostF),
	  wyjmijl(PreFfWym, Wym, PostFfWym) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
		        ^[oblwym_iter, PostFfWym, W5, ResztaWym],
		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
		        ^[najwyżej3, IleFl, _, _]
		    ]
		    ^[obldest_iter, DestPostF, Dest5, Dest6]
		    ^[oblink_iter, IPostF, I5, I]
		    ^[sprawdz_pk_iter, PkPostF, Pk5, Pk]
		   ),
	{ wymagania_zamknij(ResztaWym),
	  wyklucz_podmiot_bezokolicznika(Wf,Wym),
	  oblicz_dest_agl(KlPosiłk,Dest6,Dest) }.

% Jeżeli inicjalny posiłk jest typu agl, to trzeba przekazać o tym
% informację na zewnątrz, do frazy zdaniowej, której to zdanie stanie
% się częścią.  Zob. regułę zds2 i zds2o.
oblicz_dest_agl(agl(_), Dest1, agl) :- !, Dest1=neut.
oblicz_dest_agl(_,Dest,Dest).

%%%% ‹Niech | duch Twój | zstąpi›!
%%%% ‹Niech | duch Twój | zstępuje›!
%%%% ‹Byście | już | tę książkę | przeczytały |, gdyby Piotr nie przyszedł›.
%%%% ‹By | już | przeczytano | tę książkę |, gdyby Piotr nie przyszedł›.
%%%% Inaczej potoczyłyby się moje losy, gdyby‹m | została | kucharką›.
%%%% Nie byłbym ministrem finansów, gdyby‹m | tego | nie dodał›.
%%%? Niech duch Twój będzie zstępować!
%%%% Niech ci będzie!
%%%? Niech ci będzie czytać co wieczór.

zroblistę_iter(WW, W, [W|WW]).

% Poniższy warunek iterowany zapewnia dopuszczenie najwyżej 3
% nieterminali nim obłożonych (drugi argument jest tylko po to, żeby
% dostosować się do składni warunków iterowanych):
najwyżej3(N, _, N1) :- N < 3, N1 is N + 1.

% Poniższy warunek iterowany zapewnia dopuszczenie najwyżej N
% nieterminali nim obłożonych (drugi argument jest tylko po to, żeby
% dostosować się do składni warunków iterowanych):
najwyżej(N, _, N1) :- N > 0, N1 is N - 1.

% Następny warunek iterowany służy do sprawdzenia, że sekwencja była
% niepusta.

conajmniej1(_, _, 1).

% \subsection{Realizacje równorzędne}

zdanie(sp:r:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(r1),
	zdanie(Wf, A, C, T, RL, O, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1), Wf \= bc(_) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk3, po),
	{Wf3 \= bc(_),
	 obldest(Dest,[Dest1,Dest3]), oblpk(Pk,[Pk1,Pk2,Pk3]) }.

zdanie(sp:r:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(r2),
	zdanie(Wf, A, C, T, RL, O, Neg, neut, I, Pk1, po),
%	{ tylko_neut_pyt(Dest1) },
	{ Wf \= bc(_)},
	przec(Pk2,na),
	zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, i(r,Oz), Pk3, po),
	{ Wf3 \= bc(_),
	  obldest(Dest,[neut,Dest3]),
	  oblpk(Pk,[Pk1,(p|wp),Pk3]) }.

zdanie(sp:r:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(r3),
	spójnik(rl,Oz,I,na),
	zdanie(Wf, A, C, T, RL, O, Neg, Dest1, ni, Pk2, po),
	{ tylko_neut_pyt(Dest1), Wf \= bc(_) },
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk5, po),
	{ Wf3 \= bc(_),
	  obldest(Dest,[Dest1,Dest3]),
	  oblpk(Pk,[Pk2,Pk3,Pk5]) }.


% \subsection{Realizacje szeregowe}

jeden_na_listę([A|LL], A, LL).
dwa_na_listę([A,B|LL], [A,B], LL).
trzy_na_listę([A,B,C|LL], [A,B,C], LL).

% Blokujemy zagnieżdżenie w sobie szeregów tego samego typu: blokujemy
% szereg o takim samym oznaczeniu oraz szeregi zawierające
% wykrzykniki:
sprawdź_wyróżnik_w_szeregu(Oz, Wf) :- Wf \= sp:sz:Oz, Wf \= sp:sz:wykrz, Wf \= bc(_).

sprawdź_wyróżniki_w_szeregu(Oz,WfL) :-
	sprawdź_wyróżniki_w_szeregu(Oz,WfL,nic).

sprawdź_wyróżniki_w_szeregu(_,[],_) :- !.
sprawdź_wyróżniki_w_szeregu(Oz, [Wf |WfL], Poprz) :-
	sprawdź_czy_bok(Poprz, Wf, Nast),
	sprawdź_wyróżnik_w_szeregu(Oz,Wf),
	sprawdź_wyróżniki_w_szeregu(Oz, WfL, Nast).

% Ten warunek ma zapewnić, żeby zdania z centrum bezokolicznikowym nie
% były mieszane w szeregach z innymi:
sprawdź_czy_bok(nic,bok,bok) :- !.
sprawdź_czy_bok(bok,bok,bok) :- !.
sprawdź_czy_bok(Poprz,Wf,nbok) :- Wf\= bok, Poprz \= bok.

%%%% Śmietankę zagotować, dodać czekoladę i ostrożnie zamieszać.
%%%* Śmietankę zagotuj, dodaj czekoladę i ostrożnie zamieszać.

% sp z (, sp z)* , sp z
zdanie(sp:sz:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(s1),
	spójnik(sz,Oz,ni,na),
	{ \+ member(Oz, [przec,lub]) },
	zdanie(Wf1, A, C, T, RL, O, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,po),
	      zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk3, po)
	    ]^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WfL, Wf3, [Wf6]]
	     ^[A3]^[C3]^[T3]^[RL3]^[O3]^[Neg3]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,po),
	{ Oz \= czy },
	zdanie(Wf6, A6, C6, T6, RL6, O6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[(0|0), Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  sprawdź_wyróżniki_w_szeregu(Oz, [Wf1 | WfL]) }.

% z (sp z ,)+ sp z
% + a nie *, bo schemat bez powtarzanego elementu załatwi s3
zdanie(sp:sz:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(s2),
	zdanie(Wf1, A, C, T, RL, O, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ spójnik(sz,Oz,ni,po),
	      zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk3, po),
	      przec(Pk4,po)
            ]^[trzy_na_listę, PkL, [(0|0),Pk3,(p|wp)], [(0|0),Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WfL, Wf3, [Wf6]]
	     ^[A3]^[C3]^[T3]^[RL3]^[O3]^[Neg3]
	     ^[conajmniej1, 0, _, 1]
	]),
	spójnik(szk,Oz,ni,na),
	{ różne(Oz, [przec,czy]) },
	zdanie(Wf6, A6, C6, T6, RL6, O6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  sprawdź_wyróżniki_w_szeregu(Oz, [Wf1 | WfL]) }.

% z (, z)* sp z
zdanie(sp:sz:Oz, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(s3),
	zdanie(Wf1, A, C, T, RL, O, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WfL, Wf3, [Wf6]]
	     ^[A3]^[C3]^[T3]^[RL3]^[O3]^[Neg3]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz \= czy },
	{ Oz = przec -> Pk5 = (p|wp) ; Pk5 = (db|0) },
	zdanie(Wf6, A6, C6, T6, RL6, O6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  sprawdź_wyróżniki_w_szeregu(Oz, [Wf1 | WfL]),
	  % Dodatkowo w tym układzie szereg przecinkowy nie może być
	  % składnikiem:
	  różne( sp:sz:przec, [Wf1 | WfL]),
	  % a także ostatni składnik szeregu przecinkowego nie może
	  % być szeregiem:
	  %% korekta pod wpływem rzeczywistości: dopuszczamy ‹i›
	  ( Oz \= przec ; Wf6 \= sp:sz:_ ; Wf6 = sp:sz:i )
	}.

%%%% ‹Chciałam, żeby przyszli, | i | czekałam›.
% dopuszczone z niesmakiem:
%%%% ‹Chciałam, żeby przyszli | i | czekałam›.
%%%% ‹Niebacznie stanął pod nawisem |, | oberwało się i przywaliło›.
%%%% ‹Pomogli mu |, | podnieśli też z trudem kolumnę zaklinowaną w kącie i osadzili na trzonie›.
%%%% ‹Dyrektor zapoznał Grodzickiego z katechetą |, | potem pożegnał się i wyszedł›.

% \subsection{Realizacje podrzędne (zdanie proste w GFJP1)}

% \subsubsection{ze spójnikiem centralnym}

zdanie(Wf, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(p1),
	zdanie(Wf, A, C, T, RL, O, Neg, Dest1, I, Pk1, na),
	{ tylko_neut_pyt(Dest1) },
%	{ oblnp(Z2, Z) },
	przec(Pk2,po),
	spójnik(pc, Oz, ni, po),
	zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, ni, Pk3, po),
	{ Wf3 \= bc(_),
	  obldest(Dest,[Dest1,Dest3]),
	  oblpk(Pk,[Pk1,Pk2,Pk3]) }.

%%%% Czyta, bo musi.
%%%% Ja zostanę, gdyż kto poszedł?
%%%% ‹Wątpię, więc myślę›, myślę, więc jestem.
%%%% Żyli jako ludzie, zatem musieli cierpieć.
%%%% Słuchajcie, albowiem bliskie jest królestwo Jehowy.

% \subsubsection{ze spójnikiem prawym}

% ograniczenia:
% oblzal(Z, NZ, Oz), i wykluczone pewne zależności (zob.!)
% jeśli Oz = [choćby, gdyby], to C = przy

zdanie(Wf, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(p2),
	fzd(Oz, nk, A1, C1, T1, Neg1, I, Pk1, po),
%	{ member(Oz, ['choćby','gdyby']) },
	przec(Pk2,po),
	spójnik(pp, Oz, ni, po),
	zdanie(Wf, A, C, T, RL, O, Neg, Dest, ni, Pk3, na),
	{ tylko_neut_pyt(Dest), Wf \= bc(_),
	  oblpk(Pk,[Pk1,Pk2,Pk3]) }.

%%%% Dopóki Piotr nie umarł,  dopóty nie przychodź.
%%%% Gdy rozum śpi, wtedy budzą się.
%%%% Choćby pękł, jednak nie da rady.
%%%% Choćby zdechł, to jednak nie da rady.
%%%% Chociaż się staram, to nie wychodzi.
%%%% Choćby zdechł, to nie da rady.
%%%% Gdyby powiedziała prawdę, to Jan żyłby do stycznia.
%%%% Jeśli powiem, to umrą.

% \subsubsection{ze spójnikiem lewym}

zdanie(Wf, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(p3),
	spójnik(pl, Oz, ni, po),
	zdanie(Wf, A, C, T, RL, O, Neg, Dest, ni, Pk2, na),
	{ tylko_neut_pyt(Dest), Wf \= bc(_) },
	fzd(Oz, nk, A1, C1, T1, Neg1, I, Pk3, po),
	{ oblpk(Pk,[(0|0),Pk2,Pk3]) }.

%%%% Pisze, że ‹dopóty czytał, dopóki mógł›.
%%%% Wtedy przyszedł, gdy czytano.

% \subsubsection{ze spójnikiem inkorporacyjnym}

zdanie(Wf, A, C, T, RL, O, Neg, Dest, I, Pk, Sub) -->
	s(p4),
	zdanie(Wf, A, C, T, RL, O, Neg, neut, I, Pk1, na),
	{ Wf \= bc(_) },
	przec(Pk2,po),
	zdanie(Wf3, A3, C3, T3, RL3, O3, Neg3, Dest3, i(p,_), Pk3, po),
	{ Wf3 \= bc(_),
	  obldest(Dest,[neut,Dest3]),
	  oblpk(Pk,[Pk1,(p|wp),Pk3]) }.

%%%% Płacze, chomik bowiem umarł.
%%%% Czekam, czy więc zechcesz się pośpieszyć?

% \section{Zdanioidy wykrzyknikowe}

zdanie(wykrz, A, C, T, RL, O, tak, neut, ni, Pk, Sub) -->
	s(zk1),
	formawykrz(Wym, na),
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, tak, neut, ni, Pk5, po)
		        ^[oblwym_iter, Wym, W5, ResztaWym]
		    ]
		    ^[sprawdz_pk_iter, (0|0), Pk5, Pk]
		   ),
	{ wymagania_zamknij(ResztaWym)  }.
% ,
% 	{ rekcja_zdanioidowa(W),
% 	  oblwym_iter(W, W1, W2) },
% 	sequence_of([ 
% 		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
% 		        ^[oblwym_iter, W2, W5, ResztaWym],
% 		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
% 		        ^[najwyżej3, 0, _, _]
% 		    ]
% 		    ^[obldest_iter, Dest1, Dest5, Dest]
% 		    ^[oblink_iter, I1, I5, I]
% 		    ^[sprawdz_pk_iter, Pk1, Pk5, Pk]
% 		   ),
% 	{ ResztaWym = wym([],OW), resztawym(OW)  }.

%%%% ‹He›, ‹he›!
%%%% ‹Ejże›, chyba sobie żartujesz!
%%%% ‹Precz | z Wałęsą›!
%%%% ‹Precz | mi | stąd›!
%%%% Wszystko przepadło, ‹biada | mi›!
%%%% Chce żyć, ‹o | radości›!

% \section{Zdanioidy bezczasownikowe}

zdanie(bc(W), A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(bc1),
	fw(W1, A, C, Rl, O, pre, Neg, Dest1, I1, Pk1, po),
	{ rekcja_zdanioidowa(W),
	  oblwym_iter(W, W1, W2) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
		        ^[oblwym_iter, W2, W5, ResztaWym]
		        ^[najwyżej, 2, _, _],
		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
		        ^[najwyżej3, 0, _, _]
		    ]
		    ^[obldest_iter, Dest1, Dest5, Dest]
		    ^[oblink_iter, I1, I5, I]
		    ^[sprawdz_pk_iter, Pk1, Pk5, Pk]
		   ),
	{ wymagania_zamknij(ResztaWym)  }.

%%%% Karkonosze.
%%%% Szybko.
%%%% Najpospolitszy.
%%%% Bez powodzenia.
%%%% Ulubiona potrawa?
%%%% ‹Dla nas | koniec›.
%%%% ‹Ja | do internisty›.
%%%% A ‹Piotr | komu›?

zdanie(bc(W), A, C, T, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(bc2),
	fl(A, C, Rl, O, Neg, Dest1, I1, Pk1, po),
	{ rekcja_zdanioidowa(W) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg, Dest5, I5, Pk5, po)
		        ^[oblwym_iter, W, W5, ResztaWym]
		        ^[najwyżej, 3, _, _],
		      fl(A, C, Rl, O, Neg, Dest5, I5, Pk5, po)
		        ^[najwyżej, 2, _, _]
		    ]
		    ^[obldest_iter, Dest1, Dest5, Dest]
		    ^[oblink_iter, I1, I5, I]
		    ^[sprawdz_pk_iter, Pk1, Pk5, Pk]
		   ),
	{ wymagania_zamknij(ResztaWym)  }.

%%%% Może jutro.

% \section{FRAZA FINITYWNA}

ff(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(fi1),
	fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, na),
	{ równe( Wf, ['os','bos','bok', sp:_] ),
	  wymagania_czyste(_,Wym),
	  % blokujemy wartości mieszane parametrów, bo inaczej zdanie
	  % bezpodmiotowe mogłoby powstać z wartością mieszaną:
	  R \== mie, L\==mie, O\==mie
	}.

%  \section{FRAZA WYMAGANA}

fw(infp(A1), A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy1),
	fwe(bok, A1, C, T, Rl1, O1, Wym, Neg1, Dest, I, Pk, na),
% Jeżeli fwe ma wysycone wymagania, to trzeba uzgodnić wartość negacji z kontekstem:
	{ Neg1 = NegL/NegR *->
	  (NegL=req(Neg2) *-> Neg2 = Neg;
	   (NegR=req(Neg2) *-> Neg2 = Neg ; true ))
	;
	  (Neg1=req(Neg2) *->  Neg2 = Neg ; true)
	},
	{ wymagania_zamknij(Wym) }.

%%%% Jan chce ‹czytać›.
%%%% Jan chce ‹nie czytać›.
%%%% Jan nie chce ‹czytać›.
%%%% Jan nie chce ‹nie czytać›.
%%%% Jan nie chce ‹zbudować domu›.
%%%* Jan chce ‹zbudować domu›.
%%%% Jan chce ‹oglądać kurczęta i nie myśleć o jutrze›.
%%%? Jan nie chce ‹myśleć o jutrze i oglądać kurcząt›.
%%%% Jan chce ‹nie myśleć o jutrze i oglądać kurczęta›.
%%%* Jan chce ‹nie myśleć o jutrze i oglądać kurcząt›.

fw(subj(infp(A1)), A, C, r(mn(n),nmo(np(n)))/poj, 3, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy1s),
	fwe(bok, A1, C, T, Rl1, O1, Wym, Neg1, Dest, I, Pk, na),
% Jeżeli fwe ma wysycone wymagania, to trzeba uzgodnić wartość negacji z kontekstem:
	{ Neg1 = NegL/NegR *->
	  (NegL=req(Neg2) *-> Neg2 = Neg;
	   (NegR=req(Neg2) *-> Neg2 = Neg ; true ))
	;
	  (Neg1=req(Neg2) *->  Neg2 = Neg ; true)
	},
	{ wymagania_zamknij(Wym) }.

%%%% Marzy mu się czytać.

% \subsection{Realizacje przyimkowe}

fw(prepnp(Pm,P), A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy2),
	fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, na).

fw(prepadjp(Pm,P), A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wyp1),
	fpmpt(Pm, P, Kl, Zap, Neg, Dest, I, Pk, na).

% \subsection{Realizacje nominalne}

fw(subj(np(mian)), A, C, Rl, O, Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy3),
	fno(mian, Rl, O, wym([],_,_), Kl, Zap, Poz, Neg, Dest, I, Pk, na).

fw(np(bier), A, C, Rl, O, Poz, nie(Neg), Dest, I, Pk, Sub) -->
	s(wy4),
	fno(dop, Rl1, O1, wym([],_,_), Kl, Zap, pre, nie(Neg), Dest, I, Pk, na).

fw(np(bier), A, C, Rl, O, Poz, tak, Dest, I, Pk, Sub) -->
	s(wy5),
	fno(bier, Rl1, O1, wym([],_,_), Kl, Zap, pre, tak, Dest, I, Pk, na).

fw(np(part), A, C, Rl, O, Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy4p),
	fno(dop, Rl1, O1, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk, na).

%%%% Podał Eugeniuszowi chleba.
%%%% Nie podał Eugeniuszowi chleba.

fw(np(part), A, C, Rl, O, Poz, tak, Dest, I, Pk, Sub) -->
	s(wy5p),
	fno(bier, Rl1, O1, wym([],_,_), Kl, Zap, pre, tak, Dest, I, Pk, na).

%%%% Podał Eugeniuszowi chleb.

fw(np(P), A, C, Rl, O, Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy6),
	fno(P, Rl1, O1, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk, na),
	{ różne(P, [bier,miej])}.

fw(sie, A, C, Rl, O, _Poz, Neg, neut, ni, (0|0), Sub) -->
	s(wy7),
	[morf(_,'się',qub)].

% to ma być ‘się’ bezosobowe („czyta się książki.”)
fw(subj(np(mian)), _A, _C, r(mn(n),nmo(np(n)))/poj, 3, _Poz, _Neg, neut, ni, (0|0), Sub) -->
	s(wy8),
	[morf(_,'się',qub)].
%%%% Czyta się książki.

fw(adjp(P), A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) --> 
	s(wya1),
	fpt(P1, Rl1, St, wym([],_,_), Kl, Zap, Neg, Dest, I, Pk, na),
 	{ member(P1,[mian,narz]),
	  member(P,[P1,pred]) }.

fw(adjp(bier), A, C, Rl, O, _Poz, nie(Ani), Dest, I, Pk, Sub) --> 
	s(wya2),
	fpt(dop, Rl1, St, wym([],_,_), Kl, Zap, nie(Ani), Dest, I, Pk, na).

fw(adjp(bier), A, C, Rl, O, _Poz, tak, Dest, I, Pk, Sub) --> 
	s(wya3),
	fpt(bier, Rl1, St, wym([],_,_), Kl, Zap, tak, Dest, I, Pk, na).

fw(advp, A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy9),
 	fps(St, Kl, Neg, Dest, I, Pk, na).

%% fw(advp, A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(wy10),
%% 	fno(P, Rl1, O1, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk, na),
%% 	{ równe(P, [cel,bier,narz])}.

%% % Chyba wyrzucić bier. Na pewno cel. A może w ogóle wyrzucić regułę? [MS]

fw(advp, A, C, Rl, O, _Poz, Neg, Dest, I, Pk, Sub) -->
	s(wy11),
	fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, na).

% jeszcze powinno być advp --> sentp

% \subsection{Realizacje zdaniowe}

% do uporządkowania!:

% Idea: 
% fw(sentp(Tfz/K,...,Pk,...) 
% (a) Tfz <> wz [bo Dest=wz wchodzi tylko w regułach na fno i fpt; 
% cztery kombinacje będą zapisane w df. fno],
% (b) przec fzd przec – [p|p] Wiem, że pada, od Piotra.
% (c) przec fzd – [p|bp]	Wiem, że pada.
% (d) fzd przec – [0|p]	Że pada, wiem. 	0 czy bp? Raczej 0!
% (e) fzd – [0|bp]	Że pada, Mario, wiem.	0 czy bp? Raczej 0!
% (f) kor przec fzd przec – [bp|p]	O tym, że pada, wiem. Tu na pewno bp!
% (g) kor przec fzd – [bp|bp] Wiem o tym, że pada. Tu na pewno bp!
% 

fw(sentp(Tfz), A, C, Rl, O, _Poz, Neg, neut, I, Pk, Sub) --> 
	s(wyz1),
	fzd(Tfz, nk, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,gdy,jak,jakby,jakoby,jeśli,mie1,mie2,mie3,pz,że,żeby]) },
	{ Tfz = aż *-> C1 = przy ; true }.

%%%% Czekam‹, aż przyjdzie›.
%%%* Czekam‹, aż przyszedł›.

fw(subj(sentp(Tfz)), A, C, r(mn(n),nmo(np(n)))/poj, 3, _Poz, Neg, neut, I, Pk, Sub) --> 
	s(wyz1s),
	fzd(Tfz, nk, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [gdy,jak,jakby,jakoby,jeśli,pz,że,żeby])
      }.
%%%% Chrzani mu się‹, jak to zrobić›.
%%%% Ciekawi mnie, że przyszła.

fw(sentp(K,Tfz), A, C, Rl, O, _Poz, Neg, neut, I, Pk, Sub) -->
	s(wyz2),
	fzd(Tfz, K, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,gdy,jak,jakby,jakoby,jeśli,mie1,mie2,mie3,pz,że,żeby]),
	  \+ member(K, [bier,nk,_/_])
% Hmm, co z tym:?
%	Z = [p,np,pz,co,jaki,kto,który] 
      },
	{ Tfz = aż *-> C1 = przy ; true }.

fw(subj(sentp(mian,Tfz)), A, C, r(mn(n),nmo(np(n)))/poj, 3, _Poz, Neg, neut, I, Pk, Sub) -->
	s(wyz2s),
	fzd(Tfz, mian, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,gdy,jak,jakby,jakoby,jeśli,mie1,mie2,mie3,pz,że,żeby])
% Hmm, co z tym:?
%	Z = [p,np,pz,co,jaki,kto,który] 
      },
	{ Tfz = aż *-> C1 = przy ; true }.

%%%% Męczy go ‹to, że przyjdzie›.

fw(sentp(bier,Tfz), A, C, Rl, O, _Poz, nie(_), neut, I, Pk, Sub) -->
	s(wyz3),
	fzd(Tfz, dop, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,gdy,jak,jakby,jakoby,jeśli,mie1,mie2,mie3,pz,że,żeby])
% Hmm, co z tym:?
%	Z = [p,np,pz,co,jaki,kto,który] 
      },
	{ Tfz = aż *-> C1 = przy ; true }.

fw(sentp(bier,Tfz), A, C, Rl, O, _Poz, tak, neut, I, Pk, Sub) -->
	s(wyz4),
	fzd(Tfz, bier, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,jak,jakby,jakoby,mie1,mie2,mie3,pz,że,żeby])
% Hmm, co z tym:?
%	Z = [p,np,pz,co,jaki,kto,który] 
      },
	{ Tfz = aż *-> C1 = przy ; true }.

fw(sentp(Pm,P,Tfz), A, C, Rl, O, _Poz, Neg, neut, I, Pk, Sub) -->
	s(wyz5),
	fzd(Tfz, Pm/P, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [aż,czy,jak,jakby,jakoby,mie1,mie2,mie3,pz,że,żeby])
% Hmm, co z tym:?
%	Z = [p,np,pz,co,jaki,kto,który] 
      },
	{ Tfz = aż *-> C1 = przy ; true }.

% \subsection{oratio recta}

fw(or, A, C, Rl, O, Poz, Neg, neut, ni, Pk, Sub) -->
	s(wyor1),
	cudz(o,po),
	zdanie(Wf2, A2, C2, T2, Rl2, O2, Neg2, Dest2, I2, Pk2, na),
%	{ Wf2 \= bc(_) },
	optional(znakkonca(Dest3, po),{zgodnyznakk(Dest2,Dest3)},{}),
	cudz(z,po),
	optional(pauza(po),
		 {Poz=pre, Pkp=wpw, Pkk=wp},
		 { Poz=pre, Pkp=wpw, Pkk=0 ; Poz = post, Pkp=0, Pkk=wkw }),
	{ oblpk(Pk, [ (Pkp|wp), Pk2, (p|Pkk) ]) }.

%%%% "Nie potrafię" - odparłem.

fw(or, A, C, Rl, O, pre, Neg, neut, ni, Pk, Sub) -->
	s(wyor2),
	zdanie(Wf2, A2, C2, T2, Rl2, O2, Neg2, Dest2, I2, Pk2, na),
	{ Wf2 \= bc(_) },
	optional(znakkonca(Dest3, po),{zgodnyznakk(Dest2,Dest3)},{}),
	pauza(po),
	{ oblpk(Pk, [ (wpw|wp), Pk2, (p|wp) ]) }.

%%%% - Bolało? - spytałem.
%%%% – Chciałabym… – zaczęła.
%%%% - Cześć - powiedziała.
%%%% Co wie? - zapytał.
%%%% Poczekaj, łajdaku – pomyślałem.

fw(or, A, C, Rl, O, post, Neg, neut, ni, Pk, Sub) -->
	s(wyor3),
	dwukropek(po),
	optional(pauza(po),{},{}),
	optional(cudz(o,po),{D=t},{D=f}),
	zdanie(Wf2, A2, C2, T2, Rl2, O2, Neg2, Dest2, I2, Pk2, na),
	{ Wf2 \= bc(_) },
	optional(znakkonca(Dest3, po),{zgodnyznakk(Dest2,Dest3)},{}),
	optional(cudz(z,po),{D=t},{D=f}),
	{ oblpk(Pk, [ (0|wp), Pk2, (p|wkw) ]) }.

%%%% Kto mówi: słyszę?
%%%% Franciszek powiada: — Witajcie.
%%%% Stali tam i myśleli: Kurwa, kto to zrobił?

% Do włączenia, jeśli będą przykłady korpusowe:
% fw(or, A, C, Rl, O, post, Neg, neut, ni, Pk, Sub) -->
% 	s(wyor4),
% 	pauza(po),
% 	optional(cudz(o,po),{D=t},{D=f}),
% 	zdanie(Wf2, A2, C2, T2, Rl2, O2, Neg2, Dest2, I2, Pk2, na),
% 	{ Wf2 \= bc(_) },
% 	optional(znakkonca(Dest3, po),{zgodnyznakk(Dest2,Dest3)},{}),
% 	optional(cudz(z,po),{D=t},{D=f}),
% 	{ oblpk(Pk, [ (0|wp), Pk2, (p|wkw) ]) }.

% %%%% Kto mówi – słyszę?

% \subsection{Realizacje skoordynowane}

% Te horrendalne listy generuje się skryptem findcoord.pl:
dopuszczalna_koordynacja(
	[advp,
	 or,
	 infp(dk),infp(nd),
	 np(bier),np(cel),np(dop),np(mian),np(narz),
	 sentp(aż),sentp(gdy),sentp(jak),sentp(jakoby),sentp(jeśli),sentp(kiedy),
	 sentp(pz),sentp(że),sentp(żeby),sentp(żeby2),
	 prepnp(dla,dop),prepnp(do,dop),prepnp(ku,cel),
	 prepnp(na,bier),prepnp(na,miej),
	 prepnp('na polu',dop),prepnp('na temat',dop),
	 prepnp(nad,narz),
	 prepnp(o,bier),prepnp(o,miej),
	 prepnp(od,dop),prepnp(po,bier),prepnp(po,miej),prepnp('po stronie',dop),
	 prepnp(pod,bier),prepnp('pod względem',dop),prepnp(przeciw,cel),prepnp(przed,narz),prepnp(przez,bier),prepnp(przy,miej),prepnp(u,dop),prepnp(w,bier),prepnp(w,miej),prepnp('w dziedzinie',dop),prepnp('w kwestii',dop),prepnp('w sprawie',dop),prepnp(według,dop),prepnp(wskutek,dop),prepnp(z,dop),prepnp(z,narz),prepnp('z powodu',dop),prepnp(za,bier),prepnp(za,narz),
	 sentp(bier,gdy),sentp(bier,int),sentp(bier,jak),sentp(bier,jakoby),sentp(bier,jeśli),sentp(bier,kiedy),sentp(bier,że),sentp(bier,żeby),sentp(bier,żeby2),
	 sentp(cel,jak),sentp(cel,jakoby),sentp(cel,pz),sentp(cel,że),sentp(cel,żeby),sentp(cel,żeby2),sentp(dop,aż),sentp(dop,gdy),sentp(dop,jak),sentp(dop,jakoby),sentp(dop,kiedy),sentp(dop,pz),sentp(dop,że),sentp(dop,żeby),sentp(dop,żeby2),sentp(mian,gdy),sentp(mian,int),sentp(mian,jak),sentp(mian,jakoby),sentp(mian,jeśli),sentp(mian,kiedy),sentp(mian,że),sentp(mian,żeby),sentp(mian,żeby2),sentp(narz,jak),sentp(narz,pz),sentp(narz,że),sentp(narz,żeby),
	 sentp(dla,dop,pz),sentp(dla,dop,żeby),sentp(do,dop,jak),sentp(do,dop,pz),sentp(do,dop,że),sentp(do,dop,żeby),sentp(do,dop,żeby2),sentp(ku,cel,że),sentp(ku,cel,żeby),sentp(na,bier,aż),sentp(na,bier,gdy),sentp(na,bier,jak),sentp(na,bier,jakby),sentp(na,bier,kiedy),sentp(na,bier,pz),sentp(na,bier,że),sentp(na,bier,żeby),sentp(na,bier,żeby2),sentp(na,miej,jak),sentp(na,miej,pz),sentp(na,miej,że),sentp(na,miej,żeby),sentp(na,miej,żeby2),sentp(na,str,pz),sentp(na,str,że),sentp(nad,narz,jak),sentp(nad,narz,pz),sentp(nad,narz,że),sentp(nad,narz,żeby),sentp(o,bier,jakoby),sentp(o,bier,pz),sentp(o,bier,że),sentp(o,bier,żeby),sentp(o,bier,żeby2),sentp(o,miej,jak),sentp(o,miej,jakoby),sentp(o,miej,pz),sentp(o,miej,że),sentp(o,miej,żeby),sentp(o,miej,żeby2),sentp(od,dop,jakoby),sentp(od,dop,pz),sentp(od,dop,że),sentp(od,dop,żeby),sentp(po,miej,jak),sentp(po,miej,pz),sentp(po,miej,że),sentp(przeciw,cel,gdy),sentp(przeciw,cel,jak),sentp(przeciw,cel,jakoby),sentp(przeciw,cel,kiedy),sentp(przeciw,cel,pz),sentp(przeciw,cel,że),sentp(przeciw,cel,żeby),sentp(przed,narz,pz),sentp(przed,narz,że),sentp(przed,narz,żeby),sentp(przez,bier,pz),sentp(przez,bier,że),sentp(przy,miej,jak),sentp(przy,miej,pz),sentp(przy,miej,że),sentp(przy,miej,żeby),sentp(w,bier,jak),sentp(w,bier,pz),sentp(w,bier,że),sentp(w,bier,żeby),sentp(w,bier,żeby2),sentp(w,miej,jak),sentp(w,miej,pz),sentp(w,miej,że),sentp(w,miej,żeby),sentp(z,dop,jak),sentp(z,dop,pz),sentp(z,dop,że),sentp(z,dop,żeby),sentp(z,narz,jak),sentp(z,narz,jakby),sentp(z,narz,pz),sentp(z,narz,że),sentp(z,narz,żeby),sentp(z,narz,żeby2),sentp(za,bier,pz),sentp(za,bier,że),sentp(za,bier,żeby),sentp(za,narz,gdy),sentp(za,narz,jak),sentp(za,narz,kiedy),sentp(za,narz,pz),sentp(za,narz,rel),sentp(za,narz,że),sentp(za,narz,żeby),sentp(za,str,pz)]).
dopuszczalna_koordynacja([prepnp(wokół,dop),sentp(wokół,dop,pz),
			  sentp(wokół,dop,że),sentp(wokół,dop,żeby)]).
dopuszczalna_koordynacja([prepnp(wobec,dop),sentp(wobec,dop,pz),sentp(wobec,dop,że)]).
dopuszczalna_koordynacja([prepnp(poza,bier),sentp(poza,bier,pz),sentp(poza,bier,że)]).
dopuszczalna_koordynacja([prepnp(pod,narz),sentp(pod,narz,że),sentp(pod,narz,żeby)]).
dopuszczalna_koordynacja([prepnp(koło,dop),sentp(koło,dop,żeby)]).
dopuszczalna_koordynacja([prepnp('co do',dop),sentp('co do',dop,jakoby),
			  sentp('co do',dop,pz),sentp('co do',dop,że),
			  sentp('co do',dop,żeby)]).
dopuszczalna_koordynacja([prepnp(bez,dop),sentp(bez,dop,że),sentp(bez,dop,żeby)]).
dopuszczalna_koordynacja([np(part),sentp(part,że)]).

% Warunek iteracyjny: typy fraz wymaganych muszą pochodzić z tej samej
% listy Koord (wybranej spośród dopuszczalna_koordynacja/1 przez
% pierwszy element sekwencji), nie pozwalam też, żeby sąsiednie typy
% były równe, bo zacznie nam się kitłasić z koordynacją w obrębie typów:

dopuszczalna_koord_iter([Tfw1|TT]/Koord, Tfw2, TT2/Koord) :-
    Tfw1 \= Tfw2, member(Tfw2, Koord),
    (member(Tfw2,TT) *-> TT2=[Tfw1|TT] ; TT2=[Tfw2,Tfw1|TT]).

% \subsubsection{Realizacje szeregowe}

% sp fraza (, sp fraza)* , sp fraza
fw(Tfw, A, C, Rl, O, Poz, Neg, Dest, I, Pk, Sub) -->
	s(wys1),
	spójnik(sz,Oz,ni,na),
	{ \+ member(Oz, [przec,lub]) },
	fw(Tfw1, A, C, Rl, O, Poz, Neg, Dest, I, Pk1, po),
	{ dopuszczalna_koordynacja(Koord), member(Tfw1, Koord) },
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,na),
	      fw(Tfw3, A, C, Rl, O, Poz, Neg, Dest, I, Pk3, po)
	    ]^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
	    ^[dopuszczalna_koord_iter, [Tfw1]/Koord, Tfw3, TfwKoord]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,na),
	{ sprawdz_neg(Oz,Neg) },
	fw(Tfw6, A, C, Rl, O, Poz, Neg, Dest, I, Pk6, po),
	{ oblpk(Pk,[(0|wp), Pk1 | PkL]),
	  dopuszczalna_koord_iter(TfwKoord, Tfw6, Tfw/_)
	  }.
%%%% Chciała albo pisać, albo żeby zniknęli.
%%%% Chciała albo pisać, albo książkę.


% fraza (, fraza)* sp fraza
fw(Tfw, A, C, Rl, O, Poz, Neg, Dest, I, Pk, Sub) -->
	s(wys3),
	fw(Tfw1, A, C, Rl, O, Poz, Neg, Dest, I, Pk1, po),
	{ dopuszczalna_koordynacja(Koord), member(Tfw1, Koord) },
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fw(Tfw3, A, C, Rl, O, Poz, Neg, Dest, I, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	    ^[dopuszczalna_koord_iter, [Tfw1]/Koord, Tfw3, TfwKoord]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz = przec ->
	  Pk5 = (p|wp) ; Pk5 = (db|wp) },
	{ sprawdz_neg(Oz,Neg) },
	fw(Tfw6, A, C, Rl, O, Poz, Neg, Dest, I, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  dopuszczalna_koord_iter(TfwKoord, Tfw6, Tfw/_) }.

%%%% Kazał, żeby milczeli i czytać.

%  \section{FRAZA LUŹNA}

% Frazy luźne realizowane przez przyimkowe, rzeczownikowe i
% przysłówkowe mogą być opcjonalnie ujęte w parę przecinków.  W
% związku z tym opisujące je reguły są w dwóch wariantach.  Przecinki
% (realne lub wirtualne) muszą albo być po obu stronach, albo po
% żadnej.

% co z tym warunkiem?  Był w tej i następnych 3 regułach.
% { zróżne(Z, ['byxx','choćby','czyżby',
% 	             'gdyby','jakby','jakoby','żeby'], NZ) }.

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu1),
	fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [(bp|p),Pk1, Pk2]) },{ Pk=Pk1 }).

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu1p),
	przec(Pk0,po),
	fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [Pk0,Pk1,Pk2]) },
	                       { oblpk(Pk, [Pk0,Pk1,(p|bp)]) }).

%%%% Za papieżem‹, na klęczkach,› podążyli wyznawcy.


fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu2),
	fno(P, Rl1, O1, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk1, na), 
	{ równe(P, [cel,bier,narz]), Kl \= przym },
% zablokowany dop — bo eksplozja luźności
	optional(przec(Pk2,po),{ oblpk(Pk, [(bp|p),Pk1, Pk2]) },{ Pk=Pk1 }).

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu2p),
	przec(Pk0,po),
	fno(P, Rl1, O1, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk1, na), 
	{ równe(P, [cel,bier,narz]), Kl \= przym },
	optional(przec(Pk2,po),{ oblpk(Pk, [Pk0,Pk1,Pk2]) },
	                       { oblpk(Pk, [Pk0,Pk1,(p|bp)]) }).

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu3),
	fps(St, Kl, Neg, Dest, I, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [(bp|p),Pk1, Pk2]) },{ Pk=Pk1 }).

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu3p),
	przec(Pk0,po),
	fps(St, Kl, Neg, Dest, I, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [Pk0,Pk1,Pk2]) },
	                       { oblpk(Pk, [Pk0,Pk1,(p|bp)]) }).
%%%% Za Piotrem, dostojnie, podążyli  jego współpracownicy.

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu4),
	modpart(fin, Neg, Dest, I, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [(bp|p),Pk1, Pk2]) },{ Pk=Pk1 }).

fl(A, C, Rl, O, Neg, Dest, ni, Pk, Sub) -->
	s(lu4p),
	przec(Pk0,po),
	modpart(fin, Neg, Dest, ni, Pk1, na),
	optional(przec(Pk2,po),{ oblpk(Pk, [Pk0,Pk1,Pk2]) },
	                       { oblpk(Pk, [Pk0,Pk1,(p|bp)]) }).


% Frazy luźne wołaczowe (czasem realizowane przez mianownik):
%
% W poniższych regułach przecinki (realne lub wirtualne) są
% obligatoryjne.  Realizację przez mianownik dopuszczam (na razie?),
% wyłącznie jeżeli fraza luźna jest na samym początku lub samym końcu
% wypowiedzenia.

fl(A, C, Rl, 2, Neg, neut, ni, Pk, Sub) -->
	s(lu12),
	przec(Pk1,po), 
	fno(P, Rl, O1, wym([],_,_), Kl, Zap, pre, Neg1, neut, ni, Pk2, na),
	{ member(P,[wol,mian]) },
	{ Kl \= przym },
	optional(przec(Pk3,po),{P=wol},{P=wol *-> Pk3=(p|bp) ; Pk3=(p|wkw)}),
	{ oblpk(Pk, [Pk1,Pk2,Pk3]) }.

%%%% Czytałaś, dziewczyno.
%%%* Czytałaś, chłopcze.
%%%% Wiesz, Marek…
%%%% Chodź, Piotrze, tutaj!

fl(A, C, Rl, 2, Neg, neut, ni, Pk, Sub) -->
	s(lu12o),
	fno(P, Rl, _O1, wym([],_,_), Kl, Zap, pre, Neg1, neut, ni, Pk2, na),
	{ member(P,[wol,mian]) },
	{ Kl \= przym },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ P = wol *-> Pk0=bp ; Pk0=wpw },
	{ oblpk(Pk, [(Pk0|p),Pk2,Pk3]) }.

%%%% Marku, chodź!
%%%% Marek, chodź!

fl(A, C, Rl, O, Neg, neut, ni, Pk, Sub) -->
	s(lu13),
	przec(Pk1,po), 
	fno(wol, Rl1, _O1, wym([],_,_), Kl, Zap, pre, Neg1, neut, ni, Pk2, na),
%	{ member(P,[wol,mian]) },
	{ Kl \= przym },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ równe(O, [1,3]),
	  oblpk(Pk, [Pk1,Pk2,Pk3]) }.

%%%% Czytały, chłopcze.
%%%% Czytałem, dziewczyno.
%%%% Przeżyjemy to, Adamie.

fl(A, C, Rl, O, Neg, neut, ni, Pk, Sub) -->
	s(lu13o),
	fno(P, Rl1, _O1, wym([],_,_), Kl, Zap, pre, Neg1, neut, ni, Pk2, na),
	{ równe(O, [1,3]), member(P,[wol,mian]) },
	{ Kl \= przym },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ P = wol *-> Pk0=bp ; Pk0=wpw },
	{ oblpk(Pk, [(Pk0|p),Pk2,Pk3]) }.

%%%% Adamie, przeżyjemy to.
%%%% Adam, przeżyjemy to.

% !!! Z tym coś trzeba zrobić:
% fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
% 	s(lu8),
% 	agl(Rl, O, I), 
% 	{ Z = ['byxx','choćby','czyżby','gdyby','jakby','jakoby','żeby']}.


% Frazą luźną może być dowolna fraza przyimkowo-przymiotnikowa z formą
% poprzyimkową (por. uwagę przy formaprzym/adjp):
fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu14),
	fpmpt(Pm, pop, Kl, Zap, Neg, Dest, I, Pk, na).

%%%% Wymknął się po angielsku.
%%%% Znam go od dawna.


% (…)
fl(A, C, Rl, O, Neg, Dest, I, (0|0), Sub) -->
	s(lu30),
	nawias(o,TN,po),
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	nawias(z,TN,po).

fl(A, C, Rl, O, Neg, Dest, I, (0|0), Sub) -->
	s(lu31),
	nawias(o,TN,po),
	[morf('…',_,interp)],
	nawias(z,TN,po).

% \subsection{realizacja przymiotnikowa}

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu15),
	fpt(P, RL, St, wym([],_,_), Kl, Zap, Neg, Dest, I, Pk1, na),
	{ równe(P, [mian,dop,cel,bier,narz]) },
	optional(przec(Pk2,po),{ oblpk(Pk, [(bp|p),Pk1, Pk2]) },{ Pk=Pk1 }).

%%%% Dziewczyna przyszła ‹zmęczona›.

fl(A, C, Rl, O, Neg, Dest, I, Pk, Sub) -->
	s(lu15p),
	przec(Pk0,po),
	fpt(P, RL, St, wym([],_,_), Kl, Zap, Neg, Dest, I, Pk1, na),
	{ równe(P, [mian,dop,cel,bier,narz]) },
	optional(przec(Pk2,po),{ oblpk(Pk, [Pk0,Pk1,Pk2]) },
	                       { oblpk(Pk, [Pk0,Pk1,(p|bp)]) }).

%%%% Dziewczyna ledwie przyszła, ‹zmęczona całodzienną pracą›.

% \subsection{Realizacje imiesłowowe}

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw1),
	przec(Pk1,po),
	fwe(psw, A1, C, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ oblpk(Pk, [Pk1,Pk2,Pk3]),
	  wymagania_zamknij(Wym) }.
% MW: dlaczego równy czas?

%%%% Wchodziliśmy, depcząc trawnik, do domu.
%%%% Wchodziliśmy do domu, depcząc trawnik.

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw2), 
	przec(Pk1,po), 
	fwe(psu, A1, prze, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ oblpk(Pk, [Pk1,Pk2,Pk3]),
	  wymagania_zamknij(Wym)  }.

fl(A, przy, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw3),
	przec(Pk1,po), 
	fwe(psu, A1, C, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ C \= prze,
	  oblpk(Pk, [Pk1,Pk2,Pk3]),
	  wymagania_zamknij(Wym)  }.

% W następnych regułach rozluźniamy wymaganie przecinka, bo w wypadku
% pewnych fraz imiesłowowych jest wyraźna tendencja do pomijania
% oprzecinkowania.  Niestety nie bardzo mamy koncept, kiedy dopuszczać
% pominięcie przecinka (por. przykłady), więc dopuszczamy pominięcie
% zawsze.

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw1o),
	fwe(psw, A1, C, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{ oblpk(Pk, [(bp|p),Pk2, Pk3]) },{ Pk=Pk2 }),
	{ wymagania_zamknij(Wym) }.
% MW: dlaczego równy czas?

%%%% Depcząc trawnik, wchodziliśmy do domu.
%%%% Wchodziliśmy ‹depcząc› do domu.
%%%% Wchodziliśmy ‹depcząc jej starannie utrzymany trawnik przed domem›.
%%%! Wchodziliśmy ‹depcząc trawnik› do domu.
%%%* Wchodziliśmy depcząc trawnik, do domu.
%%%* Wchodziliśmy depcząc, do domu.
%%%% Wchodziliśmy do domu ‹depcząc trawnik›.
%%%? Wchodziliśmy ‹depcząc jej starannie utrzymany trawnik przed domem› i rozmawialiśmy.

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw2o), 
	fwe(psu, A1, prze, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{ oblpk(Pk, [(bp|p),Pk2, Pk3]) },{ Pk=Pk2 }),
	{ wymagania_zamknij(Wym) }.

%%%% Umrze przeczytawszy książkę kucharską.

fl(A, przy, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luw3o),
	fwe(psu, A1, C, T1, Rl1, O1, Wym, Neg1, neut, I, Pk2, na),
	optional(przec(Pk3,po),{ oblpk(Pk, [(bp|p),Pk2, Pk3]) },{ Pk=Pk2 }),
	{ C \= prze,
	  wymagania_zamknij(Wym)  }.

% \subsection{Realizacje zdaniowe}


fl(nd, C, Rl, O, tak, neut, I, Pk, Sub) -->
	s(luz1),
	fzd(dopóki, nk, A1, C1, T1, Neg1, I, Pk, na).

%%%% Wiedział‹, dopóki czytano›, że żyje.
%%%* Poznał‹, dopóki czytano›, że żyje.

fl(A, C, Rl, O, nie(nie), neut, I, Pk, Sub) -->
	s(luz2),
	fzd(dopóki, nk, A1, C1, T1, Neg1, I, Pk, na).

%%%% Nie wiedział‹, dopóki czytano›, że żyje.
%%%% Nie poznał‹, dopóki czytano›, że żyje.

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luz3),
	fzd(Tfz, nk, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz, [choćby,gdyby])%% , 
         %% C \= prze 
	 %% powinno być ograniczenie czasu, ale w momencie tworzenia
	 %% frazy nie znamy czasu obejmującego ją zdania :-(
     }.

%%%% Przyjdzie‹, choćby miał pęknąć›.
%%%% Przyszłyby‹, gdyby się zmęczył,› do domu.


% Warunek sprawdzający, że tryb T1 jest ustalony, ma zapobiec
% analizom, gdzie fzd ma centrum w bezokoliczniku:
fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luz9),
	fzd(Tfz, nk, A1, C1, T1, Neg1, I, Pk, na),
	{ nonvar(T1),
	member(Tfz,[aż,gdy,zanim,bo,wz(co,_),chociaż,czy,jak,jakby,jeśli,podczas,ponieważ])}.

%%%% Przyszedł‹, gdy wszyscy czytali,› do domu.
%%%% Przyszedł‹, gdy czytano,› do domu.
%%%* Przyszedł‹, gdy czytać,› do domu.
%%%% Wyglądał‹, jakby czytał›.
%%%% Poprawiał wciąż aparat w uchu‹, jakby chciał lepiej usłyszeć›.
%%%% Jan umarł‹, co mnie ucieszyło›.
%%%% Jan umarł‹, o czym nie wiedziano›.
%%%% Jan umarł‹, przez co przybyło sierot›.

fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luz10),
	fzd(Tfz, K, A1, C1, T1, Neg1, I, Pk, na),
	{ member(Tfz,[żeby]),
	  member(K, [nk, po/bier])
	}.

%%%% Przyszedł‹, żeby go wszyscy chwalili,› do domu.
%%%% Przyszedł‹po to, żeby go wszyscy chwalili,› do domu.
%%%% Przyszedł‹, żeby go chwalono,› do domu.
%%%% Przyszedł‹po to właśnie, żeby go chwalono,› do domu.
%%%% Przyszedł‹, aby czytać,› do domu.
%%%% Po krótkiej rozmowie czwórka mężczyzn udała się na pobliskie podwórko‹, aby opróżnić butelkę›.

% fraza luźna względna:
fl(A, C, Rl, O, Neg, neut, I, Pk, Sub) -->
	s(luz11),
	fzd(wz(_,przys), nk, A1, C1, T1, Neg1, I, Pk, na).

%%%% Idź, którędy możesz.
%%%% Czekaj, gdzie oni czekali.
%%%% Idź, dokąd poszli tamci.

% \section{FRAZA WERBALNA}

% \subsection{Prosta fraza werbalna}

fwe(Wf, A, C, T, Rl, O, Wym, Neg, neut, I, (0|0), Sub) -->
	s(we1),
	formaczas(Wf, A, C, T, Rl, O, Wym, Neg, na ),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

% \subsection{Fraza werbalna z negacją}

fwe(Wf, A, C, T, Rl, O, Wym, nie(_), neut, I, (0|0), Sub) -->
	s(we2),
	partykuła(nie, po),
	formaczas(Wf, A, C, T, Rl, O, Wym, tak, na ),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

% \subsection{Wysycanie wymagań wewnątrz frazy werbalnej}
%
% Wysycanie wymagań wewnątrz frazy werbalnej dopuszczamy swobodnie dla
% fraz niefinitywnych, a więc takich, które mają wartość bok, psu, psw
% wyróżnika fleksyjnego.  Wymagania finitywnych form czasowników mogą
% zostać wysycone wewnątrz frazy werbalnej pod warunkiem, że następnie
% stanie się ona częścią frazy skoordynowanej.  Sprawdzeniem tego
% sterują odpowiednie wartości atrybutu Wym (zob. gfjp2_wymagania).

% Istotnym elementem reguły wew1 jest wymaganie, aby sekwencja fraz
% wymaganych była niepusta — bez niego reguła byłaby jałowo
% rekurencyjna.


% Warunek realizujący uzgodnienia negacji z podrzędnikami frazy
% bezokolicznikowej.  Argumenty: wyr. fleksyjny, negacja wynikowa,
% negacja centrum, negacja argumentów (zunifikowana).  Warunek
% zaadoptowany z artykułu Świdzińskiego i Przepiórkowskiego
% 1997, s. 13.
obl_neg_fwe(psu, Neg,Neg,Neg).
obl_neg_fwe(psw, Neg,Neg,Neg).
obl_neg_fwe(os,  Neg,Neg,Neg).
obl_neg_fwe(bos, Neg,Neg,Neg).
%                       Frazy bezokolicznikowe:
% Jeżeli Neg2 jest nieustalone, to znaczy, że argumenty są obojętne
% negacyjnie i fwe będzie się zachowywać jak „goły” czasownik:
obl_neg_fwe(bok, Neg,Neg,Neg2) :- var(Neg2), !, Neg=Neg2.
% W przeciwnym wypadku gdy lokalny czasownik niezaprzeczony, to
% przekazujemy w górę wymaganie konkretnej negatywności pochodzącej od
% argumentów:
obl_neg_fwe(bok, req(Neg),tak,Neg).
% Gdy lokalny czasownik zaprzeczony, fwe zachowuje się jak goły
% zaprzeczony czasownik:
obl_neg_fwe(bok, nie(Neg),nie(Neg),nie(Neg)).
% Niemożliwa kombinacja zaprzeczonego centrum i argumentów
% zdeklarowanych jako niezaprzeczone:

%%%* Chce ‹nie budować dom›.
%%%* Nie chce ‹nie budować dom›.

%%%% Nie wolno ‹rozmawiać z gośćmi i czytać książek›!
%%%% Wolno ‹rozmawiać z gośćmi i czytać książki›!
%%%* Wolno ‹rozmawiać z gośćmi i czytać książek›!
%%%* Wolno ‹nie rozmawiać z gośćmi i czytać książek›!
%%%% Może ‹lubić i poważać› kurczęta.
%%%? Może ‹nie lubić i poważać› kurczęta.
%%%* Może ‹nie lubić i poważać› kurcząt.
%%%% Może ‹nie lubić i nie poważać› kurcząt.
%%%* Nie lubię i poważam kurcząt.
%%%% Nie lubię i nie poważam kurcząt.

fwe(Wf, A, C, T, Rl, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wew1),
        fwe(Wf, A, C, T, Rl, O, Wym1, Neg1, Dest1, I, Pk1, na),
	{ wymagania_czyste(_,Wym1) },
	{ member(Wf, [bok,psu,psw]) *-> wykluczpodmiot(Wym1, WymN) ; WymN=Wym1 },
	sequence_of([
		    fw(W2, A, C, Rl, O, post, Neg2, Dest2, ni, Pk2, po)
		        ^[oblwym_iter, WymN, W2, ResztaWym],
		    fl(A, C, Rl, O, Neg2, Dest2, ni, Pk2, po)
		        ^[najwyżej3, 0, _, _]
		    ]
		    ^[obldest_iter, Dest1, Dest2, Dest]
		    ^[sprawdz_pk_iter, Pk1, Pk2, Pk]
		    ^[conajmniej1, 0, _, 1]
		),
	{ wymagania_oznacz_użyte(ResztaWym,Wym),
	  obl_neg_fwe(Wf, Neg,Neg1,Neg2) }.

%%%% Jan chciał ‹sprzedać ten dom›.
%%%% Jan nie chciał ‹sprzedać tego/żadnego domu›.
%%%% Jan chciał ‹nie sprzedać tego domu›.
%%%* Jan chciał ‹sprzedać tego domu›.
%%%% Jan chciał ‹nie sprzedać nic›.
%%%% Jan chciał ‹nie sprzedać niczego›.
%%%% Jan nie chciał ‹nie sprzedać niczego›.
%%%% Jan nie chciał ‹nie sprzedać tego/żadnego domu›.
%%%* Jan chciał ‹nie sprzedać ten dom›.
%%%* Jan chciał ‹sprzedać nic›.
%%%% Kazał ‹przynieść dokumenty i poczekać›.
%%%% Chciał ‹‹pisać i czytać› listy›.

fwe(Wf, A, C, T, Rl, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wew2),
	fw(W1, A, C, Rl, O, pre, Neg2, Dest1, I, Pk1, po),
	sequence_of([ 
		      fw(W2, A, C, Rl, O, pre, Neg2, Dest2, ni, Pk2, po)
		        ^[zroblistę_iter, [W1], W2, PreFfWym],
		      fl(A, C, Rl, O, Neg2, Dest2, ni, Pk2, po)
		        ^[najwyżej3, 0, _, IleFl]
		    ]
		    ^[obldest_iter, Dest1, Dest2, DestPreF]
		    ^[sprawdz_pk_iter, Pk1, Pk2, PkPreF]
		   ),
        fwe(Wf, A, C, T, Rl, O, Wym4, Neg1, Dest4, ni, Pk4, na),
	{ wymagania_czyste(_,Wym4) },
	{ member(Wf, [bok,psu,psw]) *-> wykluczpodmiot(Wym4, WymN) ; WymN=Wym4 },
	{ obldest_iter(DestPreF, Dest4, DestPostF),
	  sprawdz_pk_iter(PkPreF, Pk4, PkPostF),
	  wyjmijl(PreFfWym, WymN, PostFfWym) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg2, Dest5, ni, Pk5, po)
		        ^[oblwym_iter, PostFfWym, W5, ResztaWym],
		      fl(A, C, Rl, O, Neg2, Dest5, ni, Pk5, po)
		        ^[najwyżej3, IleFl, _, _]
		    ]
		    ^[obldest_iter, DestPostF, Dest5, Dest]
		    ^[sprawdz_pk_iter, PkPostF, Pk5, Pk]
		   ),
	{ wymagania_oznacz_użyte(ResztaWym,Wym),
	  obl_neg_fwe(Wf, Neg,Neg1,Neg2)  }.

%%%% Mogę chcieć ‹to napisać›.
%%%% Nie mogę chcieć ‹tego napisać›.

fwe(Wf, A, C, T, Rl, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wew3),
	fl(A, C, Rl, O, Neg2, Dest1, I, Pk1, po),
	sequence_of([ 
		      fw(W2, A, C, Rl, O, pre, Neg2, Dest2, ni, Pk2, po)
		        ^[zroblistę_iter, [], W2, PreFfWym],
		      fl(A, C, Rl, O, Neg2, Dest2, ni, Pk2, po)
		        ^[najwyżej3, 0, _, IleFl]
		    ]
		    ^[obldest_iter, Dest1, Dest2, DestPreF]
		    ^[sprawdz_pk_iter, Pk1, Pk2, PkPreF]
		   ),
        fwe(Wf, A, C, T, Rl, O, Wym4, Neg1, Dest4, ni, Pk4, na),
	{ wymagania_czyste(_,Wym4) },
	{ member(Wf, [bok,psu,psw]) *-> wykluczpodmiot(Wym4, WymN) ; WymN=Wym4 },
	{ obldest_iter(DestPreF, Dest4, DestPostF),
	  sprawdz_pk_iter(PkPreF, Pk4, PkPostF),
	  wyjmijl(PreFfWym, WymN, PostFfWym) },
	sequence_of([ 
		      fw(W5, A, C, Rl, O, post, Neg2, Dest5, ni, Pk5, po)
		        ^[oblwym_iter, PostFfWym, W5, ResztaWym],
		      fl(A, C, Rl, O, Neg2, Dest5, ni, Pk5, po)
		        ^[najwyżej3, IleFl, _, _]
		    ]
		    ^[obldest_iter, DestPostF, Dest5, Dest]
		    ^[sprawdz_pk_iter, PkPostF, Pk5, Pk]
		   ),
	{ wymagania_oznacz_użyte(ResztaWym,Wym),
	  obl_neg_fwe(Wf, Neg,Neg1,Neg2)  }.


% \subsection{Realizacje równorzędne}

% fwe, sp fwe
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wer1),
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, ni, Pk3, po),
	{ obldest(Dest,[Dest1,Dest3]),
	  oblpk(Pk,[Pk1,Pk2,Pk3]),
	  zgodne_iter(R1, R3, R),
	  zgodne_iter(L1, L3, L),
	  zgodne_iter(O1, O3, O),
	  neg_do_sąsiada(Neg1, Neg3, Neg),
	  oblwym_koord(Wym, r1:Oz, [Wym1, Wym3])
	}.
%%%% Leszek ‹odchodzi, ale odwraca się jeszcze›.

% schemat inkorporacyjny: fwe, fwe(sp_ink)
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wer2),
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, neut, I, Pk1, po),
%	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,na),
	fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, i(r,Oz), Pk3, po),
	{ obldest(Dest,[neut,Dest3]),
	  oblpk(Pk,[Pk1,(p|wp),Pk3]),
	  zgodne_iter(R1, R3, R),
	  zgodne_iter(L1, L3, L),
	  zgodne_iter(O1, O3, O),
	  neg_do_sąsiada(Neg1, Neg3, Neg),
	  oblwym_koord(Wym, r2:Oz, [Wym1, Wym3])
	 }.
%%%? Leszek ‹odchodzi, odwraca natomiast się jeszcze›.

% sp fwe, sp fwe
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wer3),
	spójnik(rl,Oz,I,na),
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, Dest1, ni, Pk2, po),
	{ tylko_neut_pyt(Dest1) },
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, ni, Pk5, po),
	{ obldest(Dest,[Dest1,Dest3]),
	  oblpk(Pk,[Pk2,Pk3,Pk5]),
	  zgodne_iter(R1, R3, R),
	  zgodne_iter(L1, L3, L),
	  zgodne_iter(O1, O3, O),
	  neg_do_sąsiada(Neg1, Neg3, Neg),
	  oblwym_koord(Wym, r3:Oz, [Wym1, Wym3])
	}.
%%%% Leszek ‹nie tylko może, ale i chce› czytać książkę.
%%%% Leszek ‹nie tylko nie chce, ale i nie może› czytać książki.
%%%* Leszek ‹nie tylko może, ale i nie chce› czytać książkę.
%%%* Leszek ‹nie tylko może, ale i nie chce› czytać książki.
%%%% Weterynarz ‹nie tylko oczyścił i opatrzył ranę, ale i zaaplikował środek przeciwbólowy›.

% \subsection{Realizacje szeregowe}

% Następujący warunek iterowany służy do sprawdzenia, czy wszystkie
% człony szeregu mają wspólną wartość atrybutu (np. rodzaju).  Jeśli
% mają, to wynikiem obliczenia jest wynik unifikacji wszystkich (i
% może się on np. uzgodnić ze wspólnym podmiotem dla całości), ale
% jeśli unifikacja zawodzi, warunek skutkuje wartością specjalną
% mie(szana) (która nie uzgodni się z podmiotem, ale pozwoli utworzyć frazę).
zgodne_iter(X,X,X) :- !.
zgodne_iter(_,_,mie).
%%%% Jan ‹czytał i pisał› książkę.
%%%* Jan ‹czytał i pisała› książkę.
%%%% ‹Jan chciał i Maria chciała› czytać.

% Wersja specjalna, której użyjemy do uzgodnień negacji, która wydaje
% się „uzgadniać do sąsiada”.  Wersja ta pokazuje wartość dla
% pierwszego i ostatniego członu w szeregu.  Wykluczamy przy tym
% możliwość wystąpienia mieszaniny różnych wartości „wymuszonych” req.

neg_do_sąsiada(X,X,X) :- !.
neg_do_sąsiada(X,req(X),req(X)) :- !.
neg_do_sąsiada(req(X),X,req(X)) :- !.
neg_do_sąsiada(X/Y,Z,X/Z) :- !, 
	once(Z \= req(_) ; (X\=req(_), Y\=req(_)); X=Z; Y=Z).
neg_do_sąsiada(X,Y,X/Y) :- X\=req(_); Y\=req(_).


% sp z (, sp z)* , sp z
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wes1),
	spójnik(sz,Oz,ni,na),
	{ \+ member(Oz, [przec,lub]) },
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,po),
	      fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, ni, Pk3, po)
	    ]^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WymL, Wym3, [Wym6]]
	     ^[zgodne_iter, R1, R3, RPostSeq]
	     ^[zgodne_iter, L1, L3, LPostSeq]
	     ^[zgodne_iter, O1, O3, OPostSeq]
	     ^[neg_do_sąsiada, Neg1, Neg3, NegPostSeq]
	     ^[A3]^[C3]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,po),
	{ Oz \= czy },
	fwe(Wf, A6, C6, T, R6/L6, O6, Wym6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[(0|0), Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  zgodne_iter(RPostSeq, R6, R),
	  zgodne_iter(LPostSeq, L6, L),
	  zgodne_iter(OPostSeq, O6, O),
	  neg_do_sąsiada(NegPostSeq, Neg6, Neg),
	  oblwym_koord(Wym, sz1:Oz, [Wym1 | WymL])
	}.

%%%% Piotr wieczorami ‹albo czyta książki, albo listy pisze›.
%%%% Piotr odpoczywa, ‹drąc albo paląc› książki.

% z (sp z ,)+ sp z
% + a nie *, bo schemat bez powtarzanego elementu załatwi s3
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wes2),
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ spójnik(sz,Oz,ni,po),
	      fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, ni, Pk3, po),
	      przec(Pk4,po)
            ]^[trzy_na_listę, PkL, [(0|0),Pk3,(p|wp)], [(0|0),Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WymL, Wym3, [Wym6]]
	     ^[zgodne_iter, R1, R3, RPostSeq]
	     ^[zgodne_iter, L1, L3, LPostSeq]
	     ^[zgodne_iter, O1, O3, OPostSeq]
	     ^[neg_do_sąsiada, Neg1, Neg3, NegPostSeq]
	     ^[A3]^[C3]^[Neg3]
	     ^[conajmniej1, 0, _, 1]
	]),
	spójnik(szk,Oz,ni,na),
	{ różne(Oz, [przec,czy]) },
	fwe(Wf, A6, C6, T, R6/L6, O6, Wym6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  zgodne_iter(RPostSeq, R6, R),
	  zgodne_iter(LPostSeq, L6, L),
	  zgodne_iter(OPostSeq, O6, O),
	  neg_do_sąsiada(NegPostSeq, Neg6, Neg),
	  oblwym_koord(Wym, sz2:Oz, [Wym1 | WymL])
	}.

%%%% Piotr ‹czyta albo pracuje, albo recytuje poezję›.

% REGUŁY SZEREGOWANIA s3:
%
% • Szereg przecinkowy nie może być nieostatnim składnikiem szeregu.
%
% • Szereg nie może być ostatnim składnikiem szeregu przecinkowego.
%

% z (, z)* sp z
fwe(Wf, A, C, T, R/L, O, Wym, Neg, Dest, I, Pk, Sub) --> s(wes3),
	fwe(Wf, A, C, T, R1/L1, O1, Wym1, Neg1, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fwe(Wf, A3, C3, T, R3/L3, O3, Wym3, Neg3, Dest3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, WymL, Wym3, [Wym6]]
	     ^[zgodne_iter, R1, R3, RPostSeq]
	     ^[zgodne_iter, L1, L3, LPostSeq]
	     ^[zgodne_iter, O1, O3, OPostSeq]
	     ^[neg_do_sąsiada, Neg1, Neg3, NegPostSeq]
	     ^[A3]^[C3]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz \= czy },
	{ Oz = przec -> Pk5 = (p|wp) ; Pk5 = (db|0) },
	fwe(Wf, A6, C6, T, R6/L6, O6, Wym6, Neg6, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_iter(DestPostSeq,Dest6,Dest),
	  zgodne_iter(RPostSeq, R6, R),
	  zgodne_iter(LPostSeq, L6, L),
	  zgodne_iter(OPostSeq, O6, O),
	  neg_do_sąsiada(NegPostSeq, Neg6, Neg),
	  % W tym układzie szereg przecinkowy nie może być nieostatnim
	  % składnikiem:
	  wyklucz_przecinkowość_w_szeregu([Wym1 | WymL]),
	  % a także ostatni składnik szeregu przecinkowego nie może
	  % być szeregiem w szyku 3:
	  ( Oz \= przec ;
	    (wymagania_czyste(Oz6, Wym6) *-> Oz6 \= sz:_ ; true )
	  ),
	  oblwym_koord(Wym, sz:Oz, [Wym1 | WymL])
	}.

%%%% Nie wiadomo, czy firma ‹uruchomi punkty obsługi | i | pozwoli konkurentowi działać›.


% \subsection{Fraza werbalna nietypowa}

% W cudzysłowie:
fwe(Wf, A, C, T, Rl, O, Wym, Neg, Dest, I, Pk, Sub) -->
	s(wec1),
	cudz(o,po),
	fwe(Wf, A, C, T, Rl, O, Wym2, Neg, Dest, I, Pk, na),
	{ wymagania_oznacz_czyste(Wym2, Wym) },
	cudz(z,po).

%%%% PET "widzi" nawet pojedynczą komórkę rakową.
%%%% Piotr „czyta książkę”.

% \section{FRAZA NOMINALNA}
%
%
% \subsection{Terminale nominalne}

% Niepytajne

fno(P, R/L, 3, WymN, rzecz, bzap, Poz, _Neg, neut, I, (0|0), Sub) -->
	s(no1),   
	formarzecz(P, R/L, WymN, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

fno(P, R/L, O, Wym, os, bzap, Poz, _Neg, neut, I, (0|0), Sub) -->
	s(no2),   
	zaimos(P, R/L, O, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

fno(P, R/L, 3, Wym, kto, bzap, Poz, _Neg, neut, I, (0|0), Sub) -->
	s(no3),   
	zaimrzecz(Lemma, P, R/L, na),
	{ równe(Lemma, ktoś.ktokolwiek) },
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

fno(P, R/L, 3, Wym, co, bzap, Poz, _Neg, neut, I, (0|0), Sub) -->
	s(no4),   
	zaimrzecz(Lemma, P, R/L, na),
	{ równe(Lemma, coś.cokolwiek.co) },
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

%%%% Mówią coś innego.
%%%% Mówią co innego.

fno(P, R/L, 3, Wym, co, bzap, Poz, nie(_), neut, I, (0|0), Sub) -->
	s(no5),   
	zaimrzecz(nic, P, R/L, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

fno(P, R/L, 3, Wym, kto, bzap, Poz, nie(_), neut, I, (0|0), Sub) -->
	s(no6),   
	zaimrzecz(nikt, P, R/L, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

% «to» jest zaimkiem, bo potrzebne do korelatu:
fno(P, R/L, 3, Wym, rzecz, bzap, Poz, _Neg, neut, I, (0|0), Sub) -->
	s(no7),   
	zaimrzecz(to, P, R/L, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

% Względne

fno(P, R/L, 3, Wym, H, bzap, Poz, Neg, wz(H,R/L), I, (0|0), Sub) -->
	s(no11),
	zaimprzym(H, P, R/L, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ member(H, [który,jaki]),
	 rekcja_pusta(Wym) }.

%%%% Znam chłopca, ‹który› przyjdzie.
%%%% Sprzyja powstawaniu wszystkich problemów, ‹jakie› wynikają z niedoboru magnezu.


% Pytajne/pytajnozależne/względne

fno(P, R/L, 3, Wym, Kl, bzap, Poz, Neg, Dest, I, (0|0), Sub) -->
	s(no8),   
	zaimrzecz(Kl, P, R/L, na),
	{ równe(Kl, co.kto),
	  równe(Dest, pyt.pz.wz(Kl,R/L)) },
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}),
	{ rekcja_pusta(Wym) }.

% Realizacja frazy nominalnej przez przymiotnikową:
%
% Ograniczyłem Dest tylko do neut, bo robiła się zdublowana analiza
% dla „który”, a i dla innych nieneutralników wydaje się to
% idiotyczne.  Rozluźnimy, jeśli będzie powód.
%
% Być może w tej regule należałoby transmitować wymagania, ale z
% jakiegoś powodu kiedyś wpisaliśmy brak, więc przywrócimy dopiero w
% razie potrzeby.
fno(P, R/L, 3, wym(_,U,[[]]), przym, bzap, Poz, Neg, neut, I, Pk, Sub) -->
	s(no9),
	fpt(P, R/L, St, wym([],U,WymA), Kl, bzap, Neg, neut, I, Pk, na).

% W poniższym zdaniu względnik jest podrzędnikiem do fno→fpt, dlatego
% w no9 wymagania fno są puste, a nie wym(_,bw), jak wcześniej.
% Nie transmitujemy przy tym ewentualnych wymagań przymiotnika w górę,
% one się wypełniają niżej.  To pewnie nadgeneruje, trzeba zobaczć
% korpusowo.
%%%% - A co robić z ‹tymi›, które zawierają chlor?

%
% \subsection{Fraza nominalna z podrzędnikami}

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(noa1),  
	fno(P, R/L, O, WymN, Kl, Zap1, Poz, Neg, Dest1, I1, Pk1, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, P2) },
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(P2, R/L, St, wym([],U2,W2), Kl2, Zap2, Neg, Dest2, I2, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/Pk2]
		        ^[St]^[Kl2]^[U2]^[W2],
		    fpm(Pm, P3, Kl3, Zap2, Neg, Dest2, I2, Pk2, po)
		        ^[Pm]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, Zap2, pre, Neg, Dest2, I2, Pk2, po)
		        ^[RL4]^[Kl4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod, Kl/Kl4],
		    fzd(Tfz, nk, A5, C5, T5, Neg5, ni, Pk2, po)
		% właściwie jest problem z inkorporacją!  I2=ni
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz, _]
		        ^[Neg5],
		    fw(W6, A6, C6, Rl6, O6, post, Neg, Dest2, ni, Pk2, po)
		        ^[oblwym_iter, WymN, W6, ResztaWym],
		    modpart(fno, Neg, Dest2, ni, Pk2, po)
		    ]
		    ^[oblzap_iter, Zap1, Zap2, Zap]
		    ^[obldest_iter, Dest1, Dest2, Dest]
		    ^[oblink_iter, I1, I2, I]
		    ^[sprawdz_pk_iter, Pk1, Pk2, Pk] 
% tylko w tej regule, inaczej możliwy jeden element po prawej i pętla:
		    ^[conajmniej1, 0, _, 1]
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

% Ten warunek steruje przecinkami wokół podrzędnika przymiotnikowego:
% jeśli obu przecinków nie ma, działa przecinkowość fpm:
sprawdz_fpt_noa((bp|p)/Pk2/(p|bp)/Pk2) :- !.
% wpp. obliczamy lokalną sumę przecinkowości wymagając przecinka
% realnego lub wirtualnego na obu końcach frazy:
sprawdz_fpt_noa(Pk2a/Pk2b/Pk2c/Pk2) :-
	oblpk(Pk2, [Pk2a,Pk2b,Pk2c]).

% Ten warunek oblicza przypadek podrzędnej frazy przymiotnikowej.  W
% wypadku nadrzędnika „co” jest on ustawiany nietypowo na dopełniacz
% („widzę coś ciekawego / *ciekawe”):
sprawdz_kl_noa(co, P, dop) :- równe(P, mian.bier), !.
sprawdz_kl_noa(co, P, P) :- różne(P, mian.bier), !.
sprawdz_kl_noa(Kl, P, P) :- różne(Kl, co).

% Ten warunek sprawdza, czy wartości klasy są dopuszczalne dla
% modyfikowania nadrzędnika dopełniaczem. 
sprawdz_kl_nod(Kl/Kl2) :- Kl \== os, Kl2 \= kto.
% Kiedy podrzędnik jest przed centrum, trzeba użyć poniższego
% wariantu. Pierwszy argument zostaje ustalony, co jest sygnałem, że
% wystąpił choć jeden podrzędnik takiego typu:
sprawdz_kl_nod_prehead(dopmod/Kl2) :-  Kl2 \= kto.
% Po rozpoznaniu nadrzędnika i ustaleniu jego klasy KL należy użyć poniższego:
sprawdz_kl_nod_head(NodPresent,Kl) :- Kl \= os, ! ; var(NodPresent).



% Ten warunek sprawdza kombinacje parametów dopuszczające zdaniowy
% modyfikator frazy nominalnej:

% fraza typu „który” w zgodnym rodzaju i liczbie:
sprawdz_fzd_noz( R/L/Kl/Zap, wz(który,R/L), R/L/Kl/Zap ) :- Kl \= co.
%%%% Znam ‹chłopca, który przyszedł›.
sprawdz_fzd_noz( R/L/Kl/Zap, wz(jaki,R/L), R/L/Kl/Zap ) :- member(Kl, [rzecz,przym]).
%%%% Zasypujemy ‹dziurkę, jaka pozostała›.
sprawdz_fzd_noz( R/L/Kl/Zap, wz(Wz,przys), R/L/Kl/Zap ) :-
	member(Kl, [rzecz,przym]),
	member(Wz,[gdzie,skąd,dokąd,kiedy,gdy]).
%%%% Tam jest dom, gdzie straszy.
% fraza typu „co” lub „kto” w zgodnym rodzaju i liczbie:
%% Niestety zarówno «co» jak i «coś» ma klasę ‹co›, co oznacza, że
%% trzeba dopuścić nadrzędniki klasy ‹co› (i ‹kto› ze względu na
%% «ktoś»).  Dziwne, że są stare drzewa z „coś, co sprawia, że …” —
%% ten warunek jest przecież dość stary.
sprawdz_fzd_noz( R/L/Kl/Zap, wz(Kl1,R/L), R/L/Kl/Zap ) :- 
	member(Kl1, [kto,co]), member(Kl, [rzecz,przym,kto,co]).
%%%* Przyjdzie ‹kto, kto czytał›?
%%%% Przyjdzie ‹ten, kto czytał›.
%%%% Będzie ‹to, co lubisz›.
%%%! Przyjdzie ‹dziecko, co lubisz›.
%%%? Przyjdzie ‹dziecko, co lubisz je dręczyć›.
% frazy typu „taki”:
sprawdz_fzd_noz( R/L/Kl/tk, Tfz, R/L/Kl/tk ) :- 
	member(Tfz, [jakby,że,żeby,wz(jaki,_)]).
%%%% Zasypujemy ‹taką dziurkę, jaka pozostała›.
% frazy typu „tyle”:
sprawdz_fzd_noz( R/L/Kl/tyle, Tfz, R/L/Kl/tyle ) :- 
	member(Tfz, [ile,jakby,że,żeby,wz(jaki,_)]).

%%%% Po powrocie zauważył, że ‹drzwi do komórki, zawsze zamknięte na skobel,› są otwarte.
% [Czytałem] książkę najnowszą [.]
% Książki żadnej [nie czytano.]
% Książkę czyją [czytano?]
% Jaką książkę nową [wybrał?]
% [Autor, ] którego książkę najnowszą [znam, nie żyje.]
% [Nie wiem,] kogo jakiego [czytano.]
% [Nie wiem,] jaką książkę nową [wybrał.]

% [Nie kupił] nic nowego [.]
% Co nowego [kupił?]
% [Był malarz, ] którego coś nowego [kupiliśmy.]
% [Nie wiem,] co nowego [kupił.]
% [Nie wiem,] co jakiego [kupił.]

% Czemuś nowemu [się przyjrzał]
% Czemu nowemu [się przyjrzał?]
% [Jest malarzem, ] którego czemuś nowemu [się przyglądamy.] 
% [Nie wiem,] czemu nowemu [się przyjrzał.]
% [Nie wiem,] czemu jakiemu [się przyjrzał.]

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(noa2),
	fpt(PP, R/L, St1, wym([],U,_), Kl1, Zap1, Neg, Dest1, I1, Pk1, po),
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(PP, R/L, St2, wym([],U2,W2), Kl2, ZapL, Neg, DestL, IL, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/PkL]
		        ^[St2]^[Kl2]^[U2]^[W2],
		    fpm(Pm3, P3, Kl3, ZapL, Neg, DestL, IL, PkL, po)
		        ^[Pm3]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, ZapL, pre, Neg, DestL, IL, PkL, po)
		        ^[RL4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod_prehead, NodPresent/Kl4],
		    fw(W6, A6, C6, RL6, O6, post, Neg, DestL, ni, PkL, po)
		        ^[zroblistę_iter, [], W6, PreNWym],
		    modpart(fno, Neg, DestL, ni, PkL, po)
		    ]
		    ^[oblzap_iter, Zap1, ZapL, ZapLL]
		    ^[obldest_iter, Dest1, DestL, DestLL]
		    ^[oblink_iter, I1, IL, ILL]
		    ^[sprawdz_pk_iter, Pk1, PkL, PkLL] 
		),
	fno(P, R/L, O, WymN, Kl, Zap7, Poz, Neg, Dest7, I7, Pk7, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, PP),
	  sprawdz_kl_nod_head(NodPresent,Kl),
	  oblzap_iter(ZapLL, Zap7, ZapPP),
	  obldest_iter(DestLL, Dest7, DestPP),
	  oblink_iter(ILL, I7, IPP),
	  sprawdz_pk_iter(PkLL, Pk7, PkPP),
	  wyjmijl(PreNWym, WymN, PostNWym) },
	sequence_of([
                    [optional(przec(Pk8a,po),{},{Pk8a=(bp|p)}),
		     fpt(PP, R/L, St8, wym([],U8,W8), Kl8, ZapP, Neg, DestP, IP, Pk8b, po),
		     optional(przec(Pk8c,po),{},{Pk8c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk8a/Pk8b/Pk8c/PkP]
		        ^[St8]^[Kl8]^[U8]^[W8],
		    fpm(Pm9, P9, Kl9, ZapP, Neg, DestP, IP, PkP, po)
		        ^[Pm9]^[P9]^[Kl9],
		    fno(dop, RL10, 3, wym([],U10,WymN10), Kl10, ZapP, pre, Neg, DestP, IP, PkP, po)
		        ^[RL10]^[U10]^[WymN10]
		        ^[sprawdz_kl_nod, Kl/Kl10],
		    fzd(Tfz11, nk, A11, C11, T11, Neg11, ni, PkP, po)
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz11, _]
		        ^[Neg11],
		    fw(W12, A12, C12, RL12, O12, post, Neg, DestP, ni, PkP, po)
		        ^[oblwym_iter, PostNWym, W12, ResztaWym],
		    modpart(fno, Neg, DestP, ni, PkP, po)
		    ]
		    ^[oblzap_iter, ZapPP, ZapP, Zap]
		    ^[obldest_iter, DestPP, DestP, Dest]
		    ^[oblink_iter, IPP, IP, I]
		    ^[sprawdz_pk_iter, PkPP, PkP, Pk] 
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

%%%% Zobaczył ‹szary, nieco podupadły, niepozorny dom z ogrodem›.
%%%% Przyszli ‹tacy chłopcy, jakim  byłem kiedyś›.
%%%% Ufam ‹wytrwałym jego uczestnikom›.
% [Kupił] nową książkę 
% Nowej książki żadnego autora [nie czytano.]
% Czyją książkę [czytano?]
% Nowym książkom którego autora [się przyglądać?]
% [Ściga mnie facet, ] od którego wziętą książkę [zgubiłem.] 
% [Nie wiem,] czyją książkę [czytano.]
% [Nie wiem,] jakie czyje książki [czytano.]

% [Wyszło na jaw] nieoczekiwanego coś [.]
% Nowego co [wyszło na jaw?]
% [Jest malarka, ] której nowego cokolwiek [pokazują.] 
% [Nie wiem,] czyjego coś [znaleźli.]
% [Nie wiem,] czyjego co [znaleźli.]

% [Zachwyca się] nowym czymkolwiek [.]
% Nowym czym [żyją?] 
% [Jest malarzem, ] którego nowemu czemuś [się przyglądamy.]
% [Nie wiem,] jakim czym [żyją.]

%
% \subsection{Fraza nominalna z wyrażeniem przyimkowym}

%% wkomponowane do noa1:
%% fno(P, R/L, O, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(nop1), 
%% 	fno(P, R/L, O, Kl, Zap1, Poz, Neg1, Dest1, I1, Pk1, na),
%% 	fpm(Pm, P2, Kl2, Zap2, Neg2, Dest2, I2, Pk2, po),
%% 	{ obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
%% 	  oblneg(-ani, Neg, Neg1, Neg2), oblzap(Zap, Zap1, Zap2),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

% Książkę bez kartek [kupił.]
% Z którego miasta autora  [czytałeś?]
% Z tego miasta co nowego  [czytałeś?]
% [Krytyk, ] którego książkę o poezji [znam, przesadził.]
% [Nie wiem, ] od której facetki samochodem [jechali.]
% [Nie wiem,] od której facetki czym [jechali.]

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(nop2),
	fpm(Pm1, P1, Kl1, Zap1, Neg, Dest1, I1, Pk1, po),
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(PP, R/L, St2, wym([],U2,W2), Kl2, ZapL, Neg, DestL, IL, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/PkL]
		        ^[St2]^[Kl2]^[U2]^[W2],
		    fpm(Pm3, P3, Kl3, ZapL, Neg, DestL, IL, PkL, po)
		        ^[Pm3]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, ZapL, pre, Neg, DestL, IL, PkL, po)
		        ^[RL4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod_prehead, NodPresent/Kl4],
		    fw(W6, A6, C6, RL6, O6, post, Neg, DestL, ni, PkL, po)
		        ^[zroblistę_iter, [], W6, PreNWym],
		    modpart(fno, Neg, DestL, ni, PkL, po)
		    ]
		    ^[oblzap_iter, Zap1, ZapL, ZapLL]
		    ^[obldest_iter, Dest1, DestL, DestLL]
		    ^[oblink_iter, I1, IL, ILL]
		    ^[sprawdz_pk_iter, Pk1, PkL, PkLL] 
		),
	fno(P, R/L, O, WymN, Kl, Zap7, Poz, Neg, Dest7, I7, Pk7, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, PP),
	  sprawdz_kl_nod_head(NodPresent,Kl),
	  oblzap_iter(ZapLL, Zap7, ZapPP),
	  obldest_iter(DestLL, Dest7, DestPP),
	  oblink_iter(ILL, I7, IPP),
	  sprawdz_pk_iter(PkLL, Pk7, PkPP),
	  wyjmijl(PreNWym, WymN, PostNWym) },
	sequence_of([
                    [optional(przec(Pk8a,po),{},{Pk8a=(bp|p)}),
		     fpt(PP, R/L, St8, wym([],U8,W8), Kl8, ZapP, Neg, DestP, IP, Pk8b, po),
		     optional(przec(Pk8c,po),{},{Pk8c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk8a/Pk8b/Pk8c/PkP]
		        ^[St8]^[Kl8]^[U8]^[W8],
		    fpm(Pm9, P9, Kl9, ZapP, Neg, DestP, IP, PkP, po)
		        ^[Pm9]^[P9]^[Kl9],
		    fno(dop, RL10, 3, wym([],U10,WymN10), Kl10, ZapP, pre, Neg, DestP, IP, PkP, po)
		        ^[RL10]^[U10]^[WymN10]
		        ^[sprawdz_kl_nod, Kl/Kl10],
		    fzd(Tfz11, nk, A11, C11, T11, Neg11, ni, PkP, po)
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz11, _]
		        ^[Neg11],
		    fw(W12, A12, C12, RL12, O12, post, Neg, DestP, ni, PkP, po)
		        ^[oblwym_iter, PostNWym, W12, ResztaWym],
		    modpart(fno, Neg, DestP, ni, PkP, po)
		    ]
		    ^[oblzap_iter, ZapPP, ZapP, Zap]
		    ^[obldest_iter, DestPP, DestP, Dest]
		    ^[oblink_iter, IPP, IP, I]
		    ^[sprawdz_pk_iter, PkPP, PkP, Pk] 
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

% [Kupił] bez kartek książkę [.]
% Co od niego [czytałeś?]
% Co od kogo [czytałeś?]
% [To, ] bez czego książkę [kupiłeś, nie ma wartości.]
% [Nie wiem,] co z tego [czytano.]
% [Nie wiem,] co z której półki [czytano.]

% \subsection{Fraza nominalna z dopełniaczem}

%% fno(P, RL, O, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(nod1), 
%% 	fno(P, RL, O, Kl, Zap1, Poz, Neg1, Dest1, I1, Pk1, na),
%% 	fno(dop, RL2, 3, Kl2, Zap2, Poz2, Neg2, Dest2, I2, Pk2, po),
%% 	{ różne(Kl, os), różne(Kl2, kto),
%% 	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
%% 	  oblneg(-ani,  Neg, Neg1, Neg2), oblzap(Zap, Zap1, Zap2),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

%% 22.01: do przemyślenia Poz, Poz2

% Książkę jej [znam.]
% * My córek [pracujemy.]
% * Książkami kogokolwiek [się zajmują.]
% Co tego autora    [czytałeś?]
% Co którego autora    [czytałeś?]
% Książkę autora którego [czytałeś?]
% * Książkę kogo  [czytałeś?]
% * Co nas  [czytałeś?]
% [Facet, ] którego doradcę banku [znamy, umarł.]
% [Pytam, ] co matki [ukradziono.]
% [Pytam, ] co czyjej matki [ukradziono.]
% * [Wiem, ] co kogo [masz.]

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(nod2),
	fno(dop, RL1, 3, wym([],_,WymN1), Kl1, Zap1, pre, Neg, Dest1, I1, Pk1, po),
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(PP, R/L, St2, wym([],U2,W2), Kl2, ZapL, Neg, DestL, IL, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/PkL]
		        ^[St2]^[Kl2]^[U2]^[W2],
		    fpm(Pm3, P3, Kl3, ZapL, Neg, DestL, IL, PkL, po)
		        ^[Pm3]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, ZapL, pre, Neg, DestL, IL, PkL, po)
		        ^[RL4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod_prehead, NodPresent/Kl4],
		    fw(W6, A6, C6, RL6, O6, post, Neg, DestL, ni, PkL, po)
		        ^[zroblistę_iter, [], W6, PreNWym],
		    modpart(fno, Neg, DestL, ni, PkL, po)
		    ]
		    ^[oblzap_iter, Zap1, ZapL, ZapLL]
		    ^[obldest_iter, Dest1, DestL, DestLL]
		    ^[oblink_iter, I1, IL, ILL]
		    ^[sprawdz_pk_iter, Pk1, PkL, PkLL] 
		),
	fno(P, R/L, O, WymN, Kl, Zap7, Poz, Neg, Dest7, I7, Pk7, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, PP),
	  sprawdz_kl_nod_head(NodPresent,Kl),
	  oblzap_iter(ZapLL, Zap7, ZapPP),
	  obldest_iter(DestLL, Dest7, DestPP),
	  oblink_iter(ILL, I7, IPP),
	  sprawdz_pk_iter(PkLL, Pk7, PkPP),
	  wyjmijl(PreNWym, WymN, PostNWym) },
	sequence_of([
                    [optional(przec(Pk8a,po),{},{Pk8a=(bp|p)}),
		     fpt(PP, R/L, St8, wym([],U8,W8), Kl8, ZapP, Neg, DestP, IP, Pk8b, po),
		     optional(przec(Pk8c,po),{},{Pk8c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk8a/Pk8b/Pk8c/PkP]
		        ^[St8]^[Kl8]^[U8]^[W8],
		    fpm(Pm9, P9, Kl9, ZapP, Neg, DestP, IP, PkP, po)
		        ^[Pm9]^[P9]^[Kl9],
		    fno(dop, RL10, 3, wym([],U10,WymN10), Kl10, ZapP, pre, Neg, DestP, IP, PkP, po)
		        ^[RL10]^[U10]^[WymN10]
		        ^[sprawdz_kl_nod, Kl/Kl10],
		    fzd(Tfz11, nk, A11, C11, T11, Neg11, ni, PkP, po)
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz11, _]
		        ^[Neg11],
		    fw(W12, A12, C12, RL12, O12, post, Neg, DestP, ni, PkP, po)
		        ^[oblwym_iter, PostNWym, W12, ResztaWym],
		    modpart(fno, Neg, DestP, ni, PkP, po)
		    ]
		    ^[oblzap_iter, ZapPP, ZapP, Zap]
		    ^[obldest_iter, DestPP, DestP, Dest]
		    ^[oblink_iter, IPP, IP, I]
		    ^[sprawdz_pk_iter, PkPP, PkP, Pk] 
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

% Autora książkę [lubię.]
% * Kogoś książkę [lubisz.]
% Którego autora książkę [czytałeś?]
% * Nas co [czytałeś?]
% [Ten, ] którego matka [przyszła, śpi.]
% * [Ten, ] którego ona [umarła, też umarł.]
% [Pytam, ] której facetki samochodem [jeździcie.]
% [Pytam, ] której facetki czym [jeździcie.]
% * Kogo samochodem [jeździsz, nie wiem.]

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(now2),
	fw(W1, A1, C1, RL1, O1, pre, Neg, Dest1, I1, Pk1, po),
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(PP, R/L, St2, wym([],U2,W2), Kl2, ZapL, Neg, DestL, IL, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/PkL]
		        ^[St2]^[Kl2]^[U2]^[W2],
		    fpm(Pm3, P3, Kl3, ZapL, Neg, DestL, IL, PkL, po)
		        ^[Pm3]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, ZapL, pre, Neg, DestL, IL, PkL, po)
		        ^[RL4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod_prehead, NodPresent/Kl4],
		    fw(W6, A6, C6, RL6, O6, post, Neg, DestL, ni, PkL, po)
		        ^[zroblistę_iter, [W1], W6, PreNWym],
		    modpart(fno, Neg, DestL, ni, PkL, po)
		    ]
		    ^[oblzap_iter, bzap, ZapL, ZapLL]
		    ^[obldest_iter, Dest1, DestL, DestLL]
		    ^[oblink_iter, I1, IL, ILL]
		    ^[sprawdz_pk_iter, Pk1, PkL, PkLL] 
		),
	fno(P, R/L, O, WymN, Kl, Zap7, Poz, Neg, Dest7, I7, Pk7, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, PP),
	  sprawdz_kl_nod_head(NodPresent,Kl),
	  oblzap_iter(ZapLL, Zap7, ZapPP),
	  obldest_iter(DestLL, Dest7, DestPP),
	  oblink_iter(ILL, I7, IPP),
	  sprawdz_pk_iter(PkLL, Pk7, PkPP),
	  wyjmijl(PreNWym, WymN, PostNWym) },
	sequence_of([
                    [optional(przec(Pk8a,po),{},{Pk8a=(bp|p)}),
		     fpt(PP, R/L, St8, wym([],U8,W8), Kl8, ZapP, Neg, DestP, IP, Pk8b, po),
		     optional(przec(Pk8c,po),{},{Pk8c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk8a/Pk8b/Pk8c/PkP]
		        ^[St8]^[Kl8]^[U8]^[W8],
		    fpm(Pm9, P9, Kl9, ZapP, Neg, DestP, IP, PkP, po)
		        ^[Pm9]^[P9]^[Kl9],
		    fno(dop, RL10, 3, wym([],U10,WymN10), Kl10, ZapP, pre, Neg, DestP, IP, PkP, po)
		        ^[RL10]^[U10]^[WymN10]
		        ^[sprawdz_kl_nod, Kl/Kl10],
		    fzd(Tfz11, nk, A11, C11, T11, Neg11, ni, PkP, po)
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz11, _]
		        ^[Neg11],
		    fw(W12, A12, C12, RL12, O12, post, Neg, DestP, ni, PkP, po)
		        ^[oblwym_iter, PostNWym, W12, ResztaWym],
		    modpart(fno, Neg, DestP, ni, PkP, po)
		    ]
		    ^[oblzap_iter, ZapPP, ZapP, Zap]
		    ^[obldest_iter, DestPP, DestP, Dest]
		    ^[oblink_iter, IPP, IP, I]
		    ^[sprawdz_pk_iter, PkPP, PkP, Pk] 
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

% Fraza nominalna z partykułą modyfikującą

fno(P, R/L, O, wym(_,U,bw), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) --> 
	s(nom1),
	modpart(fno, Neg, Dest1, I1, Pk1, po),
	sequence_of([
                    [optional(przec(Pk2a,po),{},{Pk2a=(bp|p)}),
		     fpt(PP, R/L, St2, wym([],U2,W2), Kl2, ZapL, Neg, DestL, IL, Pk2b, po),
		     optional(przec(Pk2c,po),{},{Pk2c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk2a/Pk2b/Pk2c/PkL]
		        ^[St2]^[Kl2]^[U2]^[W2],
		    fpm(Pm3, P3, Kl3, ZapL, Neg, DestL, IL, PkL, po)
		        ^[Pm3]^[P3]^[Kl3],
		    fno(dop, RL4, 3, wym([],U4,WymN4), Kl4, ZapL, pre, Neg, DestL, IL, PkL, po)
		        ^[RL4]^[U4]^[WymN4]
		        ^[sprawdz_kl_nod_prehead, NodPresent/Kl4],
		    fw(W6, A6, C6, RL6, O6, post, Neg, DestL, ni, PkL, po)
		        ^[zroblistę_iter, [], W6, PreNWym],
		    modpart(fno, Neg, DestL, ni, PkL, po)
		    ]
		    ^[oblzap_iter, bzap, ZapL, ZapLL]
		    ^[obldest_iter, Dest1, DestL, DestLL]
		    ^[oblink_iter, I1, IL, ILL]
		    ^[sprawdz_pk_iter, Pk1, PkL, PkLL] 
		),
	fno(P, R/L, O, WymN, Kl, Zap7, Poz, Neg, Dest7, I7, Pk7, na),
	{ WymN = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  sprawdz_kl_noa(Kl, P, PP),
	  sprawdz_kl_nod_head(NodPresent,Kl),
	  oblzap_iter(ZapLL, Zap7, ZapPP),
	  obldest_iter(DestLL, Dest7, DestPP),
	  oblink_iter(ILL, I7, IPP),
	  sprawdz_pk_iter(PkLL, Pk7, PkPP),
	  wyjmijl(PreNWym, WymN, PostNWym) },
	sequence_of([
                    [optional(przec(Pk8a,po),{},{Pk8a=(bp|p)}),
		     fpt(PP, R/L, St8, wym([],U8,W8), Kl8, ZapP, Neg, DestP, IP, Pk8b, po),
		     optional(przec(Pk8c,po),{},{Pk8c=(p|bp)})]
		        ^[sprawdz_fpt_noa, Pk8a/Pk8b/Pk8c/PkP]
		        ^[St8]^[Kl8]^[U8]^[W8],
		    fpm(Pm9, P9, Kl9, ZapP, Neg, DestP, IP, PkP, po)
		        ^[Pm9]^[P9]^[Kl9],
		    fno(dop, RL10, 3, wym([],U10,WymN10), Kl10, ZapP, pre, Neg, DestP, IP, PkP, po)
		        ^[RL10]^[U10]^[WymN10]
		        ^[sprawdz_kl_nod, Kl/Kl10],
		    fzd(Tfz11, nk, A11, C11, T11, Neg11, ni, PkP, po)
		        ^[sprawdz_fzd_noz, R/L/Kl/Zap, Tfz11, _]
		        ^[Neg11],
		    fw(W12, A12, C12, RL12, O12, post, Neg, DestP, ni, PkP, po)
		        ^[oblwym_iter, PostNWym, W12, ResztaWym],
		    modpart(fno, Neg, DestP, ni, PkP, po)
		    ]
		    ^[oblzap_iter, ZapPP, ZapP, Zap]
		    ^[obldest_iter, DestPP, DestP, Dest]
		    ^[oblink_iter, IPP, IP, I]
		    ^[sprawdz_pk_iter, PkPP, PkP, Pk] 
		),
		{ wymagania_zamknij_nieuważnie(ResztaWym)  }.

%%%% ‹Raczej Piotr› przyszedł.

%
% \subsection{Fraza nominalna ze składnikiem zdaniowym}

%% fno(P, R/L, O, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(noz1), 
%% 	fno(P, R/L, O, Kl, Zap, Poz, Neg, Dest, I, Pk1, na),
%% 	fzd(wz(który,R/L), nk, A, C, T, Neg2, ni, Pk2, po), 
%% 	{ różne(Kl, co),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

% [Z przecinkiem końcowym: muszą być osobne reguły na fzd(.., stan) i fzd(…, bpk)]
%
% 	Przecinkowe:
%
% Chłopiec, którego znam, [umarł.]
% Chłopiec, który tu bywał, którego znam, [umarł.]
% * Chłopiec, który tu bywał,, którego znam, [umarł.]
% * [Umarł] chłopiec, który tu bywał, [.] 
% * [Umarł] chłopiec, który tu bywał, [, prawdę rzekłszy,.] 
% Ktoś, którego znam, [umarł.]
% Chłopiec której dziewuchy, którego znam, [umarł?]
% Dwóm dziewczynom, które znam, [matkują.]
% [Facetka,] której synowie, których znam, [umarli, żyje.]
% * Coś, które znam, [ci się podoba.]
% * Co, które znam, [ci się podoba?]
%
% 	Bezprzecinkowe:
%
% [Umarł] chłopiec, którego znam [.]
% [Umarł] ktoś, którego znam [!]
% [Umarł] chłopiec której dziewuchy, którego znam [?]
% [Matkują] dwóm dziewczynom, które znam [, bo są młode.]

%% fno(P, R/L, O, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(noz2), 
%%  	fno(P, R/L, O, Kl, Zap, Poz, Neg, Dest, I, Pk1, na), 
%% 	fzd(wz(Kl,R/L), nk, A, C, T, Neg2, ni, Pk2, po),
%% 	{ równe(Kl, co.kto),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

%
% 	Przecinkowe:
%
% Co, co znam, [ci się podoba?]
% Coś, które znam, [ci się podoba.]
% To, co znam, [ci się podoba.]	[to: Kl=co]
% Kto, kogo znam, [umarł?]
% * Chłopiec, co znam, [umarł.]
%
% 	Bezprzecinkowe:
%
% [Czy podoba ci się] cokolwiek, co znam [?]
% [Podoba ci się] coś, które znam [, Jasiu.]
% To, co znam, [ci się podoba.]	[to: Kl=co]
% [Umarł] kto, kogo znam [?] 
% * [Umarł] chłopiec, co znam [.]


% MW: „jaki” jest „wz(jaki,_)”.  Trzeba to dopieścić.
%% fno(P, R/L, O, Kl, tk, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(noz3), 
%%  	fno(P, R/L, O, Kl, tk, Poz, Neg, Dest, I, Pk1, na), 
%% 	fzd(sp(Tfz), nk, A, C, T, Neg2, ni, Pk2, po), 
%% 	{ równe(Tfz, jakby.jaki.że.żeby),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

%
% 	Przecinkowe:
%
% Taki chłopiec, jakie dziewczyny cenię, [umarł.]
% [Ten, ] którego tak mądry kolega, jakie dziewczyny cenię, [umarł, też umarł.]
% [On był] takim chłopcem, że ludzie zazdroszczą, [od dawna.] 
% * Chłopiec, jakie dziewczyny cenię, [umarł.]
  %
% 	Bezprzecinkowe:
%
% [Umarł] taki chłopiec, jakie dziewczyny cenię [.]
% [Ten, ] którego tak mądry kolega, jakie dziewczyny cenię [, o czym wiecie, umarł, 
% też umarł.]
% [To jest] taki chłopiec, że ludzie zazdroszczą [.] 

% MW: tu też trzeba dopieścić
%% fno(P, R/L, O, Kl, tyle, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(noz4), 
%%  	fno(P, R/L, O, Kl, tyle, Poz, Neg, Dest, I, Pk1, na), 
%% 	fzd(Tfz, nk, A, C, T, Neg2, ni, Pk2, po),
%% 	{ równe(Tfz, ile.jakby.jaki.że.żeby),
%% 	  oblpk(Pk, [Pk1,Pk2])  }.

%
% 	Przecinkowe:
%
% Tylu ludzi, ile dziewczyn znam, [zaprosił.]
% Tylu ludzi, że się zdziwiłem, [zaprosił.]
% Tylu ludzi, jakby był głupi, [zaprosił.]
% Tylu jakich ludzi, ile dziewczyn znam, [zaprosił?]
% * Ludzi, ile dziewczyn znam, [zaprosił.]
%
% 	Bezprzecinkowe:
%
% [Zaprosił] tylu ludzi, ile dziewczyn znam [.]
% [Zaprosił] tylu ludzi, że się zdziwiłem [, jak wiecie.]
% [Zaprosił] tylu ludzi, jakby był głupi [.]
% [Zaprosił] tylu jakich ludzi, ile dziewczyn znam [?]
% * [Zaprosił] ludzi, ile dziewczyn znam [.]

% \subsection{Fraza nominalna z podrzędnikiem apozycyjnym}

% Drugi składnik zgadza się co do przypadka lub jest w mianowniku.  W
% tym drugim wypadku jest silna tendencja, żeby ten składnik był
% nazwą, ale niestety trudno to opisać — może on być nazwą gatunkową
% pisaną małą literą.

fno(P, RL, O, wym(_,_,[apo]), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(noap), 
	fno(P, RL, O, wym([],_,Wym0), Kl, Zap, Poz, Neg, Dest, I, Pk0, na),
	{ Wym0 \= [apo], Kl \= przym },
	fno(P1, RL1, 3, wym([],_,Wym1), Kl1, Zap1, pre, Neg, neut, ni, Pk1, po),
	{ P1 \= dop, Kl1 \= przym,
	  ( P1 = P *-> true ; P1 = mian ),
	  oblpk(Pk, [Pk0,Pk1]) }.

%%%% Powiedziała ‹znana malarka | ‹Bogusław | Kaczyński››.
%%%% Rozmawiamy z ‹szanowanym krytykiem muzycznym | ‹dyrektorem | ‹Tamarą | Łempicką›››.
%%%% Przedstawił ‹panu | posłowi na sejm dwudziestej kadencji Ryszardowi Kaliszowi›.
%%%% Przyszedł ‹‹pan | poseł› z klubu prawicy | ‹Leszek | Miller››.
%%%% W zawodach wystartował znany kolarz zawodowej ‹grupy Mróz›, Piotr Wadecki.
%%%% Zawiedli zawodnicy ‹Amiki Wronki›.
%%%% Chojeńscy piłkarze ulegli ‹Energetykowi Gryfino›.
%%%% Zastosowano kartę graficzną ze ‹złączem AGP›.
%%%% Znajduje się na terenie ‹hrabstwa Lyon› w stanie Nevada.
%%%% Sam ‹Franciszek Ksawery książę Drucki-Lubecki›, minister skarbu Królestwa Polskiego, był właścicielem ‹dóbr Miłosna›.
%%%% Pamiętałam jego francuską dziewczynę z ‹ulicy Widok›.

% apozycja, w której składniki są rozdzielone przecinkiem:
% w tym wariancie dopuszczamy też dopełniacz.

fno(P, RL, O, wym(_,_,[apo]), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(noapp), 
	fno(P, RL, O, wym([],_,Wym0), Kl, Zap, Poz, Neg, Dest, I, Pk0, na),
	{ Kl \= przym },
	przec(Pk2,po),
	fno(P, RL1, 3, wym([],_,Wym1), Kl1, Zap1, pre, Neg, neut, ni, Pk1, po),
	{ Kl1 \= przym },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ % P \= dop,
	  oblpk(Pk, [Pk0,Pk2,Pk1,Pk3]) }.
%%%% ‹19-letnia Jenna | , | córka prezydenta USA George'a Busha | ,› została ponownie przyłapana na próbie zamówienia alkoholu w restauracji.
%%%% W partii rządzi ‹Jarosław Kaczyński |,| brat prezydenta›.

fno(P, RL, O, wym(_,_,[apo]), Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(noapn), 
	fno(P, RL, O, wym([],_,Wym0), Kl, Zap, Poz, Neg, Dest, I, Pk0, na),
	{ Kl \= przym },
	nawias(o,TN,po),
	fno(P, RL1, 3, wym([],_,Wym1), Kl1, Zap1, pre, Neg, neut, ni, Pk1, po),
	{ Kl1 \= przym },
	nawias(z,TN,po),
	{ % P \= dop,
	  oblpk(Pk, [Pk0,(0|wp),Pk1,(p|0)]) }.

%%%% JANOWO (gm. Kwidzyn).
%%%% Rodion R. (23 lata) zabił tępym narzędziem.
%%%% Jarosław (syn przewodniczącego) wziął udział w naradzie.

% \subsection{Fraza nominalna z liczebnikiem}

fno(P, R/L, O, Wym, uzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol1), 
	flicz(P, R/L, uzg, Zap, Dest, I, Pk, na),
	{ rekcja_pusta(Wym) }.

% Czterema [się wyręczał.]
% Ilu [zazdrościsz?]
% [Znam tylu facetów, z] iloma [miałam romans.]
% [Pytam, ] ilu zazdrościsz [.]

fno(P, R/L, O, Wym, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol2), 
	flicz(P, R/L, nuzg, Zap, Dest, I, Pk, na), 
	{ różne(P, mian) },
	{ rekcja_pusta(Wym) }.

% Trzech [znam.]
% Ilu [znasz?]
% [Nie wiem, z iloma się przyjaźnicie, ] ilu zaś [znasz.]

fno(mian, r(mn(n),nmo(np(n)))/poj, 3, Wym, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol3), 
	flicz(mian, R/L, nuzg, Zap, Dest, I, Pk, na),
	{ rekcja_pusta(Wym) }.

% Pięć [przyszło]
% Ilu [przyszło?]
% [Jest już późno, ] ilu więc [przyszło?]
% [Znam tylu, ] ilu [znam.]

fno(P, R/L, O, WymN, uzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol4), 
 	flicz(P, R/L, uzg, Zap1, Dest1, I1, Pk1, na), 
	fno(P, R/L, O, WymN, Kl2, Zap2, _, Neg, Dest2, I2, Pk2, po),
	{ różne(Kl2, uzg.nuzg.egz),
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.

% Dwaj faceci [idą.]
% Iloma facetami [rządzisz?]
% Iloma takimi facetami [rządzisz?]
% Pięciu którym facetom [płacą?] 
% [Jest fajnie, ] trzema bowiem facetami [się zachwycił.]
% [Przyszło tyle dziewczyn, ] iloma facetami [rozporządzam.]
% [Nie wiem, ] iloma facetami [rządzisz.]
% [Mamy kłopot, ] iloma bowiem facetami których dziewczyn [rządzisz, nie wiadomo.]
% Powiedział ‹trzynastu | profesorom i doktorom›.
%%*! ‹Dwaj | chłopiec i dziewczynka› idą.

fno(P, R/L, O, WymN, uzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol5), 
 	fno(P, R/L, O, WymN, Kl1, Zap1, pre, Neg, Dest1, I1, Pk1, po),
	flicz(P, R/L, uzg, Zap2, Dest2, I2, Pk2, na),
	{ różne(Kl1, uzg.nuzg.egz),
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.

% Facetom trzem [zaszkodziło.]
% [Było jedzenie, ] facetom więc trzem [zaszkodziło.]
% [Płacisz] facetom ilu [?]
% [Płacisz] którym facetom ilu [?]
% [Chłopcy,] którym trzem [pomagam, żyją.]
% [Pytano, ] których dziewczyn facetom pięciu [zaszkodziło.]

fno(P, R/L, O, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol6), 
	flicz(P, R/L, nuzg, Zap1, Dest1, I1, Pk1, na), 
	fno(dop, R/L, O, WymN, Kl2, Zap2, _, Neg, Dest2, I2, Pk2, po), 
	{ różne(P, mian), różne(Kl2, uzg.nuzg.egz),
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.
	
% Pięciu facetów [nie ma.]
% Ilu facetów [nie ma?]
% [Rozmawiałem z tyloma,] ilu facetów [nie ma.]
% Pięciu z którego miasta facetów [nie ma?]
% Widzę ‹pięciu | profesorów i doktorów›.

fno(P, R/L, O, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol7),
	fno(dop, R/L, O, WymN, Kl1, Zap1, pre, Neg, Dest1, I1, Pk1, po),
	flicz(P, R/L, nuzg, Zap2, Dest2, I2, Pk2, na),
	{ różne(P, mian), różne(Kl1, uzg.nuzg.egz), 
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.

% Facetów dwóch [nie ma.]
% Żadnych facetów dwóch [nie ma.]
% Facetów ilu [nie ma?]
% [Faceci, ] których dwóch [nie ma, umarli.]
% Z którego miasta facetów pięciu [nie ma?]

fno(mian, r(mn(n),nmo(np(n)))/poj, 3, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol8), 
	flicz(mian, R/L, nuzg, Zap1, Dest1, I1, Pk1, na), 
	fno(dop, R/L, O, WymN, Kl2, Zap2, _, Neg, Dest2, I2, Pk2, po),
	{ różne(Kl2, uzg.nuzg.egz), 
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.

% Dwóch facetów [przyszło.]
% Ilu facetów [przyszło?]
% [Jest tego tyle, ] ilu facetów [przyszło.]
% [Nie wiem, ] ilu facetów [przyszło.]
% Trwa ‹trzydzieści | wojen i konfliktów›.

fno(mian, r(mn(n),nmo(np(n)))/poj, 3, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol9), 
	fno(dop, R/L, O, WymN, Kl1, Zap1, pre, Neg, Dest1, I1, Pk1, po),
	flicz(mian, R/L, nuzg, Zap2, Dest2, I2, Pk2, na),
	{ różne(Kl1, uzg.nuzg.egz),
	  obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  }.

% Facetów pięciu [jest.]
% Facetów ilu [jest?]
% [Facetki są wszystkie, ] facetów ilu zaś [jest?]
% Z którego miasta facetów pięciu [jest?]
% [Faceci,] których dwóch [było, przyszli.]
% [Nie wiem, ] których ilu [przyszło.]



fno(mian, r(mn(n),nmo(np(n)))/poj, 3, Wym, Kl0, nuzg, Poz, Neg, Dest, I, Pk, Zap) -->
	s(nol10), 
	fpt(dop, R/L, St, wym([],_,_), Kl1, Zap1, Neg, Dest1, I1, Pk1, po),  
	flicz(mian, R/L, nuzg, Zap2, Dest2, I2, Pk2, na),
	{ obldest(Dest, Dest1, Dest2), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  },
	{ rekcja_pusta(Wym) }.

% Tych pięć [przyszło.]
% Takich ilu [jest?]
% Czyich pięciu [przyszło?]
% Takich tylu [przyszło.]
% [Z takim facetem,] jakich dwóch [przyszło, rozmawiałem.]
% [Nie wiem, ] czyich ilu [przyszło.]
 

%Uwaga! Trzeba się przyjrzeć interpretacji względnego który! Czy to rzeczownik?

fno(mian, r(mn(n),nmo(np(n)))/poj, 3, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol11), 
	fpt(dop, R/L, St, wym([],_,_), Kl1, Zap1, Neg1, Dest1, I1, Pk1, po),
	flicz(mian, R/L, nuzg, Zap2, Dest2, I2, Pk2, na), 
	fno(dop, R/L, O, WymN, Kl3, Zap3, pre, Neg3, Dest3, I3, Pk3, po),
	{ różne(Kl3, uzg.nuzg.egz),
	  obldest(Dest, [Dest1, Dest2, Dest3]), 
	  oblink(I, I1, I2), oblink(I, I2, I3), 
	  oblneg(-ani,  Neg, Neg1, Neg3),
	  oblzap(Zap, [Zap1, Zap2, Zap3]),
	  oblpk(Pk, [Pk1,Pk2,Pk3])  }.

%Czy to jest dobrze z Dest3, Zap3, Neg3???

% Tych dwu facetów [było.]
% Tych ilu facetów [było?]
% Czyich pięciu facetów [przyszło?]
% Tych pięciu facetów z której klasy [przyszło?]
% [Ona jest taka, ] jakich dwu facetów [było.]
% Których pięciu facetów [przyszło, nie wiadomo.]


fno(mian, r(mn(n),nmo(np(n)))/poj, 3, Wym, nuzg, Zap, Poz1, Neg, Dest, I, Pk, Sub) -->
	s(nol12), 
	fpt(mian, R/L, St, wym([],_,_), Kl1, Zap1, Neg, Dest1, I1, Pk1, po), 
	flicz(mian, R/L, nuzg, Zap2, Dest2, I2, Pk2, na), 
	{ R = r(_,nmo(_)), % wykluczony rodzaj męskoosobowy
	  obldest(Dest, [Dest1, Dest2]), oblink(I, I1, I2),
	  oblzap(Zap, [Zap1, Zap2]),
	  oblpk(Pk, [Pk1,Pk2])  },
	{ rekcja_pusta(Wym) }.
 
% Te pięć [było.]
% Które pięć [było?]
% Te pięć z której klasy [przyszło?]
%[Ona jest taka, ] jakie pięć [było.]
% [Nie wiem, ] które pięć [było.]
% *Czarniawi dwóch przyszło.

fno(mian, r(mn(n),nmo(np(n)))/poj, 3, WymN, nuzg, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nol13), 
	fpt(mian, R/L, St, wym([],_,_), Kl1, Zap1, Neg1, Dest1, I1, Pk1, po),
	flicz(mian, R/L, nuzg, Zap2, Dest2, I2, Pk2, na), 
	fno(dop, R/L, O, WymN, Kl3, Zap3, pre, Neg3, Dest3, I3, Pk3, po),
	{ różne(Kl3, uzg.nuzg.egz), 
	  R = r(_,nmo(_)), % wykluczony rodzaj męskoosobowy
	  obldest(Dest, [Dest1, Dest2, Dest3]), 
	  oblink(I, I1, I2), oblink(I, I2, I3), 
	  oblneg(-ani,  Neg, Neg1, Neg3),
	  oblzap(Zap, [Zap1, Zap2, Zap3]),
	  oblpk(Pk, [Pk1,Pk2,Pk3])  }.

% Te pięć facetek [było.]
% Które pięć facetek [było zaproszonych?]
% Te pięć z której klasy facetek [przyszło?]
% Tamte tyle facetek [było zaproszone.]
%[Ona jest taka, ] jakie pięć facetek [było.]
% [Nie wiem, ] które pięć facetek [było.]
% *Czarniawi dwóch facetów przyszło.

% \subsection{frazy nominalne skoordynowane}

% Frazy nominalne skoordynowane różnią się własnościami składniowymi w
% zależności od typu spójnika: koniunkcyjnego lub alternatywnego.
% Frazy ze spójnikiem koniunkcyjnym mogą być endo- lub egzocentryczne:
%%%% Przyszedł Jan i Marysia.
%%%% Przyszli Jan i Marysia.
% Frazy ze spójnikiem alternatywnym są zawsze endocentryczne:
%%%% Przyszedł Jan lub Marysia.
%%%* Przyszli Jan lub Marysia.
% Frazy endocentryczne są możliwe tylko w postpozycji (po czasowniku):
%%%% Przyszedł Jan i Marysia.
%%%* Jan i Marysia przyszła.
%%%% Przyszedł Jan lub Marysia.
%%%% Jan lub Marysia przyszła.
% Powyższe rozważania dotyczą wyłącznie podmiotów, bo gdzie indziej
% nie widać uzgodnień.

% Modyfikację przymiotnikiem dopuszczamy tylko dla fraz
% egzocentrycznych uznając, że w wypadku endocentrycznym przymiotnik
% dołącza się wewnątrz frazy składnikowej.

% We fno dozwolona dowolna predestynacja, ale musi być ta sama we
% wszystkich członach.  Wyjątek: mogą być wymieszane neut i
% pyt. (Drugi wyjątek — względne i pytajnozależnie niemożliwe, jeśli
% inicjalny spójnik — obsłużymy w odp. regule.)
obldest_fno_iter(Dest, Dest1, Dest) :- var(Dest1), !. % może przyjść z iteracji np. w noa1
obldest_fno_iter(neut,neut,neut).
obldest_fno_iter(neut,pyt,pyt).
obldest_fno_iter(pyt,neut,pyt).
obldest_fno_iter(pyt,pyt,pyt).
obldest_fno_iter(wz(Tfz,RL),wz(Tfz,RL),wz(Tfz,RL)).
obldest_fno_iter(pz,pz,pz).

% Następujący warunek uzależnia parametry całej frazy skoordynowanej
% od tego, czy jest to konstrukcja egzo- czy endocentryczna:
%
%                       wynikowe     1.skł.     ost.skł.    iter.
% oblparam_fno_koor(Oz, RLOKlPozWym, RLOKlPoz1, RLOKlPoz2,  [ROKl…]).

oblparam_fno_koor(Oz, R/mno/O/egz/Poz/wym([],_,[[]]),
	          R1/L1/O1/Kl1/pre, R2/_L2/O2/Kl2/pre, Params) :-
	member(Oz, [i,przec,ani, nietylko,tak,zarówno, alei]),
	egzorcyzuj_fno(R,O,[R1/O1/Kl1, R2/O2/Kl2 | Params]). %%,
        %% Ale to by psuło „chłopcy i Maria głupawi”.  Chcemy?
	%% % jeżeli wynikowe wartości są takie same, jak pierwszego
	%% % składnika, wykluczamy interpretację jako post — wystarczy
	%% % interpretacja endo:
	%% (R=R1, mno=L1, O=O1 *-> Poz=pre; true).

% W endocentrycznych Poz całości uzgadnia się ze składnikiem, z
% którego dziedziczymy, pozostały składnik ma Poz=pre.
oblparam_fno_koor(Oz, R2/L2/O2/Kl2/pre/wym(_,_,bw), 
	          _R1/_L1/_O1/_Kl1/pre, R2/L2/O2/Kl2/pre, _Params) :-
	\+ member(Oz, [i,przec,ani, nietylko,tak,zarówno, alei]).
oblparam_fno_koor(Oz, R1/L1/O1/Kl1/post/wym(_,_,bw), 
	          R1/L1/O1/Kl1/post, _R2/_L2/_O2/_Kl2/pre, _Params).

% przyjmujemy nmo i os 3 jako neutralny początek iteracji
egzorcyzuj_fno(r(_,nmo(_)), 3, []) :- !.
egzorcyzuj_fno(R, O, [R1/O1/Kl1 | Params]) :-
	member(Kl1, [rzecz,os,uzg,egz]),
	egzorcyzuj_fno(R2,O2,Params),
	egzorcyzuj_rodz(R2,R1,R),
	egzorcyzuj_os(O2,O1,O).

% W konstrukcji egzocentrycznej osoba jest minimum ze składników:
egzorcyzuj_os(O1, _, O1) :- var(O1), !.
egzorcyzuj_os(_, O2, O2) :- var(O2), !.
egzorcyzuj_os(O1, O2, O1) :- O1 < O2, !.
egzorcyzuj_os(O1, O2, O2) :- O1 >= O2.
%%%% Przyszliśmy chłopiec i ja.
%%%* Przyszli chłopiec i ja.
%%%% Przyszłyśmy trzy i on.
%%%? Przyszłyśmy on i trzy.

% W konstrukcji egzocentrycznej rodzaj męskoosobowy r(mn(m(zy)),mo) dominuje inne:
egzorcyzuj_rodz(r(mn(m(zy)),mo),_,r(mn(m(zy)),mo)) :- !.
egzorcyzuj_rodz(_,r(mn(m(zy)),mo),r(mn(m(zy)),mo)) :- !.
%%%% Przyszli facet i kobiety.
%%%* Przyszły facet i kobiety.
egzorcyzuj_rodz(_,_,r(_,nmo(_))). % nmo
% !!! A co będzie z „dziewczyna i pies”?


% \subsubsection{Realizacje równorzędne}

fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nor1),
	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
%???	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	fno(P, R3/L3, O3, wym([],_,WymN3), Kl3, Zap, Poz3, Neg, Dest3, ni, Pk3, po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3]),
	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN, 
	                    R1/L1/O1/Kl1/Poz1, R3/L3/O3/Kl3/Poz3, []) }.

%%%% Chcę złożyć pozew, względnie oskarżenie.
% MW: dla mnie przykłady mocno wątpliwe.  Naprawdę tak ma być?
%%%% Przyszli Jan, a nawet Maria.
%%%% Przyszedł Jan, a nawet Maria.
%%%* Jan, a nawet Maria przyszła.
%%%% Jan, a nawet Maria przyszli.
%%%% Zmienił się skład, a zatem struktura.
%%%% Skład, a zatem struktura zmieniła się.
%%%* Zmieniła się skład, a zatem struktura.
%%%* Skład, a zatem struktura zmienił się.

fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nor2),
	spójnik(rl,Oz,I,na),
	fno(P, R2/L2, O2, wym([],_,WymN2), Kl2, Zap, Poz2, Neg, Dest2, ni, Pk2, po),
	{ tylko_neut_pyt(Dest2) },
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	fno(P, R5/L5, O5, wym([],_,WymN5), Kl5, Zap, Poz5, Neg, Dest5, ni, Pk5, po),
	{ obldest_fno_iter(Dest2,Dest5,Dest),
	  oblpk(Pk,[Pk2,Pk3,Pk5]),
	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN, 
	                    R2/L2/O2/Kl2/Poz2, R5/L5/O5/Kl5/Poz5, []) }.

%%%% Nie tylko chłop, ale i baba przyszli.
%%%% Przyglądało się nie tylko któremu bakłażanowi, ale i jakiej papryce?
%%%% Przyglądało się nie tylko któremu bakłażanowi, ale i papryce?
%%%% Przyszedł nie Piotr, lecz Anna.
%%%% Nie Piotr, lecz Anna przyszła.
%%%% Nie czytała zarówno Maria, jak i nikt rozsądny.
%%%* Czytała zarówno Maria, jak i nikt rozsądny.
% blokowane wartościami pozycji składników:
%%%* Przyszedł nie tylko Maria albo Jan, ale i dziecko.
%%%% Przyszedł nie tylko Jan albo Maria, ale i dziecko.
%%%* Przyszedł nie tylko Maria i Jan, ale i dziecko.
%%%? Jan, nie zaś Maria przyszła.
%%%* Jan, nie zaś Maria i Piotrek przyszła.
%%%* Jan, nie zaś Piotrek i Maria przyszła.

% W tej regule końcowy przecinek jest wymagany.  Struktura bez niego
% jest akceptowana przez regułę nor1.

fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nor3),
	fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest1, I, Pk1, na),
	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,po),
	{ member(Oz, [czyli,więc,mianowicie,raczej]) },
	fno(P, R3/L3, O3, wym([],_,WymN3), Kl3, Zap, Poz3, Neg, Dest3, ni, Pk3, po),
	przec(Pk4,po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3,Pk4]) }.
%%%% ‹Traktat lizboński|, | a zatem | także Karta Praw Podstawowych|,› wkrótce zacznie obowiązywać.

% \subsubsection{Realizacje szeregowe}

% sp fno (, sp fno)* , sp fno
fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nos1),
	spójnik(sz,Oz,ni,na),
	{ \+ member(Oz, [przec,lub]) },
	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,na),
	      fno(P, R3/L3, O3, wym([],U3,WymN3), Kl3, Zap, pre, Neg, Dest3, ni, Pk3, po)
	    ]^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [], R3/O3/Kl3, Params]
	     ^[L3]^[U3]^[WymN3]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,na),
	{ sprawdz_neg(Oz,Neg) },
	fno(P, R6/L6, O6, wym([],_,WymN6), Kl6, Zap, Poz6, Neg, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN, 
	                    R1/L1/O1/Kl1/Poz1, R6/L6/O6/Kl6/Poz6, Params)
	  }.
%%%% Przyjdą i Jan, i Maria, i Piotr.

% fno (sp fno ,)+ sp fno
% + a nie *, bo schemat bez powtarzanego elementu załatwi s3
fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nos2),
	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
	sequence_of([
            [ spójnik(sz,Oz,ni,na),
	      fno(P, R3/L3, O3, wym([],U3,WymN3), Kl3, Zap, pre, Neg, Dest3, ni, Pk3, po),
	      przec(Pk4,po)
	    ]^[trzy_na_listę, PkL, [(0|0),Pk3,(p|wp)], [(0|0),Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [], R3/O3/Kl3, Params]
	     ^[L3]^[U3]^[WymN3]
	     ^[conajmniej1, 0, _, 1]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz \= przec },
	{ sprawdz_neg(Oz,Neg) },
	fno(P, R6/L6, O6, wym([],_,WymN6), Kl6, Zap, Poz6, Neg, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN,
	                    R1/L1/O1/Kl1/Poz1, R6/L6/O6/Kl6/Poz6, Params) }.

%%%% Przyjdą Jan i Maria, i Piotr, i Teresa.

% fno (, fno)* sp fno
% heheurystyka: zablokowałem dwuskładnikowe realizacje
% przecinkowe. „Jan, Maria” wydaje się mocno nieprawdopodobne.
% A jednak możliwe (zob. przykłady).

fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(nos3),
	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fno(P, R3/L3, O3, wym([],U3,WymN3), Kl3, Zap, pre, Neg, Dest3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [], R3/O3/Kl3, Params]
	     ^[L3]^[U3]^[WymN3]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz = przec ->  % length(Params,Powt), Powt>0,
	  Pk5 = (p|wp) ; Pk5 = (0|0) },
	{ sprawdz_neg(Oz,Neg) },
	fno(P, R6/L6, O6, wym([],_,WymN6), Kl6, Zap, Poz6, Neg, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN,
	                    R1/L1/O1/Kl1/Poz1, R6/L6/O6/Kl6/Poz6, Params)
	  }.
%%%% Przyjdą ‹Jan|, | Maria|, | Piotr | i | Teresa›.
%%%% Przyjdą ‹Jan|, | Maria|, | Piotr|, | Teresa›.
%%%% Jest to ‹ciekawy umysł|, | niepopularny umysł›.
%%%% Mam swoje ulubione ‹tytuły| , | fragmenty›...
%%%% Dzieci się uczą na pamięć ‹długości rzek|, | głębokości jezior›...


% \subsection{Fraza nominalna nietypowa}

% W cudzysłowie:
fno(P, R/L, O, Wym, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
	s(noc1),
	cudz(o,po),
	fno(P, R/L, O, Wym2, Kl, Zap, Poz, Neg, Dest, I, Pk, na),
	{ wymagania_odemknij(Wym2, Wym) },
	cudz(z,po).

%%%% Czytam na nowo ‹„|Lalkę|”›.
%%%% Taka jest ‹"technologia"› imprez masowych.
%%%% Pójdzie do "borówek"?
%%%% Reprezentuje atakowany ‹„nurt realistyczny”›.

% \section{FRAZA PRZYIMKOWO-NOMINALNA}

% Nietypowa przecinkowość: na wszelki wypadek blokujemy przecinek
% otwierający fno (udając, że przyimek ma przecinek końcowy).

fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
 	s(pm1),
	przyimek(Pm, P, na),
	fno(P, R/L, O, wym([],_,WymN), Kl, Zap, pre, Neg, Dest, I, Pk2, po),
	{ różne(Pm, temu),
	  oblpk(Pk, [(0|p), Pk2]) }.

% Analogiczny zabieg na przecinkowości poniżej.

fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
 	s(pm2),
	fno(P, R/L, O, wym([],_,_), Kl, Zap, pre, Neg, Dest, I, Pk1, po),
	przyimek(Pm, P, na),
	{ równe(Pm, naprzeciwko.temu),
	  oblpk(Pk, [Pk1, (p|0)]) }.

% Fraza przyimkowa modyfikowana partykułami i przysłówkami:

fpm(Pm, P, mod, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pm4),
	fpm(Pm, P, Kl, Zap, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod },
	sequence_of([ fps(St5, Kl5, Neg, Dest4, I4, Pk4, po)
                      ^[St5]^[Kl5],
		      modpart(fpm, Neg, Dest4, I4, Pk4, po) ]
                     ^[obldest_iter, Dest3, Dest4, Dest]
		     ^[oblink_iter, I3, I4, I]
		     ^[sprawdz_pk_iter, Pk3, Pk4, Pk]
		     ^[conajmniej1, 0, _, 1]
	).

fpm(Pm, P, mod, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pm5),
        fps(St1, Kl1, Neg, Dest1, I1, Pk1, po),
	sequence_of([ fps(St5, Kl5, Neg, Dest4, I2, Pk2, po)
                      ^[St5]^[Kl5],
		      modpart(fpm, Neg, Dest2, I2, Pk2, po) ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[oblink_iter, I1, I2, IL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL] 
	),
	fpm(Pm, P, Kl, Zap, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod,
 	  obldest_iter(DestL, Dest3, DestP),
	  oblink_iter(IL, I3, IP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([ fps(St6, Kl6, Neg, Dest4, I4, Pk4, po)
                      ^[St6]^[Kl6],
		      modpart(fpm, Neg, Dest4, I4, Pk4, po) ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[oblink_iter, IL, I4, I]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).

%%%% Czytali «całkiem | po łebkach».

fpm(Pm, P, mod, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pm3),
	modpart(fpm, Neg, Dest1, I1, Pk1, po),
	sequence_of([ fps(St5, Kl5, Neg, Dest4, I2, Pk2, po)
                      ^[St5]^[Kl5],
		      modpart(fpm, Neg, Dest2, I2, Pk2, po) ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[oblink_iter, I1, I2, IL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL] 
	),
	fpm(Pm, P, Kl, Zap, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod,
 	  obldest_iter(DestL, Dest3, DestP),
	  oblink_iter(IL, I3, IP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([ fps(St6, Kl6, Neg, Dest4, I4, Pk4, po)
                      ^[St6]^[Kl6],
		      modpart(fpm, Neg, Dest4, I4, Pk4, po) ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[oblink_iter, IL, I4, I]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).

%%%% Opowiadał historie ‹nie z tej ziemi›.
%%%% Była to propozycja ‹nie do odrzucenia›.

% \subsubsection{Realizacje równorzędne}

fpm(Pm, P, r, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmr1),
	fpm(Pm1, P1, Kl1, Zap, Neg, Dest1, I, Pk1, po),
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	fpm(Pm3, P3, Kl3, Zap, Neg, Dest3, ni, Pk3, po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3]),
	  obl_pmp([Pm1/P1,Pm3/P3], Pm, P)
	  }.

%%%% Czekali w domu, a nawet pod mostem.
%%%% Dopuszczała do towarzystwa, a nawet do sztamy.

fpm(Pm, P, r, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmr2),
	spójnik(rl,Oz,I,na),
	fpm(Pm2, P2, Kl2, Zap, Neg, Dest2, I, Pk2, po),
	{ tylko_neut_pyt(Dest2) },
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	fpm(Pm5, P5, Kl5, Zap, Neg, Dest5, ni, Pk5, po),
	{ obldest_fno_iter(Dest2,Dest5,Dest),
	  oblpk(Pk,[Pk2,Pk3,Pk5]),
	  obl_pmp([Pm2/P2,Pm5/P5], Pm, P) }.

%%%% ‹Nie tylko | na skale|, | ale i | na piasku› budowały.


% W tej regule końcowy przecinek jest wymagany.  Struktura bez niego
% jest akceptowana przez regułę pmr1.

fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmr3),
	fpm(Pm1, P1, Kl, Zap, Neg, Dest1, I, Pk1, na),
	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,po),
	{ member(Oz, [czyli,więc,mianowicie,raczej]) },
	fpm(Pm3, P3, Kl3, Zap, Neg, Dest3, ni, Pk3, po),
	przec(Pk4,po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3,Pk4]),
	  obl_pmp([Pm1/P1,Pm3/P3], Pm, P) }.

%%%% Zaczyna się ‹od jajka |, | czyli | od początku›.
%%%% Ogląda się ‹ku oknu|, | czyli | w stronę widza›.
%%%% Mam zastrzeżenie do sprawozdania, a mianowicie do nieprawdziwej informacji zawartej na stronie 74.

% \subsubsection{Realizacje szeregowe}

% Realizacje koordynacyjne fraz przyimkowych zawierają ciekawą
% możliwość: koordynowania fraz z różnymi przyimkami.  Dopuszczamy
% swobodnie taką możliwość we frazach luźnych.  We frazach wymaganych
% będzie to sterowane informacją ze słownika walencyjnego (ale jeszcze
% nie mamy odpowiedniej postaci).  Jeżeli słownik dopuści koordynację
% danych przyimków, to dopuścimy.

% Parametry Pm i P frazy przyimkowej skoordynowanej będą listami (bez
% powtórzeń) par Pm/P, które wystąpiły w koordynacji.  Z tego punktu
% widzenia byłoby wygodniej mieć jeden parametr Pm/P, ale już jest za
% późno.

obl_pmp(PmP, Pm, P) :-
	sort(PmP, PmPSorted),	% pomija powtórzenia!
	rozdziel(PmPSorted,Pm,P).
	
rozdziel([Pm/P],Pm,P) :- !.
rozdziel(PmP,Pm,P):- rozdziel2(PmP,Pm,P).
rozdziel2([],[],[]).
rozdziel2([Pm/P | PP], [Pm|Pm2], [P|P2]) :- rozdziel2(PP,Pm2,P2).

% Poniższy warunek służy do niedopuszczenia frazy szeregowej jako elementu
% frazy szeregowej, co prowadziłoby do powstawania nieciekawych analiz
% typu „‹w domu, ‹w ogrodzie i w zagrodzie››” albo „‹‹w domu, w
% ogrodzie› i w zagrodzie››”.

sprawdz_kl_nie_sz(Kl) :- var(Kl), !.
sprawdz_kl_nie_sz(Kl) :- Kl \= sz.


% sp fpm (, sp fpm)* , sp fpm
fpm(Pm, P, sz, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pms1),
	spójnik(sz,Oz,ni,po),
	{ \+ member(Oz, [przec,lub]) },
	fpm(Pm1, P1, Kl1, Zap, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	{sprawdz_kl_nie_sz(Kl1)},
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,po),
	      fpm(Pm3, P3, Kl3, Zap, Neg, Dest3, ni, Pk3, po)
	    ]^[sprawdz_kl_nie_sz, Kl3]
	     ^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [Pm1/P1], Pm3/P3, PmPPostSeq]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,na),
	{ sprawdz_neg(Oz,Neg) },
	fpm(Pm6, P6, Kl6, Zap, Neg, Dest6, ni, Pk6, po),
	{sprawdz_kl_nie_sz(Kl6)},
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  obl_pmp([Pm6/P6 | PmPPostSeq], Pm, P)
	  }.

%%%% Byli i w domu, i w ogrodzie, i nad rzeką.

% fpm (sp fpm ,)+ sp fpm
% + a nie *, bo schemat bez powtarzanego elementu załatwi s3
fpm(Pm, P, sz, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pms2),
	fpm(Pm1, P1, Kl1, Zap, Neg, Dest1, I, Pk1, po),
	{sprawdz_kl_nie_sz(Kl1)},
	sequence_of([
            [ spójnik(sz,Oz,ni,na),
	      fpm(Pm3, P3, Kl3, Zap, Neg, Dest3, ni, Pk3, po),
	      przec(Pk4,po)
	    ]^[sprawdz_kl_nie_sz, Kl3]
	     ^[trzy_na_listę, PkL, [(0|0),Pk3,(p|wp)], [(0|0),Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [Pm1/P1], Pm3/P3, PmPPostSeq]
	     ^[conajmniej1, 0, _, 1]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz \= przec },
	{ sprawdz_neg(Oz,Neg) },
	fpm(Pm6, P6, Kl6, Zap, Neg, Dest6, ni, Pk6, po),
	{sprawdz_kl_nie_sz(Kl6)},
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  obl_pmp([Pm6/P6 | PmPPostSeq], Pm, P)
	  }.

%%%% Byli w domu i w ogrodzie, i u Piotra, i nad rzeką.

% fpm (, fpm)* sp fpm
fpm(Pm, P, sz, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmsz3),
	fpm(Pm1, P1, Kl1, Zap, Neg, Dest1, I, Pk1, po),
	{sprawdz_kl_nie_sz(Kl1)},
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fpm(Pm3, P3, Kl3, Zap, Neg, Dest3, ni, Pk3, po)
	    ]^[sprawdz_kl_nie_sz, Kl3]
	     ^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[zroblistę_iter, [Pm1/P1], Pm3/P3, PmPPostSeq]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz = przec -> Pk5 = (p|wp) ; Pk5 = (0|0) },
	{ sprawdz_neg(Oz,Neg) },
	fpm(Pm6, P6, Kl6, Zap, Neg, Dest6, ni, Pk6, po),
	{sprawdz_kl_nie_sz(Kl6)},
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  obl_pmp([Pm6/P6 | PmPPostSeq], Pm, P)
	  }.

%%%% Mury chronią ‹przed powodzią | i | przed atakiem›.
%%%% Wody nalał ‹do szklanki|, | do kubka| i | do butelki›.
%%%% Był ‹przeciwko podwyżkom|, | przeciwko  ustawom | i | przeciwko wszelkim zmianom›.
%%%% Czytali ‹w domu | i | na ganku›.
%%%% Czekali ‹w domu | , | pod mostem | i | na ganku›.

% \subsection{Fraza przyimkowa nietypowa}

% W cudzysłowie:
fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmc1),
	cudz(o,po),
	fpm(Pm, P, Kl, Zap, Neg, Dest, I, Pk, na),
	cudz(z,po).


% \section{FRAZA PRZYIMKOWO-PRZYMIOTNIKOWA}

% Przecinkowość j.w.

fpmpt(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
 	s(pma1),
	przyimek(Pm, P, na),
	fpt(P, R/L, St, wym([],_,_), Kl, Zap, Neg, Dest, I, Pk2, po),
	{ oblpk(Pk, [(0|p), Pk2]) }.

fpmpt(Pm, pop, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
 	s(pma2),
	przyimek(Pm, P, na),
% Ta barokowa heurystyka ma zapewnić tylko po jednej interpretacji dla
% poprzyimkowych przymiotników opisanych wedle reguł NKJP:
	{ równe(Pm, [z,za]) -> P=bier ; równe(P, [dop,bier]) },
	fpt(pop, R/L, St, wym([],_,_), Kl, Zap, Neg, Dest, I, Pk2, po),
	{ oblpk(Pk, [(0|p), Pk2]) }.

% \subsection{Fraza przyimkowo-przymiotnikowa nietypowa}

% W cudzysłowie:
fpmpt(Pm, P, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pmc2),
	cudz(o,po),
	fpmpt(Pm, P, Kl, Zap, Neg, Dest, I, Pk, na),
	cudz(z,po).


%  \section{FRAZA PRZYMIOTNIKOWA}

% \subsection{Realizacje terminalne}

fpt(P, Rl, St, WymA, przym, bzap, _Neg, neut, I, (0|0), Sub) -->
	s(pt1),
	formaprzym(P, Rl, St, WymA, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

% to jest chyba źle:
fpt(P, Rl, row, wym([],_,[[]]), jaki, bzap, _Neg, Dest, I, (0|0), Sub) -->
	s(pt2),
	zaimprzym(F, P, Rl, na), 
	{ równe(F, [czyj,jaki,który]),
	  równe(Dest, pyt.pz.wz(F,Rl))},
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).
% !!!mw: pt27–31

fpt(P, Rl, row, wym([],_,[[]]), przym, tk, _Neg, neut, I, (0|0), Sub) -->
	s(pt3),
	zaimprzym(taki, P, Rl, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

fpt(P, Rl, row, wym([],_,[[]]), przym, bzap, _Neg, neut, I, (0|0), Sub) -->
	s(pt4),
	zaimprzym(jakiś, P, Rl, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

% \subsection{Z podrzędnikami}

fpt(P, Rl, St, wym(_,_,bw), Kl1, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pts1), 
	fpt(P, Rl, St, WymA, Kl1, Zap1, Neg, Dest1, I1, Pk1, na),
	{ WymA = wym(_,_,[_|_]) }, % czyli wymagania jeszcze nie wysycone
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[oblwym_iter, WymA, W4, ResztaWym],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, Zap]
          ^[obldest_iter, Dest1, Dest2, Dest]
	  ^[oblink_iter, I1, I2, I]
          ^[sprawdz_pk_iter, Pk1, Pk2, Pk]
% tylko w tej regule, inaczej możliwy jeden element po prawej i pętla:
          ^[conajmniej1, 0, _, 1]),
	  { wymagania_zamknij(ResztaWym) }.

%%%% Nóż jest ‹dobry | do walki›.
%%%% Pieczarki mają kapelusz ‹biały | od spodu›.
%%%% ‹Jaka | gdzie› ona jest?
%%%% ‹Poświęconą | właśnie› Piotrowi książkę czytano.
%%%% Czytam, ‹głodny bowiem wiedzy› jestem.
%%%% On jest ‹żądny | czego›?
%%%% Znam ‹poświęconą | Piotrowi› książkę.
%%%% Okazał się ‹skory | jakiś | do gniewu›.

fpt(P, Rl, St, wym(_,_,bw), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(pts2), 
	fps(St1, Kl1, Neg1, Dest1, I1, Pk1, po),
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[zroblistę_iter, [], W4, PreWymA],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, ZapLL]
          ^[obldest_iter, Dest1, Dest2, DestLL]
	  ^[oblink_iter, I1, I2, ILL]
          ^[sprawdz_pk_iter, Pk1, Pk2, PkLL]
        ),
	fpt(P, Rl, St, WymA, Kl, Zap5, Neg, Dest5, I5, Pk5, na),
	{ WymA = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  oblzap_iter(ZapLL,Zap5,ZapPP),
	  obldest_iter(DestLL, Dest5, DestPP),
	  oblink_iter(ILL,I5,IPP),
	  sprawdz_pk_iter(PkLL, Pk5, PkPP),
	  wyjmijl(PreWymA, WymA, PostWymA) },
	sequence_of([
           fps(St6, Kl6, Neg6, Dest6, I6, Pk6, po)
              ^[St6]^[Kl6]^[Neg6],
           fpm(Pm7, P7, Kl7, Zap6, Neg7, Dest6, I6, Pk6, po)
              ^[Pm7]^[P7]^[Kl7]^[Neg7],
	   fw(W8, A8, C8, Rl8, O8, post, tak, Dest6, I6, Pk6, po)
              ^[oblwym_iter, PostWymA, W8, ResztaWym],
	   modpart(fpt, Neg, Dest6, I6, Pk6, po),
	   modjaki(P,Rl,Zap6,Dest6,I6,Pk6,po)
          ]
	  ^[oblzap_iter, ZapPP, Zap6, Zap]
          ^[obldest_iter, DestPP, Dest6, Dest]
	  ^[oblink_iter, IPP, I6, I]
          ^[sprawdz_pk_iter, PkPP, Pk6, Pk]
        ),
	{ wymagania_zamknij(ResztaWym) }.

%%%% Nie jest źle, ‹kiedy bowiem | poświęconą Piotrowi przez niego› książkę czytano?

fpt(P, Rl, St, wym(_,_,bw), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptm2), 
	fpm(Pm1, P1, Kl1, Zap1, Neg1, Dest1, I1, Pk1, po),
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[zroblistę_iter, [], W4, PreWymA],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, ZapLL]
          ^[obldest_iter, Dest1, Dest2, DestLL]
	  ^[oblink_iter, I1, I2, ILL]
          ^[sprawdz_pk_iter, Pk1, Pk2, PkLL]
        ),
	fpt(P, Rl, St, WymA, Kl, Zap5, Neg, Dest5, I5, Pk5, na),
	{ WymA = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  oblzap_iter(ZapLL,Zap5,ZapPP),
	  obldest_iter(DestLL, Dest5, DestPP),
	  oblink_iter(ILL,I5,IPP),
	  sprawdz_pk_iter(PkLL, Pk5, PkPP),
	  wyjmijl(PreWymA, WymA, PostWymA) },
	sequence_of([
           fps(St6, Kl6, Neg6, Dest6, I6, Pk6, po)
              ^[St6]^[Kl6]^[Neg6],
           fpm(Pm7, P7, Kl7, Zap6, Neg7, Dest6, I6, Pk6, po)
              ^[Pm7]^[P7]^[Kl7]^[Neg7],
	   fw(W8, A8, C8, Rl8, O8, post, tak, Dest6, I6, Pk6, po)
              ^[oblwym_iter, PostWymA, W8, ResztaWym],
	   modpart(fpt, Neg, Dest6, I6, Pk6, po),
	   modjaki(P,Rl,Zap6,Dest6,I6,Pk6,po)
          ]
	  ^[oblzap_iter, ZapPP, Zap6, Zap]
          ^[obldest_iter, DestPP, Dest6, Dest]
	  ^[oblink_iter, IPP, I6, I]
          ^[sprawdz_pk_iter, PkPP, Pk6, Pk]
        ),
	{ wymagania_zamknij(ResztaWym) }.

%%%% Znam jej ‹przez tego autora | poświęconą› książkę.
%%%% Podniosła ‹od spodu | złocisty› grzyb.
%%%% Nie wiadomo, ‹przez kogo | poświęconą | Piotrowi› książkę czytano.

fpt(P, Rl, St, wym(_,_,bw), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptw2), 
	fw(W1, A1, C1, Rl1, O1, post, tak, Dest1, I1, Pk1, po),
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[zroblistę_iter, [W1], W4, PreWymA],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, ZapLL]
          ^[obldest_iter, Dest1, Dest2, DestLL]
	  ^[oblink_iter, I1, I2, ILL]
          ^[sprawdz_pk_iter, Pk1, Pk2, PkLL]
        ),
	fpt(P, Rl, St, WymA, Kl, Zap5, Neg, Dest5, I5, Pk5, na),
	{ WymA = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  oblzap_iter(ZapLL,Zap5,ZapPP),
	  obldest_iter(DestLL, Dest5, DestPP),
	  oblink_iter(ILL,I5,IPP),
	  sprawdz_pk_iter(PkLL, Pk5, PkPP),
	  wyjmijl(PreWymA, WymA, PostWymA) },
	sequence_of([
           fps(St6, Kl6, Neg6, Dest6, I6, Pk6, po)
              ^[St6]^[Kl6]^[Neg6],
           fpm(Pm7, P7, Kl7, Zap6, Neg7, Dest6, I6, Pk6, po)
              ^[Pm7]^[P7]^[Kl7]^[Neg7],
	   fw(W8, A8, C8, Rl8, O8, post, tak, Dest6, I6, Pk6, po)
              ^[oblwym_iter, PostWymA, W8, ResztaWym],
	   modpart(fpt, Neg, Dest6, I6, Pk6, po),
	   modjaki(P,Rl,Zap6,Dest6,I6,Pk6,po)
          ]
	  ^[oblzap_iter, ZapPP, Zap6, Zap]
          ^[obldest_iter, DestPP, Dest6, Dest]
	  ^[oblink_iter, IPP, I6, I]
          ^[sprawdz_pk_iter, PkPP, Pk6, Pk]
        ),
	{ wymagania_zamknij(ResztaWym) }.

%%%% ‹Którym chłopcem | zajętą› znasz?
%%%% Znam ‹Piotrowi | przez niego poświęconą› książkę.
%%%% Nie martwię się, ‹taką bowiem dziewczyną | zajęty› chłopiec nie jest mi potrzebny.
%%%% ‹Kim | interesujący się› chłopcy przyjdą, nie pytaliście.

fpt(P, Rl, St, wym(_,_,bw), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptm3), 
	modpart(fpt, Neg, Dest1, I1, Pk1, po),
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[zroblistę_iter, [], W4, PreWymA],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, ZapLL]
          ^[obldest_iter, Dest1, Dest2, DestLL]
	  ^[oblink_iter, I1, I2, ILL]
          ^[sprawdz_pk_iter, Pk1, Pk2, PkLL]
        ),
	fpt(P, Rl, St, WymA, Kl, Zap5, Neg, Dest5, I5, Pk5, na),
	{ WymA = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  oblzap_iter(ZapLL,Zap5,ZapPP),
	  obldest_iter(DestLL, Dest5, DestPP),
	  oblink_iter(ILL,I5,IPP),
	  sprawdz_pk_iter(PkLL, Pk5, PkPP),
	  wyjmijl(PreWymA, WymA, PostWymA) },
	sequence_of([
           fps(St6, Kl6, Neg6, Dest6, I6, Pk6, po)
              ^[St6]^[Kl6]^[Neg6],
           fpm(Pm7, P7, Kl7, Zap6, Neg7, Dest6, I6, Pk6, po)
              ^[Pm7]^[P7]^[Kl7]^[Neg7],
	   fw(W8, A8, C8, Rl8, O8, post, tak, Dest6, I6, Pk6, po)
              ^[oblwym_iter, PostWymA, W8, ResztaWym],
	   modpart(fpt, Neg, Dest6, I6, Pk6, po),
	   modjaki(P,Rl,Zap6,Dest6,I6,Pk6,po)
          ]
	  ^[oblzap_iter, ZapPP, Zap6, Zap]
          ^[obldest_iter, DestPP, Dest6, Dest]
	  ^[oblink_iter, IPP, I6, I]
          ^[sprawdz_pk_iter, PkPP, Pk6, Pk]
        ),
	{ wymagania_zamknij(ResztaWym) }.

fpt(P, Rl, St, wym(_,_,bw), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptm5), 
	modjaki(P,Rl,Zap1,Dest1,I1,Pk1,po),
	sequence_of([
           fps(St2, Kl2, Neg2, Dest2, I2, Pk2, po)
              ^[St2]^[Kl2]^[Neg2],
           fpm(Pm, P3, Kl3, Zap2, Neg3, Dest2, I2, Pk2, po)
              ^[Pm]^[P3]^[Kl3]^[Neg3],
	   fw(W4, A4, C4, Rl4, O4, post, tak, Dest2, I2, Pk2, po)
              ^[zroblistę_iter, [], W4, PreWymA],
	   modpart(fpt, Neg, Dest2, I2, Pk2, po),
	   modjaki(P,Rl,Zap2,Dest2,I2,Pk2,po)
          ]
	  ^[oblzap_iter, Zap1, Zap2, ZapLL]
          ^[obldest_iter, Dest1, Dest2, DestLL]
	  ^[oblink_iter, I1, I2, ILL]
          ^[sprawdz_pk_iter, Pk1, Pk2, PkLL]
        ),
	fpt(P, Rl, St, WymA, Kl, Zap5, Neg, Dest5, I5, Pk5, na),
	{ WymA = wym(_,_,[_|_]), % czyli wymagania jeszcze nie wysycone
	  oblzap_iter(ZapLL,Zap5,ZapPP),
	  obldest_iter(DestLL, Dest5, DestPP),
	  oblink_iter(ILL,I5,IPP),
	  sprawdz_pk_iter(PkLL, Pk5, PkPP),
	  wyjmijl(PreWymA, WymA, PostWymA) },
	sequence_of([
           fps(St6, Kl6, Neg6, Dest6, I6, Pk6, po)
              ^[St6]^[Kl6]^[Neg6],
           fpm(Pm7, P7, Kl7, Zap6, Neg7, Dest6, I6, Pk6, po)
              ^[Pm7]^[P7]^[Kl7]^[Neg7],
	   fw(W8, A8, C8, Rl8, O8, post, tak, Dest6, I6, Pk6, po)
              ^[oblwym_iter, PostWymA, W8, ResztaWym],
	   modpart(fpt, Neg, Dest6, I6, Pk6, po),
	   modjaki(P,Rl,Zap6,Dest6,I6,Pk6,po)
          ]
	  ^[oblzap_iter, ZapPP, Zap6, Zap]
          ^[obldest_iter, DestPP, Dest6, Dest]
	  ^[oblink_iter, IPP, I6, I]
          ^[sprawdz_pk_iter, PkPP, Pk6, Pk]
        ),
	{ wymagania_zamknij(ResztaWym) }.

%%%% Nie jest to ‹takie | proste›.
%%%% ‹Jakaś | biało-szara› była.
%%%% Pamiętali go ‹jakimś | takim | krostowatym›.


% \subsection{z podrzędnikiem jakowatym}
% !!!mw: dodać pt2 z GFJP!


% \subsubsection{Realizacje równorzędne}

fpt(P, R/L, St1, wym([],_,[[]]), Kl1, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptr1),
	fpt(P, R/L, St1, wym([],_,WymA1), Kl1, Zap, Neg, Dest1, I, Pk1, po),
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	fpt(P, R/L, St3, wym([],_,WymA3), Kl3, Zap, Neg, Dest3, ni, Pk3, po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3]) }.

%%%% Następują ‹dynamiczne|, | ale | dostosowane do sytuacji› zmiany.


fpt(P, R/L, St2, wym([],_,[[]]), Kl1, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptr2),
	spójnik(rl,Oz,I,na),
	fpt(P, R/L, St2, wym([],_,WymA2), Kl2, Zap, Neg, Dest2, I, Pk2, po),
	{ tylko_neut_pyt(Dest2) },
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	fpt(P, R/L, St5, wym([],_,WymA5), Kl5, Zap, Neg, Dest5, ni, Pk5, po),
	{ obldest_fno_iter(Dest2,Dest5,Dest),
	  oblpk(Pk,[Pk2,Pk3,Pk5]) }.

%%%% Następują ‹nie tylko | dostosowane do realiów społecznych i kapitałowych|, | ale i | dynamiczne› zmiany.

% W tej regule końcowy przecinek jest wymagany.  Struktura bez niego
% jest akceptowana przez regułę ptr1.


fpt(P, R/L, St1, wym([],_,[[]]), Kl1, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptr3),
	fpt(P, R/L, St1, wym([],_,WymA1), Kl1, Zap, Neg, Dest1, I, Pk1, po),
	{ tylko_neut_pyt(Dest1) },
	przec(Pk2,po),
	spójnik(rc,Oz,ni,po),
	{ member(Oz, [czyli,więc,mianowicie,raczej]) },
	fpt(P, R/L, St3, wym([],_,WymA3), Kl3, Zap, Neg, Dest3, ni, Pk3, po),
	przec(Pk4,po),
	{ obldest_fno_iter(Dest1,Dest3,Dest),
	  oblpk(Pk,[Pk1,Pk2,Pk3,Pk4]) }.

%%%% Następują ‹dostosowane do sytuacji|, | czyli | dynamiczne|,› zmiany.


% \subsubsection{Realizacje szeregowe}

%% % sp fpt (, sp fpt)* , sp fpt
%% fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(nos1),
%% 	spójnik(sz,Oz,ni,na),
%% 	{ \+ member(Oz, [przec,lub]) },
%% 	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
%% 	{ tylko_neut_pyt(Dest1) },
%% 	sequence_of([
%%             [ przec(Pk2,po),
%% 	      spójnik(sz,Oz,ni,na),
%% 	      fno(P, R3/L3, O3, wym([],_,WymN3), Kl3, Zap, pre, Neg, Dest3, ni, Pk3, po)
%% 	    ]^[trzy_na_listę, PkL, [Pk2,(0|0),Pk3], [Pk4,(0|0),Pk6]]
%% 	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
%% 	     ^[zroblistę_iter, [], R3/O3/Kl3, Params]
%% 	     ^[L3]^[WymN3]
%% 	]),
%% 	przec(Pk4,po),
%% 	spójnik(szk,Oz,ni,na),
%% 	{ sprawdz_neg(Oz,Neg) },
%% 	fno(P, R6/L6, O6, wym([],_,WymN6), Kl6, Zap, Poz6, Neg, Dest6, ni, Pk6, po),
%% 	{ oblpk(Pk,[Pk1 | PkL]),
%% 	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
%% 	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN, 
%% 	                    R1/L1/O1/Kl1/Poz1, R6/L6/O6/Kl6/Poz6, Params)
%% 	  }.
%% %%%% Przyjdą i Jan, i Maria, i Piotr.

%% % fpt (sp fpt ,)+ sp fpt
%% % + a nie *, bo schemat bez powtarzanego elementu załatwi s3
%% fno(P, R/L, O, WymN, Kl, Zap, Poz, Neg, Dest, I, Pk, Sub) -->
%% 	s(nos2),
%% 	fno(P, R1/L1, O1, wym([],_,WymN1), Kl1, Zap, Poz1, Neg, Dest1, I, Pk1, po),
%% 	sequence_of([
%%             [ spójnik(sz,Oz,ni,na),
%% 	      fno(P, R3/L3, O3, wym([],_,WymN3), Kl3, Zap, pre, Neg, Dest3, ni, Pk3, po),
%% 	      przec(Pk4,po)
%% 	    ]^[trzy_na_listę, PkL, [(0|0),Pk3,(p|wp)], [(0|0),Pk6]]
%% 	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
%% 	     ^[zroblistę_iter, [], R3/O3/Kl3, Params]
%% 	     ^[L3]^[WymN3]
%% 	     ^[conajmniej1, 0, _, 1]
%% 	]),
%% 	spójnik(szk,Oz,ni,na),
%% 	{ Oz \= przec },
%% 	{ sprawdz_neg(Oz,Neg) },
%% 	fno(P, R6/L6, O6, wym([],_,WymN6), Kl6, Zap, Poz6, Neg, Dest6, ni, Pk6, po),
%% 	{ oblpk(Pk,[Pk1 | PkL]),
%% 	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
%% 	  oblparam_fno_koor(Oz, R/L/O/Kl/Poz/WymN,
%% 	                    R1/L1/O1/Kl1/Poz1, R6/L6/O6/Kl6/Poz6, Params) }.

%% %%%% Przyjdą Jan i Maria, i Piotr, i Teresa.

% fpt (, fpt)* sp fpt
fpt(P, R/L, St, wym([],_,[[]]), Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptsz3),
	fpt(P, R/L, St1, wym([],_,WymA1), Kl1, Zap, Neg, Dest1, I, Pk1, po),
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fpt(P, R/L, St3, wym([],U3,WymA3), Kl3, Zap, Neg, Dest3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[U3]^[WymA3]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz = przec -> Pk5 = (p|wp) ; Pk5 = (0|0) },
	{ sprawdz_neg(Oz,Neg) },
	fpt(P, R/L, St6, wym([],_,WymA6), Kl6, Zap, Neg, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest)
	  }.

%%%% Widzę mały, zapuszczony i niepozorny domek.
%%%* Widzę mały, zapuszczone i niepozorny domek.
%%%% Na progu stał wysoki, zarośnięty mężczyzna.
%%%% Wieczór był ciepły i pełen spokoju.
%%%% Jakub starał się być spokojny i uprzejmy.
%%%% To wypracowuje się na codziennych, mozolnych próbach.
%%%% Potem często pokazywano ich przytulających się lub całujących.
%%%% Gierek wytrzymał długą pauzę i zaczął bardzo spokojnym, niskim głosem.
%%%% Ale Europa Zachodnia jest bardzo łagodna i tolerancyjna wobec zbrodniarzy komunistycznych.
%%%% Bracia, ‹postawni, spokojni, dobrze się prezentujący›, mówią swoje kwestie.

% \subsection{Fraza przymiotnikowa nietypowa}

% W cudzysłowie:
fpt(P, R/L, St, Wym, Kl, Zap, Neg, Dest, I, Pk, Sub) -->
	s(ptc1),
	cudz(o,po),
	fpt(P, R/L, St, Wym2, Kl, Zap, Neg, Dest, I, Pk, na),
	{ wymagania_odemknij(Wym2, Wym) },
	cudz(z,po).

%%%% Gazeta musi stać się "bardziej polityczna".



%  \section{FRAZA LICZEBNIKOWA}

% do poprawienia: Dest pyt (ile), Zap?

flicz(P, R/L, Akom, bzap, Dest, ni, (0|0), Sub) -->
	s(licz1),
	formalicz(P, R/L, Akom, Kl, na),
	{ obl_kl_licz(Kl,Dest) }.

% przez licz1 mogą przejść wszystkie liczebniki z wyjątkiem
% nieodmiennego ‹jeden›, które musi być częścią trójki:
obl_kl_licz(t(1),_) :- !, false.
% dla pozostałych pobieramy Dest:
obl_kl_licz(pyt,pyt) :- !.
obl_kl_licz(neut,neut) :- !.
obl_kl_licz(t(_),neut).

% Trójka liczebnikowa: 

flicz(P, R/L, Akom, bzap, neut, ni, (0|0), Sub) -->
	s(licz2),
	formalicz(P, R/L, Akom1, Kl1, po),
	optional(formalicz(P, R/L, Akom2, Kl2, po),{ troj_licz(Kl1,Kl2) },{ Kl2=Kl1 }),
	formalicz(P, R/L, Akom, Kl3, na),
	{ troj_licz(Kl2,Kl3) }.

%%%% trzystoma pięćdziesięcioma czterema
%%%% stu dwunastu
%%%% trzystu kilkadziesięciorgiem
%%%% pięćdziesiąt parę

% Czy dane elementy tworzą dopuszczalne następstwo w trójce:
% po setkach mogą nastąpić dziesiątki
troj_licz(t(s),t(d)).
% lub nastki
troj_licz(t(s),t(n)).
% lub bezpośrednio jednostki
troj_licz(t(s),t(j)).
troj_licz(t(s),t(1)).
% po dziesiątkach mogą nastąpić jednostki
troj_licz(t(d),t(j)).
troj_licz(t(d),t(1)).
% inne następstwa nie są możliwe.

% do dodania: liczebniki jeszcze bardziej złożone

% \subsubsection{Fraza liczebnikowa modyfikowana partykułami}

% W poniższych regułach koszmarne hakerstwo: musimy zablokować
% możliwość przyczepiania partykuł nie wszystkich na raz.  We frazach
% innych klas używamy do tego parametru klasy, którego flicz nie ma.
% Robimy więc rzecz koszmarną: wiemy, że flicz jest zawsze
% nadrzędnikiem, więc ustalamy wartość parametru Sub=na, a w regule
% sprawdzamy, czy Sub3 jest zmienną, a więc jednostka będąca centrum
% nie powstała jako lewa strona poniższych reguł.  Po zakończeniu
% projektu trzeba dodać flicz parametr klasy(?), na co teraz nie
% możemy sobie pozwolić.

flicz(P, RL, Akom, Zap, Dest, I, Pk, na) -->
	s(lim1),
	modpart(flicz, Neg, Dest1, I, Pk1, po),
	sequence_of([ modpart(flicz, Neg, Dest2, ni, Pk2, po) ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL] 
	),
	flicz(P, RL, Akom, Zap, Dest3, ni, Pk3, Sub3),
	{ var(Sub3), Sub3=na,
 	  obldest_iter(DestL, Dest3, DestP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([ modpart(flicz, Neg, Dest4, ni, Pk4, po) ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).

%%%% Znam ‹chyba trzech tylko› niegłupich sportowców z Warszawy.

flicz(P, RL, Akom, Zap, Dest, I, Pk, na) -->
	s(lim2),
	flicz(P, RL, Akom, Zap, Dest3, ni, Pk3, Sub3),
	{ var(Sub3), Sub3=na },
	sequence_of([ modpart(flicz, Neg, Dest4, ni, Pk4, po) ]
                     ^[obldest_iter, Dest3, Dest4, Dest]
		     ^[sprawdz_pk_iter, Pk3, Pk4, Pk]
		     ^[conajmniej1, 0, _, 1]
	).


% \section{FRAZA PRZYSŁÓWKOWA}

% \subsection{Realizacja terminalna}

fps(St, Kl, Neg, Dest, I, (0|0), Sub) -->
	s(ps1),
	formaprzys(St, Kl, Neg, Dest, na),
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).


% !!!mw: dodać ps17–21

% \subsection{Realizacja jakbyiczna}
% !!!mw: dodać ps2 z GFJP!

% \subsection{Realizacje z podrzędnikami}

fps(St, mod, Neg, Dest, I, Pk, Sub) -->
	s(psm1),
	fps(St, Kl, Neg, Dest1, I1, Pk1, na),
	{ Kl \= mod },
	sequence_of([
          fpm(Pm4, P4, Kl4, Zap4, Neg, Dest4, I4, Pk4, po)
            ^[Pm4]^[P4]^[Kl4]^[Zap4],
	  fps(St4, Kl4, Neg, Dest4, I4, Pk4, po)
            ^[St4]^[Kl4],
	  modpart(fpt, Neg, Dest4, I4, Pk4, po) 
                     ]
                     ^[obldest_iter, Dest1, Dest4, Dest]
		     ^[oblink_iter, I1, I4, I]
		     ^[sprawdz_pk_iter, Pk1, Pk4, Pk]
		     ^[conajmniej1, 0, _, 1]
	).

fps(St, mod, Neg, Dest, I, Pk, Sub) -->
	s(psm2),
	fpm(Pm, P1, Kl1, Zap1, Neg, Dest1, I1, Pk1, po),
	sequence_of([
          fpm(Pm2, P2, Kl2, Zap2, Neg, Dest2, I2, Pk2, po)
            ^[Pm2]^[P2]^[Kl2]^[Zap2],
	  fps(St2, Kl2, Neg, Dest2, I2, Pk2, po)
            ^[St2]^[Kl2],
	  modpart(fpt, Neg, Dest2, I2, Pk2, po) 
                     ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[oblink_iter, I1, I2, IL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL]
	),
	fps(St, Kl, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod,
 	  obldest_iter(DestL, Dest3, DestP),
	  oblink_iter(IL,I3,IP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([
          fpm(Pm4, P4, Kl4, Zap4, Neg, Dest4, I4, Pk4, po)
            ^[Pm4]^[P4]^[Kl4]^[Zap4],
	  fps(St4, Kl4, Neg, Dest4, I4, Pk4, po)
            ^[St4]^[Kl4],
	  modpart(fpt, Neg, Dest4, I4, Pk4, po) 
                     ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[oblink_iter, IP, I4, I]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).

fps(St, mod, Neg, Dest, I, Pk, Sub) -->
	s(psm4),
	fps(St1, Kl1, Neg, Dest1, I1, Pk1, po),
	sequence_of([
          fpm(Pm2, P2, Kl2, Zap2, Neg, Dest2, I2, Pk2, po)
            ^[Pm2]^[P2]^[Kl2]^[Zap2],
	  fps(St2, Kl2, Neg, Dest2, I2, Pk2, po)
            ^[St2]^[Kl2],
	  modpart(fpt, Neg, Dest2, I2, Pk2, po) 
                     ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[oblink_iter, I1, I2, IL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL]
	),
	fps(St, Kl, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod,
 	  obldest_iter(DestL, Dest3, DestP),
	  oblink_iter(IL,I3,IP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([
          fpm(Pm4, P4, Kl4, Zap4, Neg, Dest4, I4, Pk4, po)
            ^[Pm4]^[P4]^[Kl4]^[Zap4],
	  fps(St4, Kl4, Neg, Dest4, I4, Pk4, po)
            ^[St4]^[Kl4],
	  modpart(fpt, Neg, Dest4, I4, Pk4, po) 
                     ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[oblink_iter, IP, I4, I]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).

fps(St, mod, Neg, Dest, I, Pk, Sub) -->
	s(psm3),
	modpart(fpt, Neg, Dest1, I1, Pk1, po),
	sequence_of([
          fpm(Pm2, P2, Kl2, Zap2, Neg, Dest2, I2, Pk2, po)
            ^[Pm2]^[P2]^[Kl2]^[Zap2],
	  fps(St2, Kl2, Neg, Dest2, I2, Pk2, po)
            ^[St2]^[Kl2],
	  modpart(fpt, Neg, Dest2, I2, Pk2, po) 
                     ]
                     ^[obldest_iter, Dest1, Dest2, DestL]
		     ^[oblink_iter, I1, I2, IL]
		     ^[sprawdz_pk_iter, Pk1, Pk2, PkL]
	),
	fps(St, Kl, Neg, Dest3, I3, Pk3, na),
	{ Kl \= mod,
 	  obldest_iter(DestL, Dest3, DestP),
	  oblink_iter(IL,I3,IP),
	  sprawdz_pk_iter(PkL, Pk3, PkP) },
	sequence_of([
          fpm(Pm4, P4, Kl4, Zap4, Neg, Dest4, I4, Pk4, po)
            ^[Pm4]^[P4]^[Kl4]^[Zap4],
	  fps(St4, Kl4, Neg, Dest4, I4, Pk4, po)
            ^[St4]^[Kl4],
	  modpart(fpt, Neg, Dest4, I4, Pk4, po) 
                     ]
                     ^[obldest_iter, DestP, Dest4, Dest]
		     ^[oblink_iter, IP, I4, I]
		     ^[sprawdz_pk_iter, PkP, Pk4, Pk]
	).
%%%% To ‹za | dobrze | dla Piotra›.
%%%% To ‹nie za | dobrze | dla Piotra›.

% \subsection{Realizacje szeregowe}

% fps (, fps)* sp fps
fps(St, sp:sz:Oz, Neg, Dest, I, Pk, Sub) -->
	s(pss3),
	fps(St, Kl1, Neg, Dest1, I, Pk1, po),
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fps(St3, Kl3, Neg, Dest3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [Pk5,Pk6]]
	     ^[obldest_fno_iter, Dest1, Dest3, DestPostSeq]
	     ^[jeden_na_listę, KlL, Kl3, [Kl6]]
	     ^[St3]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz = przec -> Pk5 = (p|wp) ; Pk5 = (0|0) },
	{ sprawdz_neg(Oz,Neg) },
	fps(St6, Kl6, Neg, Dest6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]),
	  obldest_fno_iter(DestPostSeq,Dest6,Dest),
	  różne(sp:sz:Oz, [Kl1 | KlL]),
	  % Dodatkowo w tym układzie szereg przecinkowy nie może być
	  % składnikiem:
	  różne( sp:sz:przec, [Kl1 | KlL]),
	  % a także ostatni składnik szeregu przecinkowego nie może
	  % być szeregiem:
	  ( Oz \= przec ; Kl6 \= sp:sz:_)
	  }.
%%%% Jego następca musiałby ‹długo | i | pracowicie› budować swoją wiarygodność.
%%%% ‹Długo|, | stopniowo|, | pomału› zdobywał ich zaufanie.
%%%% Wierzył tylko w to, co daje się ‹ściśle|, | matematycznie› udowodnić.


% \subsection{Fraza przysłówkowa nietypowa}

% W cudzysłowie:
fps(St, Kl, Neg, Dest, I, Pk, Sub) -->
	s(psc2),
	cudz(o,po),
	fps(St, Kl, Neg, Dest, I, Pk, na),
	cudz(z,po).



%  \section{FRAZA ZDANIOWA}

% \subsection{Realizacja względna i pytajnozależna}

% Warianty reguł na frazę zdaniową uwzględniają obecność lub brak
% przecinków.  W pierwszym oba przecinki są obecne, więc obliczenie
% przecinkowości odbywa się normalnie.

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zd1),
	przec(Pk1,po),
	zdanie(Wf, A, C, T, Rl, O, Neg, Tfz, I, Pk2, na),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ Wf \= bc(_),
	  równe(Tfz,[wz(_,_),pz]),
	  oblpk(Pk, [Pk1,Pk2,Pk3]) }.

% W drugim wariancie, bez przecinka początkowego, za pomocą warunku
% oblpk wysyłamy na zewnątrz frazy początkową wartość −, natomiast
% wewnętrzne zdanie konfrontujemy z wartością +, żeby uniemożliwić w
% nim przecinek inicjalny:

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zd2),
	zdanie(Wf, A, C, T, Rl, O, Neg, Tfz, I, Pk2, na),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ Wf \= bc(_),
	  równe(Tfz,[wz(_,_),pz]),
	  oblpk(Pk, [(bp|p), Pk2, Pk3]) }.

% \subsection{Realizacje spójnikowe}

% do sprawdzenia: Pk spójnika?  Czy może być przecinek bezpośrednio po
% spójniku? Teraz zablokowany.
% Jaka wartość Dest w zdaniu?  Jakie ograniczenia?
% Co z inkorporacją?
% Co ma być centrum???

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zds1),
	przec(Pk1,po),
	spójnik(po,Tfz,I,na),
	zdanie(Wf, A, C, T, Rl, O, Neg, neut, ni, Pk2, po),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ Wf \= bc(_),
	  member(Tfz, [aż,chociaż,czy,dopóki,gdy,
	               jak,jeśli,podczas,ponieważ,zanim,że]),
	  oblpk(Pk, [Pk1,Pk2,Pk3]) },
	{ Wf = bok *-> member(Tfz, [gdy,jeśli]) ; true }.

% Warunek na osobę w tej regule ma zabezpieczać przed frazami typu
% „gdyby wiedziałeś”.  Sprawdzanie następuje tylko dla zdań „osobowych”,
% żeby konstrukcje typu „gdyby czytać” nie dostawały wartości osoby=3.

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zds2),
	przec(Pk1,po),
	spójnik(po,Tfz,I,na),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest, ni, Pk2, po),
	{ Wf=os *-> member(O/Dest, [3/neut,_/agl]) ; Wf \= bc(_) },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ member(Tfz, [choćby,gdyby,jakby,jakoby,żeby]),
	  oblpk(Pk, [Pk1,Pk2,Pk3]) }.

%%%% Czytałybyście‹, | gdybym | wiedział›.
%%%* Czytałybyście‹, gdyby wiedziałeś›.
%%%% Czytałybyście‹, żeby wiedzieć›.

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zds1o),
	spójnik(po,Tfz,I,na),
	zdanie(Wf, A, C, T, Rl, O, Neg, neut, ni, Pk2, po),
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ Wf \= bc(_),
	  member(Tfz, [aż,chociaż,czy,dopóki,gdy,
	               jak,jeśli,podczas,ponieważ,zanim,że]),
	  oblpk(Pk, [(bp|p),Pk2,Pk3]) },
	{ Wf = bok *-> member(Tfz, [gdy,jeśli]) ; true }.

fzd(Tfz, nk, A, C, T, Neg, I, Pk, _Sub) -->
	s(zds2o),
	spójnik(po,Tfz,I,na),
	zdanie(Wf, A, C, T, Rl, O, Neg, Dest, ni, Pk2, po),
	{ Wf=os *-> member(O/Dest, [3/neut,_/agl]) ; Wf \= bc(_) },
	optional(przec(Pk3,po),{},{Pk3=(p|bp)}),
	{ member(Tfz, [choćby,gdyby,jakby,jakoby,żeby]),
	  oblpk(Pk, [(bp|p),Pk2,Pk3]) }.

% \subsection{realizacja z korelatem}

fzd(Tfz, K, A, C, T, Neg, I, Pk, _Sub) -->
	s(zdk1), 
	korelat(K, I, po), 
%	przec(Pk2,po),
	fzd(Tfz, nk, A, C, T, Neg, ni, Pk3, na),
	{ oblpk(Pk, [(0|0),Pk3]) }.

% \subsection{Realizacje równorzędne dwumiejscowe}

fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub) -->
	s(zdr1),
	fzd(Tfz, K, A, C, T, Neg, I, Pk1, po),
	przec(_,po),
	spójnik(rc,Oz,ni,na),
	fzd(Tfz, K, A3, C3, T3, Neg3, ni, Pk3, po),
	{ oblpk(Pk,[Pk1,(p|wp),Pk3]) }.

%%%% Wiem‹, że czyta, a nawet że pisze›.
%%%% Nie chodzi ‹o to, że sypiał z nią, lecz o to, że kłamał›.
%%%% Czekam‹, ponieważ poprosił, ale i ponieważ chcę›.

fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub) -->
	s(zdr2),
	spójnik(rl,Oz,I,na),
	fzd(Tfz, K, A, C, T, Neg, I, Pk1, po),
	{ Tfz \= wz(_,_) },
	przec(_,po),
	spójnik(rp,Oz,ni,po),
	fzd(Tfz, K, A3, C3, T3, Neg3, ni, Pk3, po),
	{ oblpk(Pk,[Pk2,(p|wp),Pk3]) }.

%%%% Czytałybyście ‹zarówno gdyby wiedział, jak też gdyby nie wiedział›.

% \subsubsection{Realizacje równorzędne szeregowe}

% sp fzd (, sp fzd)* , sp fzd
fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub) -->
	s(zdsz1),
	spójnik(sz,Oz,ni,po),
	{ \+ member(Oz, [przec,lub]) },
	fzd(Tfz, K, A, C, T, Neg, I, Pk1, po),
	{ Tfz \= wz(_,_) },
	sequence_of([
            [ przec(Pk2,po),
	      spójnik(sz,Oz,ni,po),
	      fzd(Tfz, K, A3, C3, T3, Neg3, ni, Pk3, po)
	    ]^[trzy_na_listę, PkL, [Pk2,(0|wp),Pk3], [Pk4,(0|wp),Pk6]]
	     ^[zroblistę_iter, [Neg], Neg3, NegSeq]
	     ^[A3]^[C3]^[T3]
	]),
	przec(Pk4,po),
	spójnik(szk,Oz,ni,na),
	{ sprawdz_neg_fzd(Oz, [Neg6 | NegSeq]) },
	fzd(Tfz, K, A6, C6, T6, Neg6, ni, Pk6, po),
	{ oblpk(Pk,[(0|wp), Pk1 | PkL]) }.

%%%% Wiem i że był, i że będzie.
%%%% Wiem i skąd przyszedł, i dokąd poszedł, i kiedy będzie.
%%%* Przyszedł chłopiec ‹i którego znam, i którego poważam›.
%%%% Chodzi‹ i o to, że pisał, i o to, że czytał, i o to, że mówił›.

% fzd (sp fzd ,)+ sp fzd
% + a nie *, bo schemat bez powtarzanego elementu załatwi s3
fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub) -->
	s(zdsz2),
	fzd(Tfz, K, A, C, T, Neg, I, Pk1, po),
	sequence_of([
            [ spójnik(sz,Oz,ni,po),
	      fzd(Tfz, K, A3, C3, T3, Neg3, ni, Pk3, po),
	      przec(Pk4,po)
	    ]^[trzy_na_listę, PkL1, [(p|wp),Pk3,(p|0)], [(0|wp),Pk6]]
	     ^[zroblistę_iter, [Neg], Neg3, NegSeq]
	     ^[A3]^[C3]^[T3]
	     ^[conajmniej1, 0, _, 1]
	]),
	spójnik(szk,Oz,ni,na),
	{ Oz \= przec },
	{ sprawdz_neg_fzd(Oz, [Neg6 | NegSeq]) },
	fzd(Tfz, K, A6, C6, T6, Neg6, ni, Pk6, po),
	{ K = nk -> PkL = PkL1 ; PkL1 = [(p|wp)|PkL2], PkL=[(wb|wp)|PkL2] },
	{ oblpk(Pk,[Pk1 | PkL]) }.

%%%% Wiem‹, że był umęczon i że umarł, i że został pogrzebion›.
%%%* Wiem, że pisał, i że czytał, i że mówił.
%%%* Wiem, że pisał i, że czytał, i że mówił.
%%%* Wiem, że pisał i że czytał, i, że mówił.
%%%% Chodzi‹ o to, że pisał, i o to, że czytał, i o to, że mówił›.

% fzd (, fzd)* sp fzd
fzd(Tfz, K, A, C, T, Neg, I, Pk, Sub) -->
	s(zdsz3),
	fzd(Tfz, K, A, C, T, Neg, I, Pk1, po),
	{ K = nk -> Pk5 = p ; Pk5 = wb },
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      fzd(Tfz, K, A3, C3, T3, Neg3, ni, Pk3, po)
	    ]^[dwa_na_listę, PkL, [(p|wp),Pk3], [(Pk5|wp),Pk6]]
	     ^[zroblistę_iter, [Neg], Neg3, NegSeq]
	     ^[A3]^[C3]^[T3]
	]),
	spójnik(szk,Oz,ni,na),
	{ sprawdz_neg_fzd(Oz, [Neg6 | NegSeq]) },
	fzd(Tfz, K, A6, C6, T6, Neg6, ni, Pk6, po),
	{ oblpk(Pk,[Pk1 | PkL]) }.

%%%% Wiem‹, że umarł i że zostanie pogrzebany›.
%%%% Chodzi ‹o to, że czyta, i o to, że nie mówi Markowi›.
%%%% Wiem‹, że czyta i że mówi›.
%%%% Wiem‹, kto przyszedł i co zrobił›.
%%%% Przyszedł chłopiec‹, którego znam i którego poważam›.
%%%* Przyszedł chłopiec‹, którego znam i którą poważam›.
%%%% Przyszedł chłopiec‹, którego znam, którego lubię i którego poważam›.
%%%% Wiem‹, że nie umarł ani że nie usechł›.
%%%* Wiem‹, że umarł ani że nie usechł›.
%%%* Wiem‹, że nie umarł ani że usechł›.
%%%% Wiem‹, że  nie umarł, że nie był umęczon ani że nie  został pogrzebion›.
%%%% Czytałybyście‹, gdyby padało lub gdybym rozkazał›.

% \section{Nietypowe jednostki poziomu pośredniego}

% Nie są to jednostki elementarne/słowa składniowe, bo wpuszczamy je
% bezpośrednio jako podrzędniki fraz.  Jednocześnie nie są to frazy —
% nie mogą mieć podrzędników.

% \subsection{Modyfikator jakiczny}
%
% Nietypowy przymiotnikowy podrzędnik przymiotnika.

modjaki(P, Rl, Zap, Dest, I, (0|0), Sub) -->
	s(mj1),
	zaimprzym(H, P, Rl, na),
	{ member(H/Zap/Dest, [taki/tk/neut,
	    jaki/bzap/pyt, jaki/bzap/pz, jaki/bzap/wz(jaki,Rl),
	    jakiś/bzap/neut]) },
	optional(spójnik(i(IT,IO), _Tsp, ni, po),{I=i(IT,IO)},{I=ni}).

%%%% Był ‹jakiś› dziwny.
%%%% Okazał się skory ‹jakiś› do gniewu.

% \subsection{Partykuły modyfikujące}
%
% Zdefiniowana tu jednostka \jedn{modpart} obejmuje partykuły mogące
% modyfikować frazy określonych typów: czasownikowe (przez wejście
% jako fl do struktury zdania albo do struktury niefinitywnej frazy
% werbalnej), nominalne, przymiotnikowe i przysłówkowe,
% przyimkowo\dywiz nominalne.  Jest to jednostka poziomu słów
% składniowych, nie może ona mieć podrzędników.  Jej parametry
% obejmują predestynację (niektóre partykuły są pytajne) oraz klasę,
% określającą, które typy fraz może modyfikować dana partykuła.  Na
% wszelki wypadek wprowadzam też parametr negacji — może znajdziemy
% jakieś partykuły immanentnie negatywne.
%
% Wartości klasy:
% fin — określająca frazę finitywną,
% nfin — określająca niefinitywną frazę werbalną,
% fno — określająca frazę nominalną,
% flicz — określająca frazę liczebnikową,
% fpt — określająca frazy przymiotnikowe i przysłówkowe,
% fpm — określająca frazę przyimkowo\dywiz nominalną.

% Postanowienie na czas projektu: nie damy rady wewnątrz fl odróżnić
% finitywnego i niefinitywnego kontekstu jej użycia — trzeba by dodać
% parametr.  Więc puszczamy sprawę partykuł modyfikujących fwe tylko
% finitywne («czy», «azali», …) — parser zaakceptuje zdanie „Chce
% ‹książki czy czytać›?”.

modpart(Kl, _Neg, neut, ni, (0|0), Sub) -->
	s(mp1),
	[morf(_,H,qub)],
	{ slowpart(H, Klasy), member(Kl, Klasy) }.

modpart(fin, _Neg, Dest, ni, (0|0), Sub) -->
	s(mp2),
	[morf(_,H,qub)],
	{ member(Dest, [pyt,pz]),
	  member(H, [czy, czyż, czyżby, azali, azaliż, li]) }.

modpart(Kl, _Neg, neut, ni, (0|0), Sub) -->
	s(mp3),
	[morf(_,H,brev:Pun)],
	{ slowskr(H,_Skr,Pun, Kon, qub),
	  slowpart(H, Klasy), member(Kl, Klasy)
	},
	  optional(terminal(morf('.',_,interp)),{Kon\=kon},{Kon\=nkon}).

%%%% ‹Czy› on czyta?
%%%% Czytali ‹azali› książki?

modpart(Kl, _Neg, neut, ni, (0|0), Sub) -->
	s(mp5),
	[morf(_,co,prep:Cases)],
	{ przypadki(Cases,bier) },
	[morf(_,H,adv:sup)],
	{ member(H, [wysoko, mało]),
	  member(Kl, [fno,flicz,fpm,fin]) }.

%%%% Znają ‹co najwyżej› encyklopedię.
%%%% ‹Co najmniej› przeczyta, a może skomentuje.


% MW: Czy to dobre?:
modpart(Kl, _Neg, neut, ni, (0|0), Sub) -->
	s(mp6),
	[morf(_,co,prep:Cases)],
	{ przypadki(Cases,bier) },
	[morf(_,H,adv:com)],
	{ member(H, [dużo]),
	  member(Kl, [fin]) }.

%%%% ‹Co więcej›, on przyszedł. 

% Nieliczne partykuły lubią „nie” przed sobą:
modpart(Kl, _Neg, neut, ni, (0|0), Sub) -->
	s(mp7),
	[morf(_,nie,qub)],
	[morf(_,H,qub)],
	{ member(H,[byle,całkiem,dosyć,dość,nazbyt,tylko,wprost,za]),
	slowpart(H, Klasy), member(Kl, Klasy) }.

%%%% To ‹nie | za› lekkie?
%%%% ‹Nie tylko› on to słyszał.

modpart(flicz, _Neg, neut, ni, (0|0), Sub) -->
	s(mp8),
	[morf(_,H,adv:pos)],
	{ member(H, [znacznie,dużo]) }.
%%%% Dzięki nowemu oddziałowi szpital będzie mógł uratować ‹znacznie› więcej dzieci chorych na białaczkę.
%%%% Czytałem ‹dużo› więcej powieści.

modpart(fno, _Neg, neut, ni, (0|0), Sub) -->
	s(mp9),
	[morf(_,H,adv)],
	{ member(H, [donikąd]) }.
%%%% Brygida nazywała to ‹drogą donikąd›.


% Realizacja inkorporacyjna:

modpart(Kl, Neg, Dest, i(IT,IO), Pk, Sub) -->
	s(mp4),
	modpart(Kl, Neg, Dest, ni, Pk, na),
	spójnik(i(IT,IO), _Tsp, ni, po).

%  \section{Jednostki elementarne}

formarzecz( P, R/L, WymN, Sub )    --> s(n_rz1), 
	[morf(_,H,subst:Num:Cases:Gend)], 
	{ liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R),
	rekcja_nominalna(H,WymN)  }.

formarzecz( P, R/L, WymN, Sub )    --> s(n_rz2), 
	[morf(_,H,depr:Num:Cases:Gend)], 
	{ liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R),
	rekcja_nominalna(H,WymN) }.

formarzecz( P, R/L, WymN, Sub )    --> s(n_rz3), 
	[morf(_,H,ger:Num:Cases:Gend:_:_)], 
	{ liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R),
	rekcja_gerundialna(H,WymN) }.

formarzecz( P, _R/_L, Wym, _Sub )    --> s(n_rz4), 
	[morf(_,_,siebie:Cases)], 
	{ przypadki(Cases,P) },
	{ rekcja_pusta(Wym) }.

% Intencją tej reguły jest opisanie nazwisk dwuczłonowych.
% Uwzględniamy tylko dla dwa subst, bo chyba nie ma wiele sensu w
% dopuszczeniu depr i ger, a wyraźnie nie chcemy siebie ani zaimków
% osobowych.

formarzecz( P, R/L, WymN, Sub )    --> s(n_rz5), 
	[morf(_,H,subst:Num:Cases:Gend)], 
	{ liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R),
	rekcja_nominalna(H,WymN)  },
	[morf('-','-',interp)],
	[morf(_,_H,subst:Num1:Cases1:Gend1)], 
	{ liczba(Num1,L), przypadki(Cases1,P), rodzaj(Gend1,R1), R=R1 }.

%%%% Na papieża rzucił się z nożem Juan ‹Fernandez-Krohn›.

% Następna reguła opisuje skróty rzeczownikowe.  Niektóre z nich
% miewają podrzędniki (np. „woj. ciechanowskie”).

formarzecz( P, R/L, WymN, Sub )    --> s(n_rz6), 
	[morf(_,H,brev:Pun)],
	{ slowskr(H,_Skr,Pun, Kon, subst:Num:Cases:Gend), 
	  liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R),
	  rekcja_nominalna(H,WymN)  },
	  optional(terminal(morf('.',_,interp)),{Kon\=kon},{Kon\=nkon}).

% Ta reguła opisuje szczególne skróty rzeczownikowe — inicjały
% (zastępujące imię lub nazwisko):
formarzecz( P, _R/poj, Wym, Sub )    --> s(n_rz7),
	[morf(Skr,H,brev:Pun)],
	{ slowskr(H,Skr,Pun, Kon, ini),
	  member(P,[mian,dop,cel,bier,narz,miej])  },
	  optional(terminal(morf('.',_,interp)),{Kon\=kon},{Kon\=nkon}),
	{ rekcja_zablokowana(Wym) }.

% Zaimki osobowe:

zaimos( P, R/L, O, Sub ) --> 
	s(n_zo1),
	[morf(_,_,ppron12:Num:Cases:Gend:Per)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), osoba(Per,O) }.

zaimos( P, R/L, O, Sub ) -->
	s(n_zo2),
	[morf(_,_,ppron12:Num:Cases:Gend:Per:_)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), osoba(Per,O) }.

zaimos( P, R/L, O, Sub ) -->
	s(n_zo3),
	[morf(_,_,ppron3:Num:Cases:Gend:Per:_)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), osoba(Per,O) }.


%%%%%%%%%%%%%%%%%%%% Funkcyjne: %%%%%%%%%%%%%%%%%%%%

% 5.16. Jednostki funkcyjne

spójnik(Tsp, Oz, i(TI,OI), _Sub) -->
	s(si),
	spójnik(Tsp, Oz, ni, na),
	spójnik(i(TI,OI), _Oz2, ni, po).

%%%% Pisałem, ‹ponieważ zaś› czytał, umarł.
%%%% Pisałem, ‹ponieważ więc› czytał, umarł.
%%%% Czekałem, ‹nie tylko więc› czytał, ale i pisał.

spójnik(rl, F, ni, _Sub) --> 
	s(sr1), 
	[morf(_,F,conj)], 
        { równe(F, ['nie','tak','zarówno'])}.

spójnik(rl, nietylko, ni, _Sub) --> 
	s(sr2),
	[morf(_,nie,conj)], 
	[morf(_,tylko,conj)].

spójnik(rp, nie, ni, _Sub) --> 
	s(sr3),
	[morf(_,F,conj)], 
        { równe(F, ['ale','lecz'])}.

spójnik(rp, nietylko, ni, _Sub) --> 
	s(sr4),
	[morf(_,F,conj)], 
        { równe(F, ['ale','lecz']) }, 
	[morf(_,F1,qub)], 
        { równe(F1, ['i','również','także'])}.

spójnik(rp, F, ni, _Sub) --> 
	s(sr5),
	[morf(_,jak,conj)], 
        { równe(F, ['tak','zarówno'])}.

spójnik(rp, F, ni, _Sub) --> 
	s(sr6),
	[morf(_,jak,conj)], 
	[morf(_,F1,qub)], 
        { równe(F, ['tak','zarówno']), 
        równe(F1, ['i','też'])}.

spójnik(rc, a, ni, _Sub) --> 
	s(sr10),
	[morf(_,F,conj)], 
        { równe(F, [a,ale,lecz])}.

spójnik(rc, alei, ni, _Sub) --> 
	s(sr11),
	[morf(_,F,conj)], 
        { równe(F, [a,ale,lecz]) },
	[morf(_,F1,qub)], 
        { równe(F1, [i,nawet,również,także])}.

spójnik(rc, natomiast, ni, _Sub) --> 
	s(sr12),
	[morf(_,natomiast,conj)].

spójnik(rc, nie, ni, _Sub) --> 
	s(sr13),
	[morf(_,F,conj)], 
        { równe(F, [a,ale])},
	[morf(_,nie,qub)].

spójnik(rc, nie, ni, _Sub) --> 
	s(sr14),
	[morf(_,nie,qub)], 
        [morf(_,'zaś',conj)].

spójnik(rc, F, ni, _Sub) --> 
	s(sr50),
	[morf(_,F,conj)],
	{ member(F, [czyli,mianowicie]) }.

spójnik(rc, mianowicie, ni, _Sub) --> 
	s(sr51), 
	[morf(_,a,conj)],
	[morf(_,mianowicie,conj)].

spójnik(rc, raczej, ni, _Sub) --> 
	s(sr52),
	[morf(_,a,conj)],
	[morf(_,raczej,qub)].


%%%% Przyszedł, ‹czyli› zależało mu.
%%%% Zmienił się skład, ‹czyli› struktura.
%%%% Skład, ‹czyli› struktura zmieniła się.
%%%% Skład, ‹czyli› struktura, zmienił się.

spójnik(i(r,F), F, ni, _Sub) --> 
	s(sr20),
	[morf(_,F,conj)], 
        { równe(F, ['natomiast','zaś'])}.

spójnik(Tsp, F, ni, _Sub) --> 
	s(sr21),
	[morf(_,F,conj)], 
        { równe(F, ['albo','bądź','i','lub']),
	  równe(Tsp, ['sz','szk']) }.

spójnik(Tsp, ani, ni, _Sub) --> 
	s(sr22),
	[morf(_,F,conj)], 
        { równe(Tsp, [sz,szk]), 
          równe(F, [ani,ni])}.

spójnik(Tsp, przec, ni, _Sub) --> 
	s(sr23),
	[morf(_,H,interp)],
	{ member(H,[',',';']),
	 równe(Tsp, [sz,szk]) }.

spójnik(szk, F, ni, _Sub) --> 
	s(sr24),
	[morf(_,F,conj)], 
        { równe(F, [albo,bądź,lub]) },
	[morf(_,F1,qub)], 
        { równe(F1, [nawet,też])}.

spójnik(szk, ani, ni, _Sub) --> 
	s(sr25),
	[morf(_,F,conj)], 
        { równe(F, [ani,ni]) },
	[morf(_,F1,qub)], 
        { równe(F1, [nawet,też]) }.

spójnik(szk, i, ni, _Sub) --> 
	s(sr26),
	[morf(_,i,conj)], 
	[morf(_,F1,qub)], 
        { równe(F1, [nawet,także]) }.

spójnik(szk, i, ni, _Sub) --> 
	s(sr27),
	[morf(_,oraz,conj)].

% Spójnik «czy» jest tylko frazowy.  Byłoby to lepiej załatwić
% klasyfikacją, ale żeby nie zmieniać, blokujemy w regułach
% zdaniowych.
spójnik(szk, czy, ni, _Sub) --> 
	s(sr49),
	[morf(_,czy,conj)].
%%%% Dziewczęta z ludu, panny służące czy szwaczki były po innej cenie.

spójnik(szk, czy, ni, _Sub) --> 
	s(sr53),
	[morf(_,czy,conj)],
	[morf(_,też,qub)].
%%%% Sztuczne tworzenie organizmów mozaikowych ‹czy też› wprowadzenie zmienionych genów do komórek bez wątpienia przyczynia się do postępu nauki, ale nie znajduje odbicia w zjawiskach występujących w naturze.


spójnik(Tsp, dopóki, ni, _Sub) --> 
	s(spoj22), 
	[morf(_,F,conj)], 
        { równe(Tsp, [pl,pp]), 
          równe(F, [dopóty,póty])}.

spójnik(Tsp, gdy, ni, _Sub) --> 
	s(spoj23),
	[morf(_,F,adv)],  % to przysłówki!!!?
        { równe(Tsp, [pl,pp]), 
          równe(F, [wówczas,wtedy])}.

spójnik(pp, Oz, ni, _Sub) --> 
        s(spoj24),
	[morf(_,jednak,conj)],
        { równe(Oz, [chociaż,choćby])}.

spójnik(pp, Oz, ni, _Sub) --> 
        s(spoj25),
	[morf(_,to,conj)], 
        [morf(_,jednak,conj)],
        { równe(Oz, [chociaż,choćby])}.

spójnik(pp, Oz, ni, _Sub) --> 
        s(spoj26),
	[morf(_,to,conj)], 
        { równe(Oz, [chociaż,choćby,gdyby,jeśli])}.

spójnik(pc, bo, ni, _Sub) --> 
	s(spoj27), 
	[morf(_,F,comp)], 
        { równe(F, [albowiem,bo,gdyż]) }.

spójnik(Tsp, więc, ni, _Sub) --> 
	s(spoj28), [morf(_,F,conj)], 
        { równe(Tsp, [pc,i(p,więc)]), 
          równe(F, [przeto,więc,zatem])}.

spójnik(pc, więc, ni, _Sub) --> 
	s(spoj29), 
	[morf(_,toteż,conj)].

spójnik(pc, to, ni, _Sub) --> 
	s(spoj50), 
	[morf(_,to,conj)].

%%%% Chcesz, ‹to› masz.
%%%% ‹To› macie dużo szczęścia.

spójnik(rc, więc, ni, _Sub) --> 
	s(spoj48), 
	[morf(_,a,conj)],
	[morf(_,F,conj)],
	{ równe(F, [przeto,więc,zatem]) }.

spójnik(rc, więc, ni, _Sub) --> 
	s(spoj48), 
	[morf(_,H,conj)],
	{ member(H, [względnie,tymczasem]) }.

%%%% Różni się w zakresie funkcji poznawczych, względnie myślowych.
%%%% Może być odwołany, względnie ustąpić.

spójnik(i(p,bowiem), bowiem, ni, _Sub) --> 
	s(spoj30),
	[morf(_,bowiem,comp)].

spójnik(po, aż, ni, _Sub)          --> s(spoj31), [morf(_,'aż',comp)].
spójnik(po, Oz, ni, _Sub)         
                        --> s(spoj32), [morf(_,Oz,comp)], 
                          { równe(Oz, ['czy','jak','jakby','jakoby'])}.

spójnik(po, chociaż, ni, _Sub)     --> s(spoj33), [morf(_,F,comp)], 
                          { równe(F, ['chociaż','choć'])}.
spójnik(po, chociaż, ni, _Sub)    
                        --> s(spoj34), przyimek(mimo, dop, na), 
                          [morf(_,'że',comp)].

spójnik(po, choćby, ni, _Sub) -->
	s(spoj35), [morf(_,F,comp)], 
                          { równe(F, ['chociażby','choćby'])}.

spójnik(po, dopóki, ni, _Sub) -->
	s(spoj36), [morf(_,F,comp)], 
                          { równe(F, ['dopóki','póki'])}.

spójnik(po, gdy, ni, _Sub) -->
	s(spoj37), [morf(_,F,comp)], 
                          { równe(F, ['gdy','kiedy'])}.

spójnik(po, gdyby, ni, _Sub)       --> s(spoj38), [morf(_,F,comp)], 
                          { równe(F, ['gdyby','jeśliby','jeżeliby'])}.

spójnik(po, jeśli, ni, _Sub) -->
	s(spoj39), [morf(_,F,comp)], 
        { równe(F, ['jeśli','jeżeli'])}.

spójnik(po, podczas, ni, _Sub) -->
	s(spoj40), przyimek(podczas, dop, na), 
                          [morf(_,gdy,comp)].

spójnik(po, ponieważ, ni, _Sub) -->
	s(spoj41), 
	[morf(_,F,comp)], 
	{ równe(F, [ponieważ,skoro])}.
% Było tak: na okoliczność
%„Że zamknięty w skorupie niewygodnie siedział żałowała mysz żółwia.”
%	{ równe(F, ['ponieważ','skoro','że'])}.

spójnik(po, zanim, ni, _Sub) -->
	s(spoj42), [morf(_,F,comp)], 
        { równe(F, ['nim','zanim'])}.

spójnik(po, że, ni, _Sub) -->
	s(spoj43), 
	[morf(_,F,comp)], 
        { równe(F, ['iż','że'])}.

spójnik(po, żeby, ni, _Sub) -->
	s(spoj44), [morf(_,F,comp)], 
        { równe(F, ['aby','ażeby','by','iżby','żeby'])}.

% 5.16.2: Zaimek
% te reguły do ubicia, jak się pojawią frazy przymiotnikowe i przysłówkowe

zaimwzg(przym, P, Rl, _O, _Kl)
     --> s(zaim44n), zaimprzym(jaki, P, Rl).

% nowe reguły zaimkowe:

% 5.16.2.3. Zaimki nieokreślone 
%  5.16.2.3.1. zaimki rzeczowne


zaimno(rzecz, P, r(R1,nmo(R2))/L, _O, co)
--> s(zaim73), 
	zaimprzym(ten, P, r(R1,nmo(R2))/L).

zaimno(rzecz, P, r(mn(m(zy)),mo)/poj, _O, kto)
--> s(zaim73k), 
	zaimprzym(ten, P, r(mn(m(zy)),mo)/poj).

zaimno(przym, P, Rl, _O, _Kl)
--> s(zaim73x),
	zaimprzym(ten, P, Rl).

% [MŚ: można dodać jeszcze tamten, ów]


zaimrzecz(H, P, R/L, Sub) -->
	s(jel5),
	[morf(_,H,psubst:Num:Cases:Gend)], 
	{ liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R) }.

zaimprzym(H, P, R/L, Sub) -->
	s(jel6),
	[morf(_,H,padj:Num:Cases:Gend:pos)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R) }.

formaprzym( P, R/L, St, WymA, Sub ) -->
	s(n_pt1),
	[morf(_,H,adj:Num:Cases:Gend:Degr)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), stopien(Degr,St),
	  rekcja_przymiotnikowa(H,WymA) }.

formaprzym( P, R/L, St, WymA, Sub ) -->
	s(n_pt2),
	[morf(_,_,adja)],
	[morf('-','-',interp)],
	formaprzym( P, R/L, St, WymA, na).

% formy poprzyimkowe przymiotników:
%
% To jest reguła napisana pod ręczne NKJP, gdzie „staremu” dostanie
% adjp, jeśli stoi po „po”; a nawet „dawna” dostanie adjp, jeśli stoi
% po „od”!  Kiedyś to chyba zmienimy.
formaprzym( pop, R/L, row, Wym, Sub ) -->
	s(n_pt7),
	[morf(_,_,adjp)],
	{ rekcja_zablokowana(Wym) }.

formaprzym( P, R/L, row, WymA, Sub ) -->
	s(n_pt3),
	[morf(_,H,ppas:Num:Cases:Gend:_)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R),
	  rekcja_ppas(H,WymA) }.

formaprzym( P, R/L, row, WymA, Sub ) -->
	s(n_pt4),
	[morf(_,H,pact:Num:Cases:Gend:_)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R),
	  rekcja_pact(H,WymA) }.

formaprzym( mian, R/poj, row, WymA, Sub ) -->
	s(n_pt5),
	[morf(_,H,adjc)],
	{ rodzaj(m1.m2.m3,R),
	  rekcja_przymiotnikowa(H,WymA) }.


% Liczebnik porządkowy zapisany cyframi z kropką:
% (reguła pod anotację NKJP, Morfeusz na razie nie generuje takiej interpretacji)

same_cyfry(F) :- atom_codes(F,CC), \+ (member(C,CC), \+ (C>=0'0, C=<0'9)).

formaprzym( P, R/L, St, WymA, Sub ) -->
	s(n_pt6),
	[morf(F,H,adj:Num:Cases:Gend:Degr)],
	[morf('.',_,interp)],
	{ same_cyfry(F),
	 liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), stopien(Degr,St),
	  rekcja_przymiotnikowa(H,WymA) }.

% Godzina i minuty zapisana cyframi:
%
% Interpretujemy jako przymiotnik, bo zwykle jest „godz. 16.30”, a jak
% będzie „o 5.40” to się fpt przepisze na fno.
formaprzym( P, R/L, St, WymA, Sub ) -->
	s(n_pt8),
	[morf(F,H,adj:Num:Cases:Gend:Degr)],
	[morf(I,_,interp)],
	{ member(I, ['.',':']) }, % niestety obecnie króluje zapis anglosaski „16:30”
	[morf(F2,_,num:pl:nom:f:_)],
	{ same_cyfry(F), same_cyfry(F2),
	 liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), stopien(Degr,St),
	  rekcja_przymiotnikowa(H,WymA) }.

% skróty przymiotnikowe
formaprzym( P, R/L, St, WymA, Sub ) --> s(n_pt9), 
	[morf(_,H,brev:Pun)],
	{ slowskr(H,_Skr,Pun, Kon, adj:Num:Cases:Gend:Degr),
	  liczba(Num,L), przypadki(Cases,P), rodzaj(Gend,R), stopien(Degr,St),
	  rekcja_przymiotnikowa(H,WymA)  },
	  optional(terminal(morf('.',_,interp)),{Kon\=kon},{Kon\=nkon}).
%%%% Starogard Gd.


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Formy liczebnikowe:

formalicz(P, R/L, Akom, Klasa, Sub) -->
	s(n_li),
	[morf(_,H,num:Num:Cases:Gend:Acom)],
	{ liczba(Num,L), przypadki(Cases,P),
	  rodzaj(Gend,R), akomodacyjnosc(Acom,Akom),
	  klasa_licz(H,Klasa) }.

klasa_licz(ile, pyt) :- !. %LdX11
%pół	La1	
%ćwierć	La1	
%półtora	Lb1	
%zero	La2	
%
% bilion	La21	
% miliard	La21	
% milion	La21	
% tysiąc	La21	
%
klasa_licz(jeden,t(1)) :- !.
klasa_licz(dwa,t(j)) :- !.
klasa_licz(trzy, t(j)) :- !. %Lc3	
klasa_licz(cztery, t(j)) :- !. %Lc4	
klasa_licz(dziewięć, t(j)) :- !. %Ld005
klasa_licz(pięć, t(j)) :- !. %Ld005
klasa_licz(sześć, t(j)) :- !. %Ld005
klasa_licz(siedem, t(j)) :- !. %Ld007
klasa_licz(osiem, t(j)) :- !. %Ld008
klasa_licz(kilka, t(j)) :- !. %Ld00K
klasa_licz(parę, t(j)) :- !. %Ld00P
%
klasa_licz(dziesięć, t(n)) :- !.	    %Ld005
klasa_licz(czternaście, t(n)) :- !. %Ld011
klasa_licz(dziewiętnaście, t(n)) :- !. %Ld011
klasa_licz(jedenaście, t(n)) :- !. %Ld011
klasa_licz(osiemnaście, t(n)) :- !. %Ld011
klasa_licz(piętnaście, t(n)) :- !. %Ld011
klasa_licz(siedemnaście, t(n)) :- !. %Ld011
klasa_licz(szesnaście, t(n)) :- !. %Ld011
klasa_licz(trzynaście, t(n)) :- !. %Ld011
klasa_licz(dwanaście, t(n)) :- !. %Ld012
klasa_licz(kilkanaście, t(n)) :- !. %Ld012
klasa_licz(paręnaście, t(n)) :- !. %Ld01P
%
klasa_licz(dwadzieścia, t(d)) :- !.	    %Ld020
klasa_licz(czterdzieści, t(d)) :- !. %Ld030
klasa_licz(trzydzieści, t(d)) :- !. %Ld030
klasa_licz(dziewięćdziesiąt, t(d)) :- !. %Ld050
klasa_licz(osiemdziesiąt, t(d)) :- !. %Ld050
klasa_licz(pięćdziesiąt, t(d)) :- !. %Ld050
klasa_licz(siedemdziesiąt, t(d)) :- !. %Ld050
klasa_licz(sześćdziesiąt, t(d)) :- !. %Ld050
klasa_licz(kilkadziesiąt, t(d)) :- !. %Ld0K0
klasa_licz(parędziesiąt, t(d)) :- !. %Ld0P0
%
klasa_licz(sto, t(s)) :- !. %Ld100
klasa_licz(dwieście, t(s)) :- !. %Ld200
klasa_licz(czterysta, t(s)) :- !. %Ld300
klasa_licz(trzysta, t(s)) :- !. %Ld300
klasa_licz(dziewięćset, t(s)) :- !. %Ld500
klasa_licz(pięćset, t(s)) :- !. %Ld500
klasa_licz(sześćset, t(s)) :- !. %Ld500
klasa_licz(siedemset, t(s)) :- !. %Ld700
klasa_licz(osiemset, t(s)) :- !. %Ld800
klasa_licz(kilkaset, t(s)) :- !. %LdK00
klasa_licz(paręset, t(s)) :- !. %LdP00
%
% zostawiam ze względu na NKJP:
klasa_licz(dwoje, t(j)) :- !.		    %Lz2, t()) :- !. %Zbędne
klasa_licz(troje, t(j)) :- !. %Lz2, t()) :- !. %Zbędne
klasa_licz(czterdzieścioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(czternaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(czworo, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dwadzieścioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dwanaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dziesięcioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dziewięcioro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dziewiętnaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(dziewięćdziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(jedenaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(kilkadziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(kilkanaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(kilkoro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(kilkudziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(osiemdziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(osiemnaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(ośmioro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(pięcioro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(piętnaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(pięćdziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(siedemdziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(siedemnaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(siedmioro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(szesnaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(sześcioro, t(j)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(sześćdziesięcioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(trzydzieścioro, t(d)) :- !. %Lz4, t()) :- !. %Zbędne
klasa_licz(trzynaścioro, t(n)) :- !. %Lz4, t()) :- !. %Zbędne
%
klasa_licz(_,neut).

formalicz(_P, _R/_L, _Akom, neut, Sub) -->
	s(n_li2),
	[morf(_,H,dig)].


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Formy czasownikowe:

% Tryb oznajmujący, czas ter. lub przypro:

formaczas( os, A, C, ozn, _R/L, O, Wym, tak, _Sub ) --> s(n_cz4),
	[morf(_,H,fin:Num:Per:As)],
	{ aspekt(As,A), czas(fin,A,C),
	  osoba(Per,O), liczba(Num,L), rekcja_finitywna(H,Wym) }.

formaczas( os, A, C, ozn, _R/L, O, Wym, tak, _Sub ) --> s(n_cz4b),
	[morf(_, być, aglt:Num:Per:_:_)], 
	{ liczba(Num,L), osoba(Per,O),
	  rekcja_finitywna(być,Wym) }.
%%%% Jam łasica.
%%%% Tyś Pan, Bóg mój.

formaczas( os, nd, przy, ozn, _R/L, O, Wym, tak, _Sub ) --> s(n_cz5),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L), rekcja_finitywna(być,Wym) }.

%% czas przyszły złożony:

przyzlo( S, _RL, Wym, _Sub ) --> s(n_czp1),
	[morf(_,H,inf:As)],
	{ aspekt(As,nd), rekcja_finitywna(H,Wym) }.

przyzlo( S, R/L, Wym, _Sub ) --> s(n_czp2),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,nd),
	  liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

formaczas( os, nd, przy, ozn, R/L, O, Wym, tak, _Sub ) --> s(n_cz6),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
 	przyzlo( S, R/L, Wym, na ).

formaczas( os, nd, przy, ozn, R/L, O, Wym, tak, _Sub ) --> s(n_cz7),
 	przyzlo( S, R/L, Wym, na ),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) }.

formaczas( os, nd, przy, ozn, R/L, O, Wym, nie(_), _Sub ) --> s(n_cz38),
 	przyzlo( S, R/L, Wym, na ),
	partykuła(nie, po),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) }.

formaczas1( n, os, nd, przy, ozn, R/L, O, Wym, _Sub ) --> s(n_cz8),
	[morf(_, być, bedzie:Num:Per:imperf)],
	[morf(_,'się',qub)],
	{ osoba(Per,O), liczba(Num,L) },
 	przyzlo( s, R/L, Wym, na ).

formaczas1( n, os, nd, przy, ozn, R/L, O, Wym, _Sub ) --> s(n_cz9),
 	przyzlo( s, R/L, Wym, na ),
	[morf(_,'się',qub)],
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) }.

%% czas przeszły:

formaczas( os, A, prze, ozn, R/L, 3, Wym, tak, _Sub ) --> s(n_cz10),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	  liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

formaczas( os, A, prze, ozn, R/L, O, Wym, tak, _Sub ) --> s(n_cz11),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, agl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) },
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ osoba(Per,O) }.

formaczas( os, A, prze, ozn, R/L, O, Wym, tak, _Sub ) --> s(n_cz111),
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ osoba(Per,O) },
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, agl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

%%%% Gdzie‹ś | był›?
%%%% Ty‹ś | powiedział›.

% Tryb warunkowy:

condaglt(L,3, Sub) -->
	s(n_cza1),
	[morf(_,by,qub)].
	
condaglt(L,O, Sub) -->
	s(n_cza2),
	[morf(_,by,qub)],
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ liczba(Num,L), osoba(Per,O) }.

formaczas( os, A, _C, war, R/L, O, Wym, tak, _Sub ) --> s(n_cz12),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) },
	condaglt(L,O,na).

formaczas( os, A, _C, war, R/L, O, Wym, tak, _Sub ) --> s(n_cz13),
	condaglt(L, O, na),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

% wariant z 'się' w środku:

formaczas1( n, os, A, _C, war, R/L, O, Wym, _Sub ) --> s(n_cz14),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	[morf(_,'się',qub)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,WymF),
	wyjmijwymaganie(sie,WymF,Wym) },
	condaglt(L,O,na).

formaczas1( n, os, A, _C, war, R/L, O, Wym, _Sub ) --> s(n_cz15),
	condaglt(L, O,na),
	[morf(_,'się',qub)],
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,WymF),
	wyjmijwymaganie(sie,WymF,Wym) }.

% Czas przeszły trybu warunkowego:

formaczas( os, A, prze, war, R/L, O, Wym, tak, _Sub ) --> s(n_cz37),
	[morf(_,być,praet:Num:Gend:imperf)],
	condaglt(L, O, na),
	[morf(_,H,praet:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

%%%% Jan ‹byłby oddał› taniej. 
%%%% ‹Bylibyśmy czytali›.
%%%% Nie ‹byłyby pisały›.

% formaczas1 : dodać ‹byłby się bał›

% Tryb rozkazujący:

formaczas( os, A, przy, roz, _R/L, O, Wym, tak, _Sub ) --> s(n_cz16),
	[morf(_,H,impt:Num:Per:As)],
	{ aspekt(As,A),
	  osoba(Per,O), liczba(Num,L), rekcja_finitywna(H,Wym) }.

formaczas( os, A, przy, roz, _R/L, O, Wym, tak, _Sub ) --> s(n_cz17),
	[morf(_,N,qub)],
	{ member(N,[niech,niechaj,niechże,niechajże]) },
	[morf(_,H,fin:Num:Per:As)],
	{ (Num=sg, Per\=sec ; Num=pl, Per=ter),
	  aspekt(As,A),
	  osoba(Per,O), liczba(Num,L), rekcja_finitywna(H,Wym) }.

formaczas1( n, os, A, przy, roz, _R/L, O, Wym, _Sub ) --> s(n_cz18),
	[morf(_,N,qub)],
	{ member(N,[niech,niechaj,niechże,niechajże]) },
	[morf(_,'się',qub)],
	[morf(_,H,fin:Num:Per:As)],
	{ (Num=sg, Per\=sec ; Num=pl, Per=ter),
	  aspekt(As,A),
	  osoba(Per,O), liczba(Num,L), rekcja_finitywna(H,WymF),
	  wyjmijwymaganie(sie,WymF,Wym) }.

formaczas( os, nd, przy, roz, _R/L, O, Wym, tak, _Sub ) --> s(n_cz40),
	[morf(_,N,qub)],
	{ member(N,[niech,niechaj,niechże,niechajże]) },
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ (Num=sg, Per\=sec ; Num=pl, Per=ter),
	  osoba(Per,O), liczba(Num,L), rekcja_finitywna(być,Wym) }.

%%%% Niech będzie pochwalony!


% Formy nieosobowe:

% w poniższych dodatkowy warunek: subj niedopuszczalne dla Wf<>os

formaczas( bos, A, prze, ozn, _RL, _O, NWym, tak, _Sub ) --> s(n_cz19),
	[morf(_,H,imps:As)],
	{ aspekt(As,A), rekcja_niefinitywna(H,NWym) }.

formaczas( bos, A, _C, war, _RL, _O, NWym, tak, _Sub ) --> s(n_cz20),
	[morf(_,H,imps:As)],
	[morf(_,by,qub)],
	{ aspekt(As,A), rekcja_niefinitywna(H,NWym) }.

formaczas( bos, A, _C, war, _RL, _O, NWym, tak, _Sub ) --> s(n_cz21),
	[morf(_,by,qub)],
	[morf(_,H,imps:As)],
	{ aspekt(As,A), rekcja_niefinitywna(H,NWym) }.

formaczas1( n, bos, A, _C, war, _RL, _O, NWym, _Sub ) --> s(n_cz22),
	[morf(_,H,imps:As)],
	[morf(_,'się',qub)],
	[morf(by,by,qub)],
	{ aspekt(As,A), rekcja_niefinitywna(H,Wym),
	  wyjmijwymaganie(sie, Wym, NWym) }.

formaczas1( n, bos, A, _C, war, _RL, _O, NWym, _Sub ) --> s(n_cz23),
	[morf(_,by,qub)],
	[morf(_,'się',qub)],
	[morf(_,H,imps:As)],
	{ aspekt(As,A), fail, rekcja_niefinitywna(H,Wym),
	  wyjmijwymaganie(sie, Wym, NWym) }.

% W tym miejscu dajemy rekcję finitywną, bo taka forma może się
% jeszcze okazać częścią czasu przyszłego złożonego.  Sprawdzamy to
% przy próbie podłączania wymagań.
formaczas( bok, A, _C, _T, _RL, _O, NWym, tak, _Sub ) --> s(n_cz24),
	[morf(_,H,inf:As)],
	{ aspekt(As,A), rekcja_finitywna(H,NWym) }.

formaczas( psu, A, _C, _T, _RL, _O, NWym, tak, _Sub ) --> s(n_cz25),
	[morf(_,H,pant:As)],
	{ aspekt(As,A), rekcja_niefinitywna(H,NWym) }.

formaczas( psw, A, _C, _T, _RL, _O, NWym, tak, _Sub ) --> s(n_cz26),
	[morf(_,H,pcon:As)],
	{ aspekt(As,A), rekcja_niefinitywna(H,NWym) }.

% Niewłaściwe (predykatywy):

formaczas( os, nd, ter, ozn, _RL, _O, Wym, tak, _Sub ) --> s(n_cz27),
	[morf(_,H,pred)],
	{ rekcja_finitywna(H,Wym) }.

formaczas( os, nd, przy, ozn, _RL, _O, Wym, tak, _Sub ) --> s(n_cz28),
	[morf(będzie, być, bedzie:sg:ter:imperf)],
	[morf(_,H,pred)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( os, nd, przy, ozn, _RL, _O, Wym, tak, _Sub ) --> s(n_cz29),
	[morf(_,H,pred)],
	[morf(będzie, być, bedzie:sg:ter:imperf)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( os, nd, prze, ozn, _RL, _O, Wym, tak, _Sub ) --> s(n_cz30),
	[morf(było, być, praet:sg:_:imperf)],
	[morf(_,H,pred)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( os, nd, prze, ozn, _RL, _O, Wym, tak, _Sub ) --> s(n_cz31),
	[morf(_,H,pred)],
	[morf(było, być, praet:sg:_:imperf)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( os, nd, _C, war, _RL, _O, Wym, tak, _Sub ) --> s(n_cz32),
	[morf(_,H,pred)],
	[morf(_,by,qub)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( os, nd, _C, war, _RL, _O, Wym, tak, _Sub ) --> s(n_cz33),
	[morf(_,by,qub)],
	[morf(_,H,pred)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

formaczas( bok, nd, _C, _T, _RL, _O, Wym, tak, _Sub ) --> s(n_cz34),
	[morf(_, być, inf:imperf)],
	[morf(_,H,pred)],
	{ H\=to, rekcja_finitywna(H,Wym) }.

% formy analityczne predykatywnego «to»:

% przeszłe:
formaczas( os, nd, prze, ozn, R/L, 3, Wym, tak, _Sub ) --> s(to2),
	[morf(_, być, praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R) },
	[morf(_,to,pred)],
	{ rekcja_finitywna(to,Wym) }.

formaczas( os, nd, prze, ozn, R/L, O, Wym, tak, _Sub ) --> s(to3),
	[morf(_, być, praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R) },
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ osoba(Per,O) },
	[morf(_,to,pred)],
	{ rekcja_finitywna(to,Wym) }.

formaczas( os, nd, prze, ozn, R/L, 3, Wym, tak, _Sub ) --> s(to4),
	[morf(_,to,pred)],
	[morf(_, być, praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R) },
	{ rekcja_finitywna(to,Wym) }.

formaczas( os, nd, prze, ozn, R/L, O, Wym, tak, _Sub ) --> s(to5),
	[morf(_,to,pred)],
	[morf(_, być, praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R) },
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ osoba(Per,O) },
	{ rekcja_finitywna(to,Wym) }.

% przyszłe:
formaczas( os, nd, przy, ozn, _R/L, O, Wym, tak, _Sub ) --> s(to6),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	[morf(_,to,pred)],
	{ rekcja_finitywna(to,Wym) }.

formaczas( os, nd, przy, ozn, _R/L, O, Wym, tak, _Sub ) --> s(to7),
	[morf(_,to,pred)],
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	{ rekcja_finitywna(to,Wym) }.

% teraźniejsze:
formaczas( os, nd, ter, ozn, _R/L, O, Wym, tak, _Sub ) --> s(to8),
	[morf(_, być, fin:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	[morf(_,to,pred)],
	{ rekcja_finitywna(to,Wym) }.

formaczas( os, nd, ter, ozn, _R/L, O, Wym, tak, _Sub ) --> s(to9),
	[morf(_,to,pred)],
	[morf(_, być, fin:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	{ rekcja_finitywna(to,Wym) }.

%%%? Świnia ‹to jestem› ja.

% zanegowane formy analityczne predykatywnego «to»:

formaczas( os, nd, ter, ozn, _RL, _O, Wym, nie(_), _Sub ) --> s(to10),
	[morf(_,to,pred)],
	[morf(_,nie,qub)],
	{ rekcja_finitywna(to,Wym) }.

%%%% Lewak ‹to | nie› liberał.

% przeszłe:
formaczas( os, nd, prze, ozn, R/L, 3, Wym, nie(_), _Sub ) --> s(to14),
	[morf(_,to,pred)],
	[morf(_,nie,qub)],
	[morf(_, być, praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R) },
	{ rekcja_finitywna(to,Wym) }.

%%%% Dostać wizę ‹to nie był› żaden problem.

% Na razie uznaję za za dziwne:
% formaczas( os, nd, prze, ozn, R/L, O, Wym, nie(_), _Sub ) --> s(to15),
% 	[morf(_,to,pred)],
% 	[morf(_,nie,qub)],
% 	[morf(_, być, praet:Num:Gend:imperf)],
% 	{ liczba(Num,L), rodzaj(Gend,R) },
% 	[morf(_F, 'być', aglt:Num:Per:_:_)], 
% 	{ osoba(Per,O) },
% 	{ rekcja_finitywna(to,Wym) }.
%
% %%%? Ty ‹to nie byłeś› liberał.
% %%%? Orangutan ‹to nie byłeś› Ty.

% przyszłe:
formaczas( os, nd, przy, ozn, _R/L, O, Wym, nie(_), _Sub ) --> s(to17),
	[morf(_,to,pred)],
	[morf(_,nie,qub)],
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	{ rekcja_finitywna(to,Wym) }.

%%%% Dostać wizę ‹to nie będzie› żaden problem.

% teraźniejsze:
formaczas( os, nd, ter, ozn, _R/L, O, Wym, nie(_), _Sub ) --> s(to19),
	[morf(_,to,pred)],
	[morf(_,nie,qub)],
	[morf(_, być, fin:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) },
	{ rekcja_finitywna(to,Wym) }.

%%%? Świnia ‹to nie jestem› ja.


formaczas( os, nd, _C, war, R/L, O, Wym, tak, _Sub ) --> s(to20),
	[morf(_,to,pred)],
	[morf(_,być,praet:Num:Gend:imperf)],
	condaglt(L, O, na),
	{ liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(to,Wym) }.

%%%% Zawał to byłaby tragedia.
%%%% Świnia to byłbym ja.

formaczas( os, nd, _C, war, R/L, O, Wym, tak, _Sub ) --> s(to21),
	[morf(_,to,pred)],
	condaglt(L, O, na),
	[morf(_,być,praet:Num:Gend:imperf)],
	{ liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(to,Wym) }.

%%%% Zawał to by była tragedia.

formaczas( os, nd, _C, war, R/L, O, Wym, tak, _Sub ) --> s(to21),
	[morf(_,być,praet:Num:Gend:imperf)],
	condaglt(L, O, na),
	[morf(_,to,pred)],
	{ liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(to,Wym) }.

%%%% Tragedia byłby to objaw słabości.

% odmienne nietypowo (powinien):

formaczas( os, A, ter, ozn, R/L, 3, Wym, tak, _Sub ) --> s(n_cz35),
	[morf(_,H,winien:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, nagl), aspekt(As,A),
	  liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) }.

formaczas( os, A, ter, ozn, R/L, O, Wym, tak, _Sub ) --> s(n_cz36),
	[morf(_,H,winien:Num:Gend:AsAgl)],
	{ asagl(AsAgl, As, agl), aspekt(As,A),
	liczba(Num,L), rodzaj(Gend,R), rekcja_finitywna(H,Wym) },
	[morf(_F, 'być', aglt:Num:Per:_:_)], 
	{ osoba(Per,O) }.

% Posiłkowa forma czasownika (jednostka poziomu mieszanego — rozpisuje
% się na terminale, ale wchodzi bezpośrednio do zdania):

posiłk(agl(O), _R/L, neut, ni, (0|0), Sub) -->
	s(po1),
	[morf(_, 'być', aglt:Num:Per:_:_)], 
        { liczba(Num,L), osoba(Per,O) }.

%%%% Czytałybyście, gdyby‹m› wiedział.

% !!!mw: w GFJP1 «gdyby więc wiedział» ma pusty aglutynant ze spójnikiem

posiłk(niech, RL, neut, ni, (0|0), Sub) -->
	s(po2),
	[morf(_,N,qub)],
	{ member(N,[niech,niechaj,niechże,niechajże]) }.

%%%% ‹Niech› duch Twój zstąpi!

posiłk(by(O), _R/L, neut, ni, (0|0), Sub) -->
	s(po3),
	condaglt(L, O, na).

%%%% Ja ‹bym› to chętnie zrobił.

posiłk(byłby(O,tak), R/L, neut, ni, (0|0), Sub) -->
	s(po4),
	[morf(_,być,praet:Num:Gend:imperf)],
	condaglt(L, O, na),
	{ liczba(Num,L), rodzaj(Gend,R) }.

%%%% ‹Byłbym› to chętnie zrobił.

posiłk(bedzie(O,tak), _R/L, neut, ni, (0|0), Sub) -->
	s(po5),
	[morf(_, być, bedzie:Num:Per:imperf)],
	{ osoba(Per,O), liczba(Num,L) }.

posiłk(bedzie(O,nie(_)), RL, Dest, I, Pk, Sub) -->
	s(po6),
	partykuła(nie, po),
	posiłk(bedzie(O,tak), RL, Dest, I, Pk, na).

% \subsection{Formy przysłówkowe}
% najtypowsza forma przysłówkowa odprzymiotnikowa lub stopniowalna:
formaprzys(St, przys, Neg, neut, Sub) -->
	s(eps1),
	[morf(_,_,adv:Degr)],
	{ stopien(Degr,St) }.

% najtypowsza forma przysłówkowa nieodprzymiotnikowa i niestopniowalna:
formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps2),
	[morf(_,_,adv)].

% zaimki przysłowne:
formaprzys(row, przys, Neg, Dest, Sub) -->
	s(eps3),
	[morf(_,H,padv)],
	{ równe(H, [dlaczego,dokąd,gdzie,jak,kiedy,którędy,odkąd,skąd,czemu]),
	  równe(Dest,[pyt,pz]) } .

% względniki przysłówkowe:
formaprzys(row, przys, Neg, wz(H,przys), Sub) -->
	s(eps30),
	[morf(_,H,padv)],
	{ równe(H, [dokąd,gdzie,jak,kiedy,którędy,odkąd,skąd]) } .

formaprzys(row, tk, Neg, neut, Sub) -->
	s(eps4),
	[morf(_,H,padv)],
	{ member(H,[tak]) }. % MW: wyrzuciłem stąd «taki». Co to miało być?

formaprzys(row, przys, nie(_Neg), neut, Sub) -->
	s(eps5),
	[morf(_,nigdy,padv)].

% sfrazeologizowane:
formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps10),
	[morf(_,na,prep:Cases)],
	{przypadki(Cases,bier)},
	[morf(_,H,adv:pos)],
	{member(H,[bieżąco,długo,fest,krótko,lewo,nowo,okrągło,pewno,prawo,próżno,szybko,żywo,
		   biało,czarno,czerwono,niebiesko,różowo,rudo,zielono,żółto]) }.

formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps12),
	[morf(_,na,prep:Cases)],
	{przypadki(Cases,bier)},
	[morf(_,H,adv)],
	{member(H,[darmo,serio,tip-top,tyle,wpół,zawsze,zewnątrz]) }.

formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps15),
	[morf(_,na,prep:Cases)],
	{przypadki(Cases,bier)},
	[morf(_,H,burk)],
	{member(H,[przekór,przemian]) }.

formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps11),
	[morf(_,i,conj)],
	[morf(_,tak,padv)].

formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps13),
	[morf(_,jak,padv)],
	[morf(_,zwykle,adv:pos)].

formaprzys(row, przys, Neg, neut, Sub) -->
	s(eps14),
	[morf(_,za,prep:Cases)],
	{przypadki(Cases,bier)},
	[morf(_,H,adv)],
	{member(H,[darmo]) }.

%%%% Mieszkańcy będą mogli korzystać z nich ‹za darmo›.

% Uznałem za niepotrzebne (duck typing):
% formaprzys(row, przys, Neg, neut, Sub) -->
% 	s(eps15),
% 	[morf(przede,przed,prep:Cases:wok)],
% 	{przypadki(Cases,narz)},
% 	[morf(wszystkim,wszystko,subst:sg:Cases2:_)],
% 	{przypadki(Cases2,narz)}.


% morfagl(F, _R/L, O)      --> s(jel1), [morf(F, 'być', aglt:Num:Per:_:_)], 
%                           { liczba(Num,L), osoba(Per,O) }.




% \subsection{}

partykuła(H,Sub)           --> s(jel2), [morf(_,H,qub)].

przyimek(F, P, Sub)         --> s(jel3), [morf(_,F,prep:Cases)], 
                          { przypadki(Cases,P),
			    F \= przeciwko }.
przyimek(F, P, Sub)         --> s(jel3x), [morf(_,F,prep:Cases:_)], 
                          { przypadki(Cases,P) }.


% dostosowanie do Walentego, w którym wymaganie jest oznaczane „przeciw”:
przyimek(przeciw, P, Sub) --> s(jel3p),
	[morf(_,przeciwko,prep:Cases)], 
	{ przypadki(Cases,P) }.

% tymczasowe, trzeba zrobić porządnie!
% następujące dwuczłonowe przyimki występują w słowniku Świdzińskiego:

przyimek('co do',dop,Sub) --> s(jel3a),
	[morf(co,co,prep:acc)],
	[morf(do,do,prep:gen)].

przyimek('na temat',dop,Sub) --> s(jel3b),
	[morf(na,na,prep:[acc|loc])],
	[morf(temat,temat,subst:sg:[nom|acc]:m3)].

przyimek('w sprawie',dop,Sub) --> s(jel3c),
	[morf(w,w,prep:[acc|loc]:nwok)],
	[morf(sprawie,sprawa,subst:sg:[dat|loc]:f)].

przyimek('z powodu',dop,Sub) --> s(jel3d),
	[morf(z,z,prep:[gen,acc|inst]:nwok)],
	[morf(powodu,powód,subst:sg:gen:m3)].

przyimek('w trakcie',dop,Sub) --> s(jel3e),
	[morf(w,w,prep:Cases1:nwok)],
	{przypadki(Cases1,miej)},
	[morf(trakcie,trakt,subst:sg:Cases2:m3)],
	{przypadki(Cases2,miej)}.

przyimek('wraz z',narz,Sub) --> s(jel3f),
	[morf(wraz,wraz,Tag)],
	{równe(Tag,[burk,adv])},
	[morf(z,z,prep:Cases:nwok)].

przyimek('w ciągu',dop,Sub) --> s(jel3g),
	[morf(w,w,prep:Cases1:nwok)],
	{przypadki(Cases1,miej)},
	[morf(ciągu,ciąg,subst:sg:Cases2:m3)],
	{przypadki(Cases2,miej)}.

% dalsze przyimki złożone:

przyimek('na skutek',dop,Sub) --> s(jel3h),
	[morf(na,na,prep:Cases1)],
	{przypadki(Cases1,bier)},
	[morf(skutek,skutek,subst:sg:Cases2:m3)],
	{przypadki(Cases2,bier)}.


% Skróty rozwijające się do przyimków: Na razie znamy tylko „wg”, ale
% na wszelki wypadek wpisujemy również wersję z kropką.
przyimek(F, P, Sub)         --> s(jel3s), [morf(_,F,brev:Pun)],
	{ slowskr(F,_Skr,Pun, Kon, prep:Cases), 
	  przypadki(Cases,P)  },
	optional(terminal(morf('.',_,interp)),{Kon\=kon},{Kon\=nkon}).

% \subsubsection{Realizacje skoordynowane przyimków}

przyimek(Pm, P, Sub) -->
	s(pimr1),
	przyimek(Pm1, P, po),
	przec(Pk2,po),
	spójnik(rc,Oz,ni,na),
	przyimek(Pm, P, po).

%%%% Czekali za, a nawet przed domem.

przyimek(Pm, P, Sub) -->
	s(pimr2),
	spójnik(rl,Oz,ni,na),
	przyimek(Pm2, P, po),
	przec(Pk3,po),
	spójnik(rp,Oz,ni,po),
	przyimek(Pm, P, po).

%%%% ‹Nie tylko | od|, | ale i | do› domu szły.

% fpm (, fpm)* sp fpm
przyimek(Pm, P, Sub) -->
	s(pims3),
	przyimek(Pm1, P1, po),
	sequence_of([
            [ spójnik(sz,przec,ni,po),
	      przyimek(Pm3, P3, po)
	    ]^[Pm3]^[P3]
	]),
	spójnik(szk,Oz,ni,na),
	przyimek(Pm, P, po).

%%%% Pokonuje dużą odległość w drodze ‹do | i | z› pracy.
%%%% Zdarzyło się ‹przed | lub | za› Gibraltarem.
%%%% Samogłoski zaznacza się za, przed, nad lub pod spółgłoską.
%%%! Badania były prowadzone ‹przed, podczas lub po› treningach.
%%%! Obok, nad lub pod nimi pracują górnicy.

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%% Formy wykrzyknikowe:

formawykrz(Wym, Sub) -->
	s(wk1),
	[morf(_,H,interj)],
	{ rekcja_wykrzyknikowa(H,Wym) }.

%%%% ‹O›!
%%%% ‹O› Jezu, a cóż to jest?
%%%% ‹Biada› nam!
%%%% ‹Precz› z Wałęsą!

formawykrz(Wym, Sub) -->
	s(wk2),
	[morf(_,H1,interj)],
	[morf(_,H,interj)],
	{ rekcja_wykrzyknikowa(H,Wym) }.

% To jest wątpliwe interpunkcyjnie, ale występuje:
%%%% ‹Hi hi›!

formawykrz(Wym, Sub) -->
	s(wk2),
	[morf(_,H1,interj)],
	[morf('-','-',interp)],
	[morf(_,H,interj)],
	{ rekcja_wykrzyknikowa(H,Wym) }.

%%%% My tu ‹gadu-gadu›, a ryby są rozdzielnopłciowe.
%%%% ‹Pif-paf›, wyzywam Pana na pojedynek.


% \subsection{}

znakkonca(pyt, Sub)            --> s(int1), [morf('?',_,interp)].
znakkonca(pyt, Sub)            -->
	s(int8), [morf('!',_,interp)],
	[morf('?',_,interp)].
znakkonca(pyt, Sub)            -->
	s(int9), [morf('?',_,interp)],
	[morf('!',_,interp)].
znakkonca(pyt, Sub) --> s(int11), [morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('?',_,interp)].
znakkonca(pyt, Sub) --> s(int12), [morf('?',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)].
znakkonca(pyt, Sub) --> s(int20),
	[morf('?',_,interp)],
	[morf('!',_,interp)], 
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)].

znakkonca(neut, Sub) --> s(int2), [morf('.',_,interp)].
znakkonca(neut, Sub) --> s(int3), [morf('!',_,interp)].
znakkonca(neut, Sub) --> s(int10),
	[morf('!',_,interp)],[morf('!',_,interp)],[morf('!',_,interp)].
znakkonca(neut, Sub) --> s(int4), [morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)].
znakkonca(neut, Sub) --> s(int5), [morf('…',_,interp)].
znakkonca(neut, Sub) --> s(int7), [morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('.',_,interp)],
	[morf('!',_,interp)].
znakkonca(neut, Sub) --> s(int15), [morf('…',_,interp)],
	[morf('!',_,interp)].
znakkonca(neut, Sub) --> s(int18),
	[morf('!',_,interp)], 
	[morf('.',_,interp)], [morf('.',_,interp)], [morf('.',_,interp)].
znakkonca(neut, Sub) --> s(int19),
	[morf('!',_,interp)], 
	[morf('…',_,interp)].


korelat(K/P, ni, _Sub) --> 
	s(kor1),
	przyimek(K, P, na),
	zaimrzecz(to, P, _R/poj, po).

korelat(P, ni, _Sub) --> 
	s(kor2), 
	zaimrzecz(to, P, _R/poj, na),
	{ \+ member(P, [mian,miej,wol]) }.

% korelat inkorporacyjny:
korelat(K, i(TI,OI), _Sub) --> 
	s(kor3),
	korelat(K, ni, na),
	spójnik(i(TI,OI), _Oz2, ni, po).

przec((p|p), Sub)             --> s(int6), [morf(_,',',interp)].
przec((p|p), Sub)             --> s(int13), [morf(_,';',interp)].

cudz(_, Sub) --> s(intc1), [morf('"',_,interp)].
cudz(o, Sub) --> s(intc2), [morf('„',_,interp)].
cudz(o, Sub) --> s(intc5), [morf(',',_,interp)],[morf(',',_,interp)].
cudz(z, Sub) --> s(intc3), [morf('”',_,interp)].
cudz(z, Sub) --> s(intc6), [morf('''''',_,interp)]. % dwa apostrofy — jest w NKJP1M :-/
cudz(z, Sub) --> s(intc7), [morf('''',_,interp)], [morf('''',_,interp)].
cudz(_, Sub) --> s(intc4), [morf('“',_,interp)].  % ang. otw, niem. zamyk

pauza(Sub) --> s(intp1), [morf('—',_,interp)].
pauza(Sub) --> s(intp2), [morf('–',_,interp)].
pauza(Sub) --> s(intp3), [morf('-',_,interp)].
% Morfeusz i tak nie generuje takich interpretacji.  Ale może w korpusie ręcznym są.
pauza(Sub) --> s(intp4), [morf('-',_,interp)],[morf('-',_,interp)].
pauza(Sub) --> s(intp5), [morf('-',_,interp)],[morf('-',_,interp)],[morf('-',_,interp)].

nawias(o,o,Sub) --> s(intn1), [morf('(',_,interp)].
nawias(z,o,Sub) --> s(intn2), [morf(')',_,interp)].
nawias(o,k,Sub) --> s(intn3), [morf('[',_,interp)].
nawias(z,k,Sub) --> s(intn4), [morf(']',_,interp)].

dwukropek(Sub) --> s(intd1), [morf(':',_,interp)].

%%%%  Local Variables:  
%%%%  mode: prolog
%%%%  End: