************************************************************************************
* In diesem Dokument befinden sich keine Lösungen nur Anregungen für die Beispiele *
* Zum Lesen empfehle ich Notpad++ mit einer UserDefinedLanguage für Prolog		   *
* Bezieht sich auf das WS2018													   *
************************************************************************************


8)

Ebenso bruder_von/2

:- bruder_von(B,P).
:/- bruder_von(B,B).
:- weiblich(B), bruder_von(B,P).
:/-weiblich(B),männlich(B).

:- bruder_von(marie_antoinette,marie_antoinette).
(Error) Weil zu speziell, nur dif(B,P) bleibt übrig, nochmal space, männlich

bruder_von(B, P) :-
	kind_von(B,E),
	kind_von(P,E),
	dif(B,P),
	männlich(B).
	
11)

:-kind_vonvater_vonmutter(K,V,M).
:/-kind_vonvater_vonmutter(K,V,K).
:/-kind_vonvater_vonmutter(K,K,M).

kind_vonvater_vonmutter(K,V,M) :-
	kind_von(K,V),
	männlich(V),
	kind_von(K,M),
	weiblich(M).
	
12)

:- kind_von(K,E),kind_von2(K,E).
kind_von2 ist teilmenge
	
kind_von2(K,E) :-
	kind_vonvater_vonmutter(K,E,_).
kind_von2(K,E) :-
	kind_vonvater_vonmutter(K,_,E).
	
13)

1: 
deutsch_english(handy,cellphone).
deutsch_english(mobiltelefon,cellphone).
deutsch_english(handlich,handy).
deutsch_english(baby,baby).
:-deutsch_english(handy,E).
:-deutsch_english(D,cellphone).
:-deutsch_english(D,E).
:-deutsch_english(D,D).

2:
assembler_binär(A,B).

3:
staat_organisation(S,O).

4:
ort_temperatur(O,T).

14)

argumentreihenfolge
größer_kleiner(G,K).
add = zahl_zahl_zahl(X,Z,SUMME).
computesum([])... zahlenliste_summe
sortiere -> zahlenliste_aufsteigend

15)
:- U = s(X), X=0.

:-U = f(V,X), X=a.
:-U = f(V,X), X= g(a).
:-U = f(V,X), X= g(X2),X2=a.

16)
:- U = g(a), U=g(b).
:-f(g(W),U) = f(V,g(a)).

17)

:(/)- natürlichezahlsx(X).
% 0, s(0),....
natürlichezahlsx(0).
//natürlichezahlsx(s(0)).
//natürlichezahlsx(s(X)) :- X = 0.
//natürlichezahlsx(s(X)) :- X = s(0).
//natürlichezahlsx(s(X)) :- X = s(0).
natürlichezahlsx(s(X)) :- natürlichezahlsx(X).
:-natürlichezahlsx(X), X=s(s(s(_))).

19)
vorfahre_von_abstand(E,K,s(0)) :-
	kind_von(K,E).
vorfahre_von_abstand(

20)
2: Subraction
4: :/-(&) nat_nat_summe(A,B,C), false.

nat_nat_summe(0,A,A).
nat_nat_summe(s(A),B,s(C)) :-
	nat_nat_summe(A,B,C).
	
5:
E=0

21)
:- parketspalte([W]) <<< W = w(1,2,3).
:- parketspalte([W]) <<< W = w(1,1,3).

b)
:/- parketspalte([W]) <<< würfel(W).
:/- würfel(W), false.
:- W = w (1,1,1), würfel(W).
:- W = w (1,2,3), würfel(W).
:- W = w (1,4,2), würfel(W).
:- W = w (_,4,_), würfel(W).
würfel(w(1,2,3)).
würfel(w(A,B,C)) :-
	holzart(A),
	holzart(B),
	holzart(C).

oder:
	
würfel(W) :-
	W = w(A,B,C),
	holzart(A),
	holzart(B),
	holzart(C),
	holzart(4). % Macht Probleme
	
holzart(1).
holzart(2).
holzart(3).

22)

:- Us = [V].

:- Us = [].

:- Us = [a].

:- Us = [a,b].
:- Us = [a,b|[]].
:- Us = [a|[b]].
:- Us = [a|[b|[]]].

23)

:- Us = [V].
:- Us = [V|Xs], Xs = [].

24)
:- würfelliste(Ws).
:/-& würfelliste(Ws), false.

:- Ws = [], würfelliste(Ws).

:- Ws = [_,_,_,_,_], würfelliste(Ws).

:- liste ({a,b,c]).
:- liste (s(0)).

liste([]).
liste([_X|Xs]) : -
	liste(Xs).
	
würfelliste([]).
würfelliste([_W|Ws] :-
	würfel(W),
	würfelliste(Ws).
	
:- parketspalte(Ws) <<< würfelliste(Ws).
:- parketspalte(Ws) <<< Ws= [_], würfelliste(Ws).
:- parketspalte(Ws) <<< liste(Ws), würfelliste(Ws).

25)

:- allegleich(Es).
:/-& allegleich(Es), false.
:- Es = [_,_,_|_], allegleich(Es).
:- Es = [any0,any1,any0], allegleich(Es).


27)
:- ring(R1);
:- ring(R2);

28)

:- keineelement_von(X,Xs).
:/-& keineelement_von(X,Xs), false.

//keineelement_von(_X,_Xs).


:- Xs = [_,_|_], keineelement_von(X,Xs).

:- Xs = [any0,any1,any2],X=any0 keineelement_von(X,Xs).
;/- Xs=[V0|_],X=V0,keineelement_von(X,Xs).


//keineelement_von(X, [Y,X]) :-
//	dif(X,Y).

keineelement_von(_X, []).
keineelement_von(X,[E|Es]) :-
	dif(X,E),
	keineelement_von(X,Es).

:- alleunterschiedlich(Xs).
:/-& alleunterschiedlich(Xs),false.

:- Xs = [_,_,_], alleunterschiedlich(Xs).
:/- Xs = [_,_,_], alleunterschiedlich(Xs),false.


alleunterschiedlich([]).
alleunterschiedlich([_E|Es]) :-
	keineelement_von(E,Es),
	alleunterschiedlich(Es).
	

	
29)

nat_nat_summeX(0,I,I).
nat_nat_summeX(s(J), I, s(K)) :-
	nat_nat_summeX(I,J,K).

30)

:- nat_nat_nat_summe(s(0),s(0),s(0),N).
:/- nat_nat_nat_summe(s(0),s(0),s(0),N).

:- nat_nat_nat_summe(A,B,C,D).
:/-& nat_nat_nat_summe(A,B,C,D),false.

nat_nat_nat_summe (A,B,C,D) :-
	nat_nat_summe(A,B,AB),
	nat_nat_summe(AB,C,D).
	
nat_nat_nat_summe (A,B,C,D) :-
	nat_nat_summe(A,BC,D),
	nat_nat_summe(B,C,BC).

	
	
31)
alleunterschiedlich auf alle Tage

32)
:-liste_gleichlang(Xs,Ys).
:/-&liste_gleichlang(Xs,Ys),false.

:-liste_gleichlang([a,b],[s(0),j_II]).
:- liste_gleichlang([a],[s(0),j_II]).

:/- liste_gleichlang([_],[_,_]).
:- liste_gleichlang([_,_,_], Ys).
:/- liste_gleichlang([_,_,_], Ys),false.
	
:/- liste_gleichlang(Xs,[_|Xs]).

liste_gleichlang([], _).
liste_gleichlang([_E|Es],[_F|Fs]) :-
	liste_gleichlang(Es,Fs]


:- ous_gleichlangmit(OUs, Xs).
:/-& ous_gleichlangmit(OUs, Xs),false.

	
:- ous_gleichlangmit(o([1,2]),o([3,4]),o([3,4])],[_,_]).

:/- ous_gleichlangmit(o([1,2]),o([3:/-:]),o([3,4])],[_,_]).

ous_gleichlangmit([],_Xs).
ous_gleichlangmit([OU|OUs],Xs) :-
	ou_(OU,E),
	liste_gleichlang(E,Xs)
	ous_gleichlangmit(OUS,Xs).
	
:- ou_(OU,E).
ou_(o[E],E).
ou_(u[E],E).
	
:- ous_quadrat(OUs).
:/-& ous_quadrat(OUs),false.

	
ous_quadrat(Ous) :-
	ous_gleichlangmit(OUs, OUs).
	
	
:-ous_abwechselnd ( [o(etwas),u(nochetwas)]).
:-ous_abwechselnd(OUs).
:/-ous_abwechselnd(OUs),false.

ous_abwechselnd([]).
ous_abwechselnd([OU|OUs]) :-
	ou_abw(OU,OUs),
	ous_abwechselnd(OUs).
	

	
	
%ou_abw(o(_), []).
%ou_abw(o(_), [u(_)|_]).
%ou_abw(u(_), []).
%ou_abw(u(_), [o(_)|_]).

%ou_abw(_, []).

ous_abwechselnd([]).
ous_abwechselnd(o(_)|OUs]) :-
	uos_abwechselnd(OUs).
	
uos_abwechselnd([]).	
uos_abwechselnd(u(_)|OUs]) :-
	ous_abwechselnd(OUs).


:-würfel123liste(Ws).
:/-&würfel123liste(Ws),false.

würfel123liste([]).
würfel123liste([w(1,2,3)|Ws] :-
	würfel123liste(Ws).
	
würfel123liste(Ws) :-
	allegleich(w(1,2,3)|Ws].
	
ous_mitwürfel123([]).
ous_mitwürfel123([OU|OUs]) :-
	ou_(OU, Ws),
	würfel123liste(Ws),
	ous_mitwürfel123(OUs).
	
	
parkettfläche(Parkett) :-
	ous_abwechselnd(Parkett),
	ous_quadrat(Parkett),
	ous_mitwürfel123(Parkett).
	
	
33)

:- zugweg_nach(Städte,Nach).
:/- zugweg_nach(Städte,Nach),false.

:- Städte = [_,_,_|_], zugweg_nach(Städte,Nach).
:- Städte = [_,_,_,_,_,_|_], zugweg_nach(Städte,Nach).
:- Städte = [endinburg,aberdeen,edinburg], zugweg_nach(Städte,Nach).

:/- Städte = [aberdeen], Nach=edinburg, zugweg_nach(Städte,Nach).
:/- Städte = [], zugweg_nach(Städte,Nach).

:- Städte = [_,_,_], zugweg_nach(Städte,Nach).
:/- Städte = [_,_,_], zugweg_nach(Städte,Nach),false.

:- Städte = [_,_,_,_,_,_,_], zugweg_nach(Städte,Nach).
:/-$ Städte = [_,_,_,_,_,_,_], zugweg_nach(Städte,Nach),false.


:- Städte = [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_], zugweg_nach(Städte,Nach).
:/-$ Städte = [_,_,_,_,_,_,_,_,_,_,_,_,_,_,_], zugweg_nach(Städte,Nach),false.
%Zu groß


:/- Städte = [V0,V0|_],zugweg_nach(Städte,Nach).
:/- Städte = [x,edinburg], Nach= edinburg, zugweg_nach(Städte,Nach).

zugweg_nach([Stadt],Stadt) :-
	stadt(Stadt).
zugweg_nach([Stadt|Weg],Nach) :-
	Weg = [X|_]				%Weg beginnt mit X
	streckevon_nach(Stadt, X),
	zugweg_nach(Weg, Nach).

:- steckenkarte(Weg) <<< Walzerstadt(W),Weg = [W, _,_,_,_,_,_,_, marseille], zugweg_nach(Weg, Nach).

:- regzugweg_nach(Weg,Nach).
:/- regzugweg_nach(Weg,Nach),false.
:- Weg = [_,_,_], regzugweg_nach(Weg,Nach).
:/- Weg = [_,_,_], regzugweg_nach(Weg,Nach),false.


regzugweg_nach([Stadt],Stadt) :-
	stadt(Stadt).
regzugweg_nach([Stadt|Weg],Nach) :-
	Weg = [X|_]				%Weg beginnt mit X
	regstreckevon_nach(Stadt, X),
	regzugweg_nach(Weg, Nach).
	
34)

:- regzugwegzyklenfrei_nach(Weg, Nach).
:/-& regzugwegzyklenfrei_nach(Weg, Nach),false.

regzugwegzyklenfrei_nach(Weg,Nach) :-
	alleunterschiedlich(Weg),
	regzugweg_nach(Weg,Nach).

35)
:- regzugweg_nach_außer(Weg,Nach,Außer).
:/-& regzugweg_nach_außer(Weg,Nach,Außer),false.


:- regzugweg_nach_außer(Weg,Nach,[]).
:/- regzugweg_nach_außer(Weg,Nach,[]),false.

:- Außer =[linz,linz|_], regzugweg_nach_außer(Weg,Nach,Außer). %Ist zulässing in Referenz

:- Weg= [_,_,_,_], Außer = [_,_,_,_], regzugweg_nach_außer(Weg,Nach,Außer).

regzugweg_nach_außer([Stadt],Stadt,Außer) :-
	keineelement_von(Stadt,Außer),
	stadt(Stadt).
regzugweg_nach_außer([Stadt|Weg],Nach,Außer) :-
	Weg = [X|_],				%Weg beginnt mit X
	keineelement_von(Stadt,Außer),
	regstreckevon_nach(Stadt, X),
	regzugweg_nach_außer(Weg, Nach,Außer).

%Versuch einer Verbesserung
regzugweg_nach_außer([Stadt],Stadt,Außer) :-
	keineelement_von(Stadt,Außer),
	stadt(Stadt).
regzugweg_nach_außer([Stadt|Weg],Nach,Außer) :-
	Weg = [X|_],				%Weg beginnt mit X
	keineelement_von(Stadt,Außer),
	regstreckevon_nach(Stadt, X),
	regzugweg_nach_außer(Weg, Nach,[Stadt|Außer]).
	
37)
:- phrase(lied,L).
:/- phrase(lied,L). %Kurzfristig ändern

:- phrase(quatrain1,"hier bin ich am Radar").

Lesearten: Der Anfang ist beliebig, ...

:- phrase(wort1, L).
:/- phrase(wort1, L),false.

:- phrase(wort2,L).

:- phrase(reim, L).
:/- phrase(reim, L),false.

%Shift Einf

reim -->
	"Auf",
	" ",
	wort1,
	" und Fleiß, ",
	"folgt ",
	wort2,
	" und Preiß".

38)

10:
g -->
	"a",
	* "b",  %Mit stern kann die Mitte beliebig lang sein
	"c".
%Es beginnt mit einem a es endet mit einem c


39)

:- phrase(expr, Xs).
:/-& phrase(expr, Xs),false.


:- phrase(expr,"(1+1)").
:/- phrase(expr,"(1+1)"),false.

:- phrase(expr, [A,B,C,D,E]).
:/- phrase(expr, [A,B,C,D,E]),false.

:- phrase(expr,"(1+(1+1))").
:- phrase(expr,"1").
:/-phrase(expr,"2").
:/- phrase(expr,['2'|_]).

expr -->
	"1".
expr -->
	"(",
	expr,
	"+",
	expr,
	")".

:-list_length(Text,N).

40)
:- phrase(expr(T),Xs).
:/- phrase(expr(T),Xs),false.

is_expr(knoten(1,[])).
is_expr(knoten(+,[ExprL,ExprR])) :-
	is_expr(ExprL),
	is_expr(ExprR).
	
expr(knoten(1,[])) -->
	"1".
expr(knoten(+,[ExprL,ExprR])) -->
	"(",
	expr(ExprL),
	"+",
	expr(ExprR),
	")".
	
:- Xs = "((1+1)+(1+1))", phrase(expr(T),Xs).
:- Xs = "((1+1)+(1+1))", T= knoten(+,[knoten(1,[])]),phrase(expr(T),Xs).


41)
:- expr_knotennamen(Expr, KNs).
:/- expr_knotennamen(Expr, KNs),false.


expr_knotennamen(Expr, KNs) :-
	phrase(knotennamen(Expr), KNs).
	
knotennamen(knoten(N, [])) -->
	[N].
knotennamen(knoten(N, [ExprL,ExprR])) -->
	[N],
	knotennamen(ExprL),
	knotennamen(ExprR).
	
42)


expr_knotennamenrpn(Expr, KNs) :-
	phrase(knotennamenrpn(Expr), KNs).
	
knotennamenrpn(knoten(N, [])) -->
	[N].
knotennamenrpn(knoten(N, [ExprL,ExprR])) -->
	knotennamenrpn(ExprR),
	knotennamenrpn(ExprL),
	[N].
	
	
43)

expr_knotenname(knoten(N, []), N).
expr_knotenname(knoten(N, [_,_],N).
expr_knotenname(knoten(_,[ExprL,_]),N) :-
	expr_knotenname(ExprL,N).
expr_knotenname(knoten(_,[ExprR,_]),N) :-
	expr_knotenname(ExprR,N).
	
	
expr_knotenname(knoten(N, _),N)).
expr_knotenname(knoten(_,[ExprL|_]),N) :-
	expr_knotenname(ExprL,N).
expr_knotenname(knoten(_,[_,ExprR|_]),N) :-
	expr_knotenname(ExprR,N).

	
44)


:- phrase(seq(Cs),Xs).
:/- phrase(seq(Cs),Xs),false.

seq([]) -->
	[].
seq([E|Es]) -->
	[E],
	seq(Es).
	

:- phrase(invseq("abc"), "cba").

invseq([]) -->
	[].
invseq([E|Es]) -->
	invseq(Es),
	[E].


palindrom -->
	seq(Xs),
	optel,
	invseq(Xs).

optel -->
	[].
optel -->
	[_].
	
	

palindrom2 -->
	[].
palindrom2 -->
	[_].
palindrom2 -->
	[E],
	palindrom2,
	[E].
	


45)

:- listen_zusammen(Xss,Xs).	
:/- listen_zusammen(Xss,Xs),false.	


:- Xss = [_,_,_], listen_zusammen(Xss,Xs).	
:/- Xss = [_,_,_], listen_zusammen(Xss,Xs),false.
:- Xss = [_,_,_], listen_zusammen(Xss,Xs).	

listen_zusammen(Xss,Xs) :-
	phrase(seqq(Xss),Xs.
	
seqq([]) -->
	[].
seqq([Xs|Xss]) -->
	seq(Xs),
	seqq(Xss).
	
46)
	
	
zahlenpaar(par(X,Y)) :-
	natürlichezahlsx(X),
	natürlichezahlsx(Y).
	
zahlenpaarD(paar(X,Y)) :-
	natürlichezahlsx(Z),
	nat_nat_summe(X, Y, Z),
	natürlichezahlsx(X),
	natürlichezahlsx(Y).

48)

:- phrase(basen,A).
:/-& phrase(basen,A),false.

:- Bs = [_,_,_,_,_], phrase(basen,Bs).
:/- Bs = [_,_,_,_,_], phrase(basen,Bs),false.

:/- phrase(basen, "ACHTAA").
	
basen -->
	[].
basen -->
	base,
	basen.
	
base -->
	"A".
base -->
	"C".
base -->
	"T".
base -->
	"G".
	
49)

:- phrase(tandemrepeat(Xs), Bs).
:/-& phrase(tandemrepeat(Xs), Bs),false.
	

tandemrepeat(Xs) -->
	{Xs = [_|_]},
	seq(Xs),
	seq(Xs).
	
substr_tandemrepeat(Xs) -->
	seq(_),
	tandemrepeat(Xs),
	seq(_).
	
50)

:- phrase(komplseq(Cs),Bs).
:/-& phrase(komplseq(Cs),Bs),false.

komplseq([]) -->
	[].
komplseq([C|Cs]) -->
	komplseq(Cs),
	{base_kompl(C,B)},
	[B].

base_kompl('A','T').
base_kompl('T','A').
base_kompl('C','G').
base_kompl('G','C').

einfachschleife_ (Cs,Ks) -->
	{Cs = [_,_,_|]},
	{Ks = [_,_,_|]},
	seq(Cs),
	seq(Ks),
	komplseq(Cs).


51)

:- ist_faltung(Fs).


53)

:- X = s(s(_)).

:- X #>1.
:- X #>1, X#<5.

:- 1 + 1 #= X.

:- X +Y #= 2.

:- X + X #= 2.
:- F*2 + H*4 #= 24, F+H #= 9.
:- F*2 + H*4 #= 24, F+H #= 9, F #>= 0, H #>= 0.

:- [A,B,C] ins 1..2.
:- [A,B,C] ins 1..2, A #\= B.
:- [A,B,C] ins 1..2, A #\= B, B #\= C, C #\= A.

:- [A,B,C] ins 1..2, labeling_zs([],[A,B,C]).
:- [A,B,C] ins 1..2, A #\= B,labeling_zs([],[A,B,C]).
:- [A,B,C] ins 1..2, A #\= B, B #\= C, C #\= A,labeling_zs([],[A,B,C]).

54)

:- keineelement_vonzs(X,Zs).
:/-& keineelement_vonzs(X,Zs),false.

:- Zs = [_,_,_|_], keineelement_vonzs(X,Zs).
:- Zs = [4711,4711,4711], X= 4712, keineelement_vonzs(X,Zs).
:/- Zs = [4711,4711,4711], X= 4711, keineelement_vonzs(X,Zs).
:/- Zs = [4711|_], X= 4711, keineelement_vonzs(X,Zs).

:/- Zs=[X|_],keineelement_vonzs(X,Zs).

keineelement_vonzs(_X, []).
keineelement_vonzs(X,[Z|Zs]) :-
	X #\= Z.
	keineelement_vonzs(X,Zs).

	
:- zalleunterschiedlich(Xs).
:/- zalleunterschiedlich(Xs),false.

zalleunterschiedlich ([]).
zalleunterschiedlich ([X|Xs]).
	keineelement_von(X,Xs),
	zalleunterschiedlich(Xs).

	
55)

:- buchstabe_wert(B,W).
:/- buchstabe_wert(B,W),false.

buchstabe_wert('M', 1000).
buchstabe_wert('D', 500).
buchstabe_wert('C', 100).
buchstabe_wert('L', 50).
buchstabe_wert('X', 10).
buchstabe_wert('V', 5).
buchstabe_wert('U', 5).
buchstabe_wert('I', 1).
buchstabe_wert(B, 0) :-
	keineelement_von(B,"MDCLXVUI").




:- buchstabe_wert(' ',0).
:- dif(Z1,Z2), buchstabe_wert(Z1, 5), buchstabe_wert(Z2,5).

:- chronogramm_jahr(Chs, J).
:/-& chronogramm_jahr(Chs, J),false.

:- Chs = [_,_,_,_,_], chronogramm_jahr(Chs, J).
:/-$ Chs = [_,_,_,_,_], chronogramm_jahr(Chs, J),false.

chronogramm_jahr([], 0).
chronogramm_jahr([B|Bs], J0) :-
	J0 #>= 0,
	buchstabe_wert(B,W),
	J0 #= W+J1,
	chronogramm_jahr(Bs, J1).


:/- chronogramm_jahr(['X'|_],7).

56)

% X1          X5
% |           |
% X2 -- X4 -- X6
% |           |
% X3          X7
 
:- hrätsel(Xs).
:/- hrätsel(Xs),false.

:- hrätsel_(Xs, Zs).
:/- hrätsel_(Xs, Zs),false.

hrätsel(Xs) :-
	hrätsel_(Xs, Zs),
	labeling_zs([],Zs).
	
hrätsel_(Xs, Zs) ;-
	Xs = [X1,X2,X3,X4,X5,X6,X7],
	Zs = [X1,X2,X4,X5,X6],
	Xs ins 1..7,
	zalleunterschiedlich(Xs),
	X1+X2+X3 #= S,
	X2+X4+X6 #= S,
	X5+X6+X7 #= S.
	
	
Xs = [A,B,C], Xs ins 1..3.
Xs = [A,B,C], Xs ins 1..3, keineelement_vonzs(2,Xs).


:/-$ exptrue(10^3), hrätsel_(Xs,Zs),false.

57)

:- phrase(integer_mitstellen(1,9),Xs).
:-(!) phrase(integer_mitstellen(I,S),Xs). %Fehler

:-(!) phrase(hfigur(Zs),Cs).
:/-(!) phrase(hfigur(Zs),Cs),false.

hfigur([X1,X2,X3,X4,X5,X6,X7]) -->
	integer_mitstellen(X1,2),
	"     ",
	integer_mitstellen(X5,2),
	"\n",
	integer_mitstellen(X2,2),
	"--",
	integer_mitstellen(X4,2).
	"--",
	integer_mitstellen(X6,2),
	"\n",
	integer_mitstellen(X3,2),
	"     ",
	integer_mitstellen(X7,2).

58)

:- phrase(tRNA(Descr),Bs).
:/-& phrase(tRNA(Descr),Bs),false.
	
tRNA(Descr) -->
	{Descr = [frei(F1),bindung(B1, Innerefaltung), frei(F2)]},
	{B1 = [_,_,_|_]},
	{Innerefaltung = [frei(F3),bindung(B2, [frei(L1)]),frei(F4),bindung(B3,[frei(L2)]),frei(F5),bindung(B4,[frei(L3)]),frei(F6)]},
	{B2 = [_,_,_|_]},
	{B3 = [_,_,_|_]},
	{B4 = [_,_,_|_]},
	{L1 = [_,_,_,_,_|_]},
	{L2 = [_,_,_,_,_|_]},
	{L3 = [_,_,_,_,_|_]},
	seq(F1),
	seq(B1),
	seq(F3),
	seq(B2),
	seq(L1),
	komplseq(B2),
	seq(F4),
	seq(B3),
	seq(L2),
	komplseq(B3),
	seq(F5),
	seq(B4),
	seq(L3),
	komplseq(B4),
	seq(F6),
	komplseq(B1),
	seq(F2).
	
	
tRNA(Descr) -->
	{Descr = [frei(F1),bindung(B1, Innerefaltung), frei(F2)]},
	{B1 = [_,_,_|_]},
	{Innerefaltung = [frei(F3),bindung(B2, [frei(L1)]),frei(F4),bindung(B3,[frei(L2)]),frei(F5),bindung(B4,[frei(L3)]),frei(F6)]},
	{B2 = [_,_,_|_]},
	{B3 = [_,_,_|_]},
	{B4 = [_,_,_|_]},
	{L1 = [_,_,_,_,_|_]},
	{L2 = [_,_,_,_,_|_]},
	{L3 = [_,_,_,_,_|_]},
	{Inner = [_,_,_,_,_,_,_,_,_, _,_,_,_,_,_,_,_,_, _,_,_,_,_,_,_,_,_, _,_|_]},
	seq(F1),
	seq(B1),
	%inner(F3,F4,F5,F6,L1,L2,L3,B2,B3,B4),
	seq(Inner),
	komplseq(B1),
	{phrase(inner(F3,F4,F5,F6,L1,L2,L3,B2,B3,B4), Inner)},
	seq(F2).

inner (F3,F4,F5,F6,L1,L2,L3,B2,B3,B4) -->	
	seq(F3),
	seq(B2),
	seq(L1),
	komplseq(B2),
	seq(F4),
	seq(B3),
	seq(L2),
	komplseq(B3),
	seq(F5),
	seq(B4),
	seq(L3),
	komplseq(B4),
	seq(F6).

	
59)

:- magischesquadrat3(M).
:/-$ magischesquadrat3(M),false.

:- magquad(M) <<< magischesquadrat3(M).
:- zahlenbrett(M) <<< magischesquadrat3(M).

:- M = [[2,7,6],[9,5,1],[4,3,8]], magischesquadrat3(M).

magischesquadrat3(M) :-
	magischesquadrat3_(M,Zs),
	labeling_zs([],Zs).

magischesquadrat3_(M, Zs) :-
	M = [[A1,A2,A3],[B1,B2,B3],[C1,C2,C3]],
	Es = [A1,A2,A3,B1,B2,B3,C1,C2,C3],
	Zs = [A1,A2,A3,B1],
	Es ins 1..9,
	zalleunterschiedlich(Es),
	S = 15,
	B2=5,
	A1+A2+A3 #= S,
	B1+B2+B4 #= S,
	C1+C2+C3 #= S,
	A1+B1+C1 #= S,
	A2+B2+C2 #= S,
	A3+B3+C3 #= S,
	A1+B2+C3 #= S,
	C1+B2+A3 #= S.


60)

:- magquad(M) <<< magischesquadrat3nred(M).
:/- magischesquadrat3,false.

magischesquadrat3nred(M) :-
	magischesquadrat3nred_(M,Zs),
	labeling_zs([],Zs).
	
magischesquadrat3nred_(M,Zs) :-
	M = [[A1,_,A3],_,[C1,_,C3]],
	A1 #< A3,
	A1 #< C1,
	A1 #< C3,
	C1 #< A3,
	magischesquadrat3_(M,Zs).
	

61)

:- liste_aufsteigend(Xs,Zs).
:/-& liste_aufsteigend(Xs,Zs),false.
	
	
:- Xs = [_,_,_], liste_aufsteigend(Xs,Zs).
:/- Xs = [_,_,_], liste_aufsteigend(Xs,Zs),false.


:- Zs = [_,_,_], liste_aufsteigend(Xs,Zs).
:/- Zs = [_,_,_], liste_aufsteigend(Xs,Zs),false.

:- Xs = [3,2,1], liste_aufsteigend(Xs,Zs).
:- Xs = [3,2,1], Zs = [1,2,3], liste_aufsteigend(Xs,Zs).

liste_aufsteigend(Xs,Zs) :-
	liste_gleichlang(Xs,Zs).
	phrase(aufsteigend(Xs), Zs).


:- phrase(aufsteigend([3,2,1]), [1,2,3]).

aufsteigend([]) -->
	[].
aufsteigend([X,Xs]) -->
	{xs_x_klgls_grs(Xs,X,Klgls,Grs)},
	aufsteigend(Klgls),
	[X],
	aufsteigend(Grs).

xs_x_klgls_grs([],_X, [],[]).
xs_x_klgls_grs([E|Es], X, [E|Klgls],_) :-
	E #=< X,
	xs_x_klgls_grs(Es,X,Klgls,Grs).
xs_x_klgls_grs([E|Es], X, _,[E|Grs]) :-
	E #> X,
	xs_x_klgls_grs(Es,X,Klgls,Grs).
	
	
64)

:- is_task(T).

:- task_nichtüberschneidend(T1,T2).
:/- task_nichtüberschneidend(T1,T2),false.

task_nichtüberschneidend(T1,T2) :-
	T1 = task(_, B1,D1),
	T2 = task(_,B2,_),
	B1+D1 #=< B2.
task_nichtüberschneidend(T2,T1) :-
	T1 = task(_, B1,D1),
	T2 = task(_,B2,_),
	B1+D1 #=< B2.
	
nichtgleichzeitigetasks([Task|Tasks]) :-
	nichtüberlappend_mittask(Tasks, Task),
	nichtgleichzeitigetasks(Tasks).
	
nichtüberlappend_mittask([], _).
nichtüberlappend_mittask([T|Tasks],Task).
	task_nichtüberschneidend(T,Task),
	nichtüberlappend_mittask(Tasks,Task).
	
65)

:- ressourcenverwendung_plan(RVs, Plan).
:/-& ressourcenverwendung_plan(RVs, Plan),false.
	
ressourcenverwendung_plan([], _ Plan).
ressourcenverwendung_plan([_-Ns|RVs], Plan) :-
	namen_plan_tasks(Ns,Plan,Tasks),
	nichtgleichzeitigetasks(Tasks),
	ressourcenverwendung_plan(RVs, Plan).
	
namen_plan_tasks([],_,[]).
namen_plan_tasks([N|Ns], Plan, [Task|Tasks]) :-
	Task = task(N,_,_),
	liste_el(Plan, Task),
	namen_plan_tasks(Ns, Plan,Tasks).
	
liste_el([E|_], E).
liste_el([E|Es], E) :-
	liste_el(Es,E).
	
66)

:- db_tasks(DB, Tasks).

:- db_ressources(DB, RVs).

:- plangraph(DB-Plan) <<< db_resplan_(DB, Plan, Zs), labeling_zs([], Zs).

:- db_resplan_(DB, Plan, Zs).

db_resplan_(DB, Plan, Zs) :-
	db_tasks(DB, TDDs),
	tdds_plan_zs(TDDs, Plan, Zs),
	Zs ins 0..200,
	db_ressources(DB, RVs),
	ressourcenverwendung_plan(RVs, Plan).

tdds_plan_zs([],[],[]).
tdds_plan_zs([task_descr_duration(N,_,D)|TDDs], [task(N,B,D)|Tasks], [B|Bs]) :-
	tdds_plan_zs(TDDs, Tasks, Bs).
	
	
:/- db_resplan_(DB, Plan, Zs),false.
	

	
67)

:- ist_folgen(Folgen).

:- ist_otyp(OTyp).

:- otyp_folgen_plan(OTyp, Folgen, Plan).
:/-& otyp_folgen_plan(OTyp, Folgen, Plan),false.
	
otyp_folgen_plan(_, [], _).
otyp_folgen_plan(OTyp, [Folge|Folgen], Plan) :-
	otyp_folge_plan(OTyp, Folge, Plan),
	otyp_folgen_plan(OTyp,Folgen,Plan).
	
otyp_folge_plan(MM:BZ1-BZ2, dist(N1,N2,A), Plan) :-
	Task1 = task(N1, B1, D1),
	Task2 = task(N2,B2,D2),
	liste_el(Plan, Task1),
	liste_el(Plan, Task2),
	bz_b_d_z(BZ1, B1, D1, Z1),
	bz_b_d_z(BZ2, B2, D2, Z2),
	mm_z1_z2_a(MM, Z1,Z2,A).
	
bz_b_d_z(a, B, _ , B).
bz_b_d_z(e, B,D,Z) :-
	Z #= B+D.
	
mm_z1_z2_a(min, Z1, Z2, A) :-
	Z1+A #=< Z2.
mm_z1_z2_a(max, Z1, Z2,A) :-
	Z1+A #=> Z2.
	
68)

:-db_plan_max_(DB,Plan,Max, Zs).
:/-db_plan_max_(DB,Plan,Max, Zs),false.

:- brückengraph(DB-Plan) <<< db_plan_max_(DB,Plan,Max, Zs), labeling_zs([],Zs).

:- db_otyp_folgen(DB, OTyp, Folgen).

:- db_otyp_plan(DB, OTyp, Plan).

db_otyp_plan(DB, OTyp, Plan) :-
	db_otyp_folgen(DB, OTyp, Folgen),
	otyp_folgen_plan(OTyp,Folgen,Plan).

db_plan_max_(DB, Plan, Max, Zs) :-
	db_tasks(DB, TDDs),
	tdds_plan_zs(TDDs, Plan, Zs),
	Zs ins 0..200,
	db_ressources(DB, RVs),
	max_ofzs(Max, Zs),
	db_otyp_plan(DB, min:a-a , Plan),
	db_otyp_plan(DB, min:a-e , Plan),
	db_otyp_plan(DB, min:e-a , Plan),
	db_otyp_plan(DB, min:e-e , Plan),
	db_otyp_plan(DB, max:a-a , Plan),
	db_otyp_plan(DB, max:e-a , Plan),
	db_otyp_plan(DB, max:a-e , Plan),
	db_otyp_plan(DB, max:e-e , Plan),
	ressourcenverwendung_plan(RVs, Plan).
	
	
:- max_ofzs(1,[0,1]).

	
69)

:- damen_brettgröße_(Qs,(,Zs), labeling_zs([],Zs).
:- nqueens(Qs) <<< damen_brettgröße_(Qs,8,Zs),labeling_zs([],Zs).
:-$ nqueens(Qs) <<< damen_brettgröße_(Qs,80,Zs),labeling_zs([],Zs).
:-$ nqueens(Qs) <<< damen_brettgröße_(Qs,80,Zs),labeling_zs([ff],Zs).
:-$ nqueens(Qs) <<< damen_brettgröße_(Qs,120,Zs),queenslabeling(Zs).
 
:- vars_twicereordered("abcdefghijklmnopqrtuvwxyz").
%Funktion in Hilfe queenslabeling
 
 
queenslabeling(Vs0)
	vars_twicereordered(Vs0,Vs),
	labeling_zs([ff],Vs).
	
vars_twicereordered(Vars0,Vars) :-
	vars_reordered(Vars0,Vars1),
	vars_reordered(Vars1,Vars).