getErrorIdList([Error|ErrorRest], [Id|IdRest]):-
	(   Error = error(id(Id),_,_,_,_); 
	Error = error(id(Id),_,_,_)),
	getErrorIdList(ErrorRest, IdRest).
getErrorIdList([], []).

% -------------------------------------------test cases for Blatt 5, Aufgabe 4-----------------------------%
% autotest(Result):-findall(TestResult, testcase(_, TestResult), Result).

autotest([Exer|R], [Result|RRest]):- testcase(Exer, Result), autotest(R, RRest).
autotest([], []).

% test predicates which are not implemented according to predefined patterns.

testcase(ExerID, TestResult):-
  atom_concat('exer', ExerID, Exercise),
  findall(Id-RelCounter-R, ( clause(test(Exercise,Id, _SPDecList, _ClauseTypes, _DecMap, _SPPred, _ErrorList, RelCounter),Body), debug(test,'<~w>ID=~w',[Exercise, Id]),(call(time(Body))->R=y; R=n)), TestResult).

test(exer1, dec-1, RelCounter):-
	SPDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Anlagejahr'), ('Arg4', '-', 'number', 'Endbetrag')])],
	diagnose_declaration(1, SPDecList, _DecMap, _ErrorList, RelCounter).

test(exer1, dec-2, RelCounter):-
	SPDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Anlagejahr'), ('Arg3', '+', 'number', 'Zinssatz'), ('Arg4', '-', 'number', 'Endbetrag')])],
	diagnose_declaration(1, SPDecList, _DecMap, _ErrorList, RelCounter).

test(exer0,1, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-NZeit is Zeit-1, zins(Betrag, Satz, NZeit, NEnd), End is NEnd + Satz*Betrag.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,no_pattern_rekursiv, StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1,1, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-zins(Betrag, Satz, NDauer, NEnd),Zeit is 1+NDauer, End is NEnd + Satz*NEnd.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null, StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 2, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-Zeit>1, NeuBetrag is Betrag*(Satz+1), NZeit is Zeit -1, zins(NeuBetrag, Satz, NZeit, End).\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null, StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s8c],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 3, RelCounter):-
	StudentDecList=[(sp, zins, [('A1', '+', 'number', 'Betrag'), ('A2', '+', 'number', 'Satz'), ('A3', '+', 'number', 'Laufzeit'), ('A4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- NeuBetrag is Betrag*(Satz+1), NZeit is Zeit -1, zins(NeuBetrag, Satz, NZeit, End).\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null, StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s8a],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 4, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null, StudentDecList, StudentPred, [basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[pre3a],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 5, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-Zeit>=1,NeuBetrag is Betrag*(Satz+1), NZeit is Zeit -1, zins(NeuBetrag, Satz, NZeit, End).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 6, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- End is Betrag*(Satz+1)^Zeit.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive, nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[s7i1],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 7, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Laufzeit'), ('Arg3', '+', 'number', 'Satz'), ('Arg4', '-', 'number', 'Endbetrag')])],
	SPPred = 'zins(Betrag, Zeit, Satz, End):- End is Betrag*(Satz+1)^Zeit.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, SPPred, [nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 8, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag, Satz, Zeit, End):- End is Betrag*(Satz+1)^3*Zeit.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2, s6g],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 9, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- End is (-Betrag)*(-(Satz-2-Zeit))^Zeit.\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1, no_pattern_rekursiv, StudentDecList, StudentPred, [nonrecursive, nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[hypo1, s7i1, s9a, s9a, s9b, s6c1],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer1-9>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer1, 10, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[pre3a],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 11, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')]),
			(sp, zins_accu, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag'), ('Arg5', '+', 'number', 'Accu')])
		       ],
	StudentPred = 'zins(B, Z, I, BI):- zins_accu(B, Z, I, B, BI).\n zins_accu(_, _, 0, X, X).\n zins_accu(B, Z, I, BI, A):-I>0, I1 is I - 1, A1 is A * (1 + Z), zins_accu(B, Z, I1, BI, A1).\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive, basecase, recursivecase], DecMap, ErrorList, RelCounter).

test(exer1, 12, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-Zeit>0, NZeit is Zeit -1, zins(NeuBetrag, Satz, NZeit, NEnd), End is NEnd*(Satz+1).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter).

test(exer1, 13, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-Zeit>0, zins(Betrag, Satz, NZeit, NEnd), NZeit is Zeit +1, End is NEnd*(Satz+1).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter).

test(exer1, 14, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-Zeit>1, zins(Betrag, Satz, NZeit, NEnd), Zeit is NZeit +1, End is NEnd*(Satz+1).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter).

test(exer1, 15, RelCounter):-
     StudentDecList=[(sp, zins_nr, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
     StudentPred = 'zins_nr(B, C, D, A) :-A is B* (1+C)**D.\n',
     DecMap=[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,1,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,2,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,3,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 16, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
	StudentPred = 'zins(A, _, 0, A).\n zins(B, C, A, F):-A>0, E is A-1, D is B*(1+C), zins(D, C, E, F).\n',
	DecMap =[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 17, ErrorList, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag,Zins,Dauer,Endguthaben):-X is Betrag+Betrag*Zins/100, Dauer>0, DecDauer is Dauer-1, zins(X,Zins,DecDauer,Endguthaben).\n',
	DecMap =[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6b],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 18, RelCounter):-
    StudentDecList=[(sp, zins_nr, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
    StudentPred = 'zins_nr(Betrag,Zins,Dauer,Endguthaben):-Endguthaben is Betrag*(100+Zins)**Dauer/(100**Dauer).\n',
    DecMap =[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,1,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,2,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,3,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,zins_nr,4,zins_nr/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a3, s6f],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer1, 19, RelCounter):-
	StudentDecList=[(sp, b, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
	StudentPred = 'b(A,_,0,A).\n b(A,Z,D,E):-D>0,D_1 is D-1, b(A,Z,D_1,E1), E is E1*(1+Z).\n',
	DecMap =[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,b,4,b/4,main,_,1,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,b,4,b/4,main,_,2,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,b,4,b/4,main,_,3,_,number,_)),
		 map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,b,4,b/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

% b2(A,Z,D,E):-E is A*(1+Z)^D.
test(exer1, 20, ErrorList, RelCounter):-
    StudentDecList=[(sp, b2, [('Arg1','+','number','Betrag'), ('Arg2','+','number','Satz'), ('Arg3','+','number','Laufzeit'), ('Arg4','-','number','Endbetrag')])],
    StudentPred = 'b2(A,Z,D,E):-E is A*(1+Z)^D.\n',
    DecMap =[map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_),predicatedec(sp,b2,4,b2/4,main,_,1,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_),predicatedec(sp,b2,4,b2/4,main,_,2,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_),predicatedec(sp,b2,4,b2/4,main,_,3,_,number,_)),
	     map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_),predicatedec(sp,b2,4,b2/4,main,_,4,_,number,_))],
	diagnose_predicate(1,null,  StudentDecList, StudentPred, [nonrecursive], DecMap, ErrorList, RelCounter).

% -----------------------------------------------exercise 2------------------------%
test(exer2, 1, RelCounter):-
    StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
    StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- End is Betrag*(Satz+1+Zeit)^Satz.\n',
    DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
	      map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
	      map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
	      map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(2,no_pattern_analytisch,  StudentDecList, StudentPred, [nonrecursive, nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[s7i1, s6g1, s9b],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer2-1>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer2, 2, RelCounter):-
    StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
    StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- End is (-Betrag)*(-(Satz-2))^Zeit.\n',
    DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
	      map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
	      map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
	      map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(2,no_pattern_analytisch,  StudentDecList, StudentPred, [nonrecursive, nonrecursive], DecMap, ErrorList, RelCounter),
	Exp_EL=[s7i1, s9a, s9a, s6c1],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer2-2>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

% ------------------------------------------------exercise 3-----------------------%
test(exer3, 1, RelCounter):-
    StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
    StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-2<Zeit, NeuBetrag is Betrag*(Satz+1), NZeit is Zeit -1,zins(NeuBetrag, Satz, NZeit, End).\n',
    DecMap=[map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
	    map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
	    map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
	    map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(3,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s8d],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer3-1>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer3, 2, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):- Zeit>(1), NeuBetrag is Betrag*(Satz+1), NZeit is Zeit -1, zins(NeuBetrag, Satz, NZeit, End).\n',
	DecMap = [map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec, predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(3,no_pattern_endrekursiv,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s8c],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer3, 3, RelCounter):-
	StudentDecList=[(sp, zins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '-', 'number', 'Endbetrag')])],
	StudentPred = 'zins(Betrag,_,0,Betrag).\n zins(Betrag, Satz, Zeit, End):-zins(Betrag, Satz, NDauer, NEnd), Zeit is NDauer+1, End is NEnd + Satz* NEnd.\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,1,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,2,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,3,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,4,tpzins/4,main,_,4,_,number,_), predicatedec(sp,zins,4,zins/4,main,_,4,_,number,_))],
	diagnose_predicate(3,null,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

% ------------------------------------------------exercise 4-----------------------%
% Für diese folgenden Testfälle müssen wir xpce mit mehr Speicher starten: xpce -G64M -L64M
test(exer4, 1, RelCounter):-
	StudentDecList=[(sp, vzins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '+', 'number', 'BonusZins'), ('Arg5', '-', 'number', 'Endbetrag')])],
	StudentPred = 'vzins(Betrag,_,_,0,Betrag).\n vzins(Betrag, Satz, BonusZins, Zeit, End):- Zeit>=1, NeuSatz is Satz+BonusZins, NeuBetrag is Betrag + Satz* Betrag, NeuBonus is BonusZins/2, vzins(NeuBetrag, NeuSatz, NeuBonus, NeuZeit, End).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,1,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,2,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,3,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,4,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,4,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,5,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,5,_,number,_))],
	diagnose_predicate(4, no_pattern_endrekursiv,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s5a, s6b1, s4b4, post5c],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer4-1>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer4, 2, RelCounter):-
	StudentDecList=[(sp, vzins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '+', 'number', 'BonusZins'), ('Arg5', '-', 'number', 'Endbetrag')])],
	StudentPred = 'vzins(Betrag,_,_,0,Betrag).\n vzins(Betrag, Satz, BonusZins, Zeit, End):- Zeit>1, NeuZeit is Zeit-1, NeuSatz is Satz+BonusZins, NeuBetrag is Betrag + Satz* Betrag, NeuBonus is BonusZins/2, vzins(NeuBetrag, NeuSatz, NeuBonus, NeuZeit, End).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,1,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,2,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,3,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,4,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,4,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,5,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,5,_,number,_))],
	diagnose_predicate(4, no_pattern_endrekursiv,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6b1, s8c, s4b4],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer4-2>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer4, a2, ErrorList, RelCounter):-
	StudentDecList=[(sp, vzins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '+', 'number', 'BonusZins'), ('Arg5', '-', 'number', 'Endbetrag')])],
	StudentPred = 'vzins(Betrag,_,_,0,Betrag).\n vzins(Betrag, Satz, BonusZins, Zeit, End):- Zeit>1, NeuZeit is Zeit-1, NeuSatz is Satz+BonusZins, NeuBetrag is Betrag*(Satz+1), NeuBonus is BonusZins/2, vzins(NeuBetrag, NeuSatz, NeuBonus, NeuZeit, End).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,1,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,2,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,3,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,4,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,4,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,5,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,5,_,number,_))],
	diagnose_predicate(4, no_pattern_endrekursiv,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter).

% a positive testcase
test(exer4, 3, RelCounter):-
	StudentDecList=[(sp, vzins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '+', 'number', 'BonusZins'), ('Arg5', '-', 'number', 'Endbetrag')])],
	StudentPred = 'vzins(Betrag,_,_,0,Betrag).\n vzins(Betrag, Satz, BonusZins, Zeit, End):- Zeit>0, NeuSatz is Satz+BonusZins, NeuBetrag is Betrag + Satz* Betrag, NeuBonus is BonusZins/2, vzins(NeuBetrag, NeuSatz, NeuBonus, NeuZeit, End).\n',
	DecMap = [map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,1,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,1,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,2,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,2,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,3,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,3,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,4,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,4,_,number,_)),
		  map(dec,predicatedec(tp,tpzins,5,tpzins/5,main,_,5,_,number,_),predicatedec(sp,vzins,5,vzins/5,main,_,5,_,number,_))],
	diagnose_predicate(4, no_pattern_endrekursiv,  StudentDecList, StudentPred, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s5a, s6b1, s4b4, post5c],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer4, dec1, RelCounter):-
	SPDecList = [(sp, vzins, [('Arg1', '+', 'number', 'Betrag'), ('Arg2', '+', 'number', 'Satz'), ('Arg3', '+', 'number', 'Laufzeit'), ('Arg4', '+', 'number', 'BonusZins'), ('Arg5', '-', 'number', 'Endbetrag')])],
	diagnose_declaration(4, SPDecList, _DecMap, ErrorList, RelCounter),
	Exp_EL = [error(id(d5),_,_,_), error(id(d5),_,_,_), error(id(d5),_,_,_)],
	Exp_EL=ErrorList.

test(exer4, dec2, RelCounter):-
	SPDecList = [(sp, vzins, [('Arg1', '+', 'number', 'GeldBetrag'), ('Arg2', '+', 'number', 'Basiszins'), ('Arg3', '+', 'number', 'Bonuszins'), ('Arg4', '+', 'number', 'Anlagejahr'), ('Arg5', '-', 'number', 'Endguthaben')])],
	diagnose_declaration(4, SPDecList, _DecMap, ErrorList, RelCounter),
	Exp_EL = [],	
	Exp_EL=ErrorList.	

% -------------------test caes for Blatt 6 - Aufgabe 1.1 -----------------------------------------%
test(exer5, 1, RelCounter):-
    StudentDecList = [(sp, mylast, [('Arg1', '?', 'list', 'Liste'), ('Arg2', '?', 'any_type', 'Element')])],
    StudentPredicate = 'mylast([_|T], E):- mylast(T,E).\n mylast([X,_],X).\n',
    DecMap=[map(dec,predicatedec(tp,tplast,2,tplast/2,main,_,1,_,list,_),predicatedec(sp, mylast,2,mylast/2,main,_,1,_,list,_)),
	    map(dec,predicatedec(tp,tplast,2,tplast/2,main,_,2,_,any_type,_),predicatedec(sp,mylast,2,mylast/2,main,_,2,_,any_type,_))],
    diagnose_predicate(5, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
    Exp_EL=[s1f],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.    

% -------------------test caes for Blatt 6 - Aufgabe 1.2 -----------------------------------------%
test(exer6, 1, RelCounter):-
	StudentDecList = [(sp, 'summe', [('Summe', '-', 'number', 'Summe'), ('Liste', '+', 'list', 'List')])],
	StudentPredicate = 'summe(EndSum, [H|T]):-summe(S, T), EndSum is H+S.\n summe(0, []).\n',	
	DecMap = [map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,2,-,number,_), predicatedec(sp,summe,2,summe/2,main,_,1,-,number,_)),	
		  map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,1,+,list,[_]), predicatedec(sp,summe,2,summe/2,main,_,2, +, list,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer6, 2, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), H=S.\n sum([],0).\n',
	DecMap = [map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,2,_,number,_),predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))], 
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s5a, s4f, post5c],	
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-2>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 3, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), X is (H - S1)*H.\n sum([],0).\n',
	DecMap = [map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s5a, s9a, s6a2, s4b1, post5b, post5c],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-3>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 4, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], R):- sum(T,S1), S is (H - S1)*X.\n sum([],0).\n',
	DecMap = [map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_, 1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_, 2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s5a, s9a, s6a2, s6a2, s4b1, post5b, post5c, post5c, post7b],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-4>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 5, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is (H + S1)*T.\n sum([],0).\n',
	DecMap = [map(dec,predicatedec(tp,tpsum,2,_,_,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec,predicatedec(tp,tpsum,2,_,_,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2, s6a2],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer6, 6, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is (H + S1)*H.\n sum([],0).\n',
	DecMap = [map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer6, 7, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is (S1/2 + H)*4.\n sum([],0).\n',
	DecMap = [map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp, sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp, sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2, s6a3, s6b],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

% test s5e, 6c1 check multiplicants which are numbers
test(exer6, 8, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is (S1/S1 + H)*3.\n sum([],0).\n',	
	DecMap = [map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_, 1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec, predicatedec(tp, tpsum,2,tpsum/2,main,_, 2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2, s6a3, s6b],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

% test check multiplicants which are missing
test(exer6, 9, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is  H*3.\n sum([],0).\n',	
	DecMap = [map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec,predicatedec(tp, tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s9b1, s6a2, post5c],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-9>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 10, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T], S):- sum(T,S1), S is  S1/3+H*3+H/S1.\n sum([],0).\n',
	DecMap = [map(dec,predicatedec(tp,tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec,predicatedec(tp,tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase], DecMap, ErrorList, RelCounter),
	Exp_EL=[s9b, s6a2, s6a3, s6b],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer6, 11, ErrorList, RelCounter):-
	StudentDecList = [(sp, sum, [('Arg1', '+', 'list', 'Liste'), ('Arg2', '-', 'number', 'Summe')])],
	StudentPredicate = 'sum([H|T],Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n sum(Arg1,Summe):-Summe is S+H, sum(T,S).\n',	
	DecMap = [map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,1,_,list,_), predicatedec(sp,sum,2,sum/2,main,_,1,_,list,_)),
		  map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,2,_,number,_), predicatedec(sp,sum,2,sum/2,main,_,2,_,number,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, recursivecase,recursivecase,recursivecase,recursivecase,recursivecase,recursivecase,recursivecase,recursivecase,recursivecase], DecMap, ErrorList, RelCounter).

% check unknown subgoal
test(exer6, 12, RelCounter):-
	StudentDecList = [(sp, 'summe', [('Liste', '+', 'list', 'List'), ('Summe', '-', 'number', 'Summe')])],
	StudentPredicate = 'summe([H|T], EndSum):-summe(T,S1), EndSum is  H*3+T.\n summe([],0).\n',	
	DecMap = [map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,2,-,number,_), predicatedec(sp,summe,2,summe/2,main,_,2,-,number,_)),	
		  map(dec, predicatedec(tp,tpsum,2,tpsum/2,main,_,1,+,list,[_]), predicatedec(sp,summe,2,summe/2,main,_,1, +,list, _))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase],DecMap, ErrorList, RelCounter),
	Exp_EL=[s6a2, s6b1, post5c],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-12>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 13, RelCounter):-
	StudentDecList = [(sp, 'summe', [('Summe', '-', 'number', 'Summe'), ('Liste', '+', 'list', 'List')])],
	StudentPredicate = 'summe(EndSum, [H|T]):-summe(H, T), EndSum is H+T.\n summe(0, []).\n',	
	DecMap = [map(dec,predicatedec(tp,tpsum,2,tpsum/2,main,_,2,-,number,_), predicatedec(sp,summe,2,summe/2,main,_,1,-,number,_)), 
		  map(dec,predicatedec(tp,tpsum,2,tpsum/2,main,_,1, +,list,[_]), predicatedec(sp,summe,2,summe/2,main,_,2,+,list,_))],
	diagnose_predicate(6, null, StudentDecList, StudentPredicate, [recursivecase, basecase],DecMap, ErrorList, RelCounter),
	Exp_EL=[s6b1, s4a],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer6-13>ErrorID=~w',[EIDL]),
	Exp_EL=EIDL.

test(exer6, 14, DecMap, ErrorList, RelCounter):-
	SPDecList = [(sp, sum, [('Arg2', '-', 'number', 'Summe'), ('Arg1', '+', 'list', 'Liste')])],
	diagnose_declaration(6, SPDecList, DecMap, ErrorList, RelCounter).
% ----------------------------------------- test cases for Blatt 6 - Aufgabe 2-------------------------------------%
% we do not have a map for declaration of accu predicates
test(exer7, 1, RelCounter):-
 SPDecList=[(sp, mylength, [('Liste', '+', 'list', 'Liste'), ('Laenge', '-', 'number', 'Laenge')]),
	       (sp, accu_length, mylength/2, accu, [('Liste', '+', 'list', 'Liste'), ('Laenge', '-', 'number', 'Laenge'), ('Accu', '+', 'number', 'Accu')])],
 SPPredicate = 'mylength(Liste,Laenge):- accu_length(Liste,Laenge, 0).\n accu_length([],L,L).\n accu_length([_|R],L, N):-N>=0, N1 is N+1, accu_length(R,L, N1).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_),predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	 map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_)),
	 map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,1,_,list,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,1,_,list,_)),
	 map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,2,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,2,_,number,_)),
	 map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,3,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,3,_,number,_))],
    diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [nonrecursive, basecase, recursivecase], DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer7-1>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

% we do not have a map for declaration of accu predicates
test(exer7, 2, RelCounter):-
 SPDecList=[(sp, mylength, [('Liste','+','list','Liste'), ('Laenge','-','number','Laenge')]),
    (sp,accu_length,mylength/2,accu,[('Liste','+','list','Liste'),('Laenge','-','number','Laenge'),('Accu','+','number','Accu')])],
 SPPredicate = 'mylength(Liste,Laenge):- accu_length(Liste,Laenge,0).\n accu_length([],L,L).\n accu_length([_|R],L,N):-N>(-1), N1 is N+1, accu_length(R,L, N1).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_), predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_)),
	map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,2,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,2,_,number,_)),
	map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,3,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,3,_,number,_))],
	diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [nonrecursive, basecase, recursivecase],DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  Exp_EL=EIDL.

% we do not have a map for declaration of accu predicates
test(exer7, 3, RelCounter):-
 SPDecList = [(sp, mylength, [('Liste', '+', 'list', 'Liste'), ('Laenge', '-', 'number', 'Laenge')])],
 SPPredicate = 'mylength([_|R], Laenge):- mylength(R, Rest).\n mylength([],0).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_),predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_))],
 diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [recursivecase, basecase],DecMap, ErrorList, RelCounter),
 Exp_EL=[hypo1, s5a, post5b, post5c],
 getErrorIdList(ErrorList, EIDL),
 debug(test, '<exer7-3>EIDL=~w',[EIDL]),
 Exp_EL=EIDL.

% we do not have a map for declaration of accu predicates
test(exer7, 4, RelCounter):-
 SPDecList = [(sp, mylength, [('Liste', '+', 'list', 'Liste'), ('Laenge', '-', 'number', 'Laenge')])],
 SPPredicate = 'mylength([],0).\n mylength([H|T],L):-mylength(T, L1), L is L1+1.\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_), predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
       map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_), predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_))],
 diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [basecase, recursivecase], DecMap, ErrorList, RelCounter),
 Exp_EL=[hypo1, t5b, post5a],
 getErrorIdList(ErrorList, EIDL),
 debug(test, '<exer7-4>EIDL=~w',[EIDL]),
 Exp_EL=EIDL.

% we do not have a map for declaration of accu predicates
test(exer7, 5, RelCounter):-
 SPDecList=[(sp, mylength, [('Liste','+','list','Liste'), ('Laenge','-','number','Laenge')]),
    (sp,accu_length,mylength/2,accu,[('Liste','+','list','Liste'),('Laenge','-','number','Länge'),('Accu','+','number','Accu')])],
 SPPredicate = 'mylength(Liste,Laenge):- accu_length(Liste,Laenge,0).\n accu_length([],0,L).\n accu_length([_|R],L,N):-N>(-1), N1 is N+1, accu_length(R,L, N1).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_), predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_)),
	map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,2,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,2,_,number,_)),
        map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,3,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,3,_,number,_))],
 diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [nonrecursive, basecase, recursivecase],DecMap, ErrorList, RelCounter),
 Exp_EL=[pa5, s7k, post5b], 
 getErrorIdList(ErrorList, EIDL),
 debug(test, '<exer7-5>EIDL=~w',[EIDL]),
 Exp_EL=EIDL.

test(exer7, 6, RelCounter):-
 SPDecList=[(sp, mylength, [('Liste','+','list','Liste'), ('Laenge','-','number','Laenge')]),
    (sp,accu_length,mylength/2,accu,[('Liste','+','list','Liste'),('Laenge','-','number','Länge'),('Accu','+','number','Accu')])],
 SPPredicate = 'mylength(Liste,Laenge):- accu_length(Liste,Laenge,0).\n accu_length([],L,L).\n accu_length([_|R],L,N):- N>=0, N1 is N+1, accu_length(R,L, N).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_), predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_)),
	map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,2,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,2,_,number,_)),
        map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,3,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,3,_,number,_))],
 diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [nonrecursive, basecase, recursivecase],DecMap, ErrorList, RelCounter),
 Exp_EL=[s5a, s4a1, s4b4, post5c],
 getErrorIdList(ErrorList, EIDL),
 Exp_EL=EIDL.

test(exer7, 7, RelCounter):-
 SPDecList=[(sp, mylength, [('Liste','+','list','Liste'), ('Laenge','-','number','Laenge')]),
    (sp,accu_length,mylength/2,accu,[('Liste','+','list','Liste'),('Laenge','-','number','Laenge'),('Accu','+','number','Accu')])],
 SPPredicate = 'mylength(Liste,Laenge):- accu_length(Liste,Laenge,0).\n accu_length([],L,L).\n accu_length([_|R],L,N):- N>=0, N1 is N+1, accu_length(R,R, N1).\n',
 DecMap=[map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,1,_,list,_), predicatedec(sp,mylength,2,mylength/2,main,_,1,_,list,_)),
	map(dec,predicatedec(tp,tplength,2,tplength/2,main,_,2,_,number,_),predicatedec(sp,mylength,2,mylength/2,main,_,2,_,number,_)),
	map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,2,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,2,_,number,_)),
        map(dec,predicatedec(tp,tpaccu_length,3,tplength/2,accu,_,3,_,number,_),predicatedec(sp,accu_length,3,mylength/2,accu,_,3,_,number,_))],
 diagnose_predicate(7, 'process_all_accu', SPDecList, SPPredicate, [nonrecursive, basecase, recursivecase],DecMap, ErrorList, RelCounter),
 Exp_EL=[pa8, s3d, s4d, post5b],
 getErrorIdList(ErrorList, EIDL),
 debug(test, '<exer7-7>EIDL=~w',[EIDL]),
 Exp_EL=EIDL.

test(exer7, dec1, RelCounter):-
 SPDecList = [(sp, mylength, [('Liste', '+', 'list', 'List'), ('Laenge', '-', 'number', 'LALALA')]),
   (sp,accu_length, mylength/2, accu, [('Liste','+','list','Liste'), ('Länge','-','number','Laenge'),('Accu','+','number','Akku')])],
 diagnose_declaration(7, SPDecList, _DecMap, ErrorList, RelCounter),
 Exp_EL=[d5],
 getErrorIdList(ErrorList, EIDL),
 Exp_EL=EIDL.

% This needs to be checked on the interface layer.
test(exer7, dec2, DecMap, ErrorList, RelCounter):-	
	diagnose_declaration(7, [predicatedec(sp, '', 1, ''/1, main,'', 1, +, number,'')], DecMap, ErrorList, RelCounter).

test(exer7, dec3, RelCounter):-
	SPDecList = [(sp, mylength, [('Laenge', '-', 'number', 'Laenge'), ('Liste', '+', 'list', 'HIHIHI')])],
	diagnose_declaration(7, SPDecList, _DecMap, ErrorList, RelCounter),
	Exp_EL=[d5],	
	getErrorIdList(ErrorList, EIDL),	
	Exp_EL=EIDL.

test(exer7, dec4, RelCounter):-	
    diagnose_declaration(7, [(sp, 'my_length', [('List', '+', 'list', 'Liste'), ('Length', '-', 'number', 'Laenge'), ('Arg', '+', 'number', 'XXX')]), (sp, 'accu_my_length', my_length/3, accu, [('List', '+', 'list', 'Liste'), ('Length', '-', 'number', 'Laenge'), ('Accu', '+', 'number', 'Akku')])], _DecMap, ErrorList, RelCounter),
    Exp_EL=[d2b],
    getErrorIdList(ErrorList, EIDL),  
    Exp_EL=EIDL.

test(exer7, dec5, RelCounter):-
    SPDecList = [(sp, mylength, [('Laenge', '+', 'number', 'Liste')])],
    diagnose_declaration(7, SPDecList, _DecMap, ErrorList, RelCounter),
    Exp_EL=[d2a,d3],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

%-------------------------exercise Probeklausur1-----------------------------%
/** Exercise 5c - 
WS99/00b - 39 Teilnehmer, Informatiker+WI
10 Solutions ; 10 understanables, 0 incorrectly analysed
Gegeben sei die Liste der Zuschauerzahlen eines Tages für eine Reihe von Fernsehprogrammen. Für jede Sendung enthält die Liste eine Teilliste mit den Angaben zu Sender, Titel der Sendung und Zuschauerzahl (in Tausend), wobei die Eintragungen zu den Sendungen nach fallender Zuschauerzahl sortiert sind. Die Gesamtliste sei als Argument des einstelligen Prädikats zuschauer/1 in der Datenbasis des prolog-Systems abgespeichert: zuschauer([[ard, goldmelodie, 5300], [rtl, blutrausch, 4200], [sat1, ran_an_die_bouletten, 3500], [ottifanten_kanal, greif_denzaster, 3300], ..., [arte, spannende_wissenschaft, 3]]). <br> Definieren Sie ein Prädikat, das aus der einer gegebenen Gesamtliste mit Zuschauerzahlen eine neue Liste berechnet, die nur die Angaben für die Sendungen eines bestimmten, aber frei wählbaren Senders enthält. Die ursprüngliche Sortierreihenfolge soll bei der Berechnung nicht verändert werden. Hinweis: der Operator zur Negation eine Unifikation ist: Term1 \\= Term2 */
/**
test(exer8, dec1):-
	SPDecList=[(sp,mysenderlist,[('A1','+','list','Gesamtliste'),('A2','+','atom','Sender'),('A3','-','list','Liste')])],
	diagnose_declaration(8, SPDecList, _DecMap, ErrorList),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer8, dec2):-	
    SPDecList=[(sp, sender,[('A1','+','atom','Sender'), ('A2','+','list','GesamtListe'), ('A3','-','list','Liste')])],
    diagnose_declaration(8, SPDecList, _DecMap, ErrorList),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer8, dec3):-	
	SPDecList=[(sp, einsender,[('A1','+','list','GesamtListe'), ('A2','+','atom','Sender'), ('A3','-','list','Liste')])],
	diagnose_declaration(8, SPDecList, _DecMap, ErrorList),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.

test(exer8, dec4):-	
	SPDecList=[(sp, sender,[('A1','+','list','GesamtListe'), ('A2','-','list','Liste'), ('A3','+','atom','Sender')])],
	diagnose_declaration(8, SPDecList, _DecMap, ErrorList),
	Exp_EL=[],
	getErrorIdList(ErrorList, EIDL),
	Exp_EL=EIDL.*/

% not/1 is removed from SWI. \+/1 should be used instead

test(exer8, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-   
    DecMap = [map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, list, 'GesamtListe'))],  
    SPDecList=[declaration(sp,sender,[d('A1','+','atom','Sender'),d('A2','+','list','GesamtSenderListe'),d('A3','-','list','Liste')])], 
    SPPred = 'sender(_,[],[]).\n sender(GSender,[AktS|Rest],[AktS|GSRest]):-AktS=[GSender,_,_],sender(GSender,Rest,GRest).\n sender(GSender,[AktS|Rest],GSRest):-not(AktS=[GSender,_,_]),sender(GSender, Rest, GSRest).\n',  
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),   
    % Exp_EL=[s3a, s3c, s1d2, post5a, post5c],
    Exp_EL=[g7],   
    getErrorIdList(ErrorList, EIDL),    
    Exp_EL=EIDL.
/**
test(exer8, add1,  SPDecList, ClauseTypes, DecMap, SPPred, ErrorList):-
    DecMap = [map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp,sender,[d('A1','+','atom','Sender'),d('A2','+','list','GesamtSenderListe'),d('A3','-','list','Liste')])],
    SPPred = 'sender(_,[],[]).\n sender(GSender,[AktS|Rest],[AktS|GSRest]):-AktS=[GSender,_,_],sender(GSender,Rest,GRest).\n sender(GSender,[AktS|Rest],GSRest):-(\\+AktS=[GSender,_,_]),sender(GSender, Rest, GSRest).\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList),
    % Exp_EL=[s3a, s3c, s1d2, post5a, post5c],   
    Exp_EL=[g7],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-1>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.
*/

test(exer8, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), 
	    map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, atom, 'Sender')), 
	    map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp, sender,[d('A1','+','atom','Sender'),d('A2','+','list','GesamtSenderListe'),d('A3','-','list','Liste')])],
    SPPred='sender(_,[],[]).\n sender(X, [[X,Y,Z]|T], [[X,Y,Z]|H]):-zuschauer([[X,Y,Z]|T]), sender(X,T,H).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[g7],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-2>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

% It seems that input from JAVA will not contain syntax error any more because we use the method is_valid_sourcetext to check input
/** 4/4 Punkte. Wir tolerieren Rechtschreibfehler in Send=Program
sender(Program, Ergebnis):- einsender(Zuschauer, Program, Ergebnis).
Einsender([], _, []).
Einsender([[Prog, Send, Zahl]|RZuschauer], Programm, [[Prog, Send, Zahl], RErg]):- Send=Program, einsender(RZuschauer, Programm, RErg).
Einsender([[Prog, Send, Zahl]|RZuschauer], Programm, RErg):- Send/== Programm, einsender(RZuschauer, Programm, RErg).*/
test(exer8, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, einsender, 3, einsender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, einsender, 3, einsender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, einsender, 3, einsender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp, einsender,[d('A1','+','list','GesamtListe'), d('A2','+','atom','Sender'), d('A3','-','list','Liste')])],
    SPPred='einsender([], _, []).\n einsender([[Prog, Send, Zahl]|RZuschauer], Programm, [[Prog, Send, Zahl], RErg]):-Send = Programm, einsender(RZuschauer, Programm, RErg).\n einsender([[Prog, Send, Zahl]|RZuschauer], Programm, RErg):-Send\\== Programm, einsender(RZuschauer, Programm, RErg).\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s1d2, post5a, post5a, s1f, s1d2],    
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-3>EIDL=~w',[EIDL]),   
    Exp_EL=EIDL.
    % ErrorList = [error(id(syntax), penalty(1), poslist([]), hint('Ihre Eingabe hat Syntaxfehler. Der Prolog-Kompiler sagt: operator_expected'), _)].

test(exer8, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, zusch_sender, 3, zusch_sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, zusch_sender, 3, zusch_sender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, zusch_sender, 3, zusch_sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
   SPDecList=[declaration(sp, zusch_sender,[d('A1','+','list','GesamtListe'),d('A2','+','atom','Sender'),d('A3','-','list','Liste')])],
   SPPred='zusch_sender([], _, []).\n zusch_sender([[Sender, X,Y]|Rest], Sender, [[Sender, X,Y]|Rest2]):- zusch_sender(Rest, Sender, Rest2).\n',
   ClauseTypes=[basecase, recursivecase],
   diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes,DecMap, ErrorList, RelCounter),
   Exp_EL=[s7h],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-4>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.	

test(exer8, 5, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
   SPDecList=[declaration(sp, sender,[d('A1','+','list','GesamtListe'), d('A2','+','atom','Sender'), d('A3','-','list','Liste')])],
   SPPred='sender([],_,[]).\n sender([X|Y],XX,Z):-X=[XX|T], sender([Y],XX,Z).\n sender([[XX|T]|Y],XX,[X]).\n',
   ClauseTypes=[basecase, recursivecase, basecase],
   diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s7h, s7i, s1e, s3a, s10a, post5c],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-5>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.	

test(exer8, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sendung_von_sender, 3, sendung_von_sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sendung_von_sender, 3, sendung_von_sender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sendung_von_sender, 3, sendung_von_sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
   SPDecList=[declaration(sp, sendung_von_sender,[d('A1','+','list','GesamtListe'),d('A2','+','atom','Sender'),d('A3','-','list','Liste')])],
   SPPred='sendung_von_sender([],_,[]).\n sendung_von_sender([[Y,Send|Zahl]|T],Y,[Send,Zahl|R1]):-sendung_von_sender(T,Y,R1).\n',
   ClauseTypes=[basecase, recursivecase],
   diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s7h, s1a2, s1f,s1f],  
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-6>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.	

test(exer8, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
   SPDecList=[declaration(sp, sender,[d('A1','+','list','GesamtListe'), d('A2','-','list','Liste'), d('A3','+','atom','Sender')])],
   SPPred='sender([], [], _).\n sender([X|Y], [[A|B]|Z], Sender):- [A|B]=X, A=Sender, sender(Y,Z,Sender).\n',
   ClauseTypes=[basecase, recursivecase],
   diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s7h, s1e],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-7>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

test(exer8, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp, sender,[d('A1','+','list','GesamtListe'), d('A2','+','atom','Sender'), d('A3','-','list','Liste')])],
    SPPred='sender([], _,[]).\n sender(zuschauer([X|Y]), Sender, [A|B]):- [Sender|_]=X, X=A, sender(Y,Sender,B).\n sender(zuschauer([X|Y]), Sender, [B]):-sender(Y,Sender, B).\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[pre2c, pre2c],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-8>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

% TODO: [F|RST] causes error s1f because in semantic table [F,_,_]. Not the same structure
test(exer8, 9, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, neu, 3, neu/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, neu, 3, neu/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, neu, 3, neu/3, main, 'A1', 1, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp, neu,[d('A1','+','list','GesamtListe'), d('A2','+','atom','Sender'), d('A3','-','list','Liste')])],
    SPPred='neu(_,_,[]).\n neu([], N, []).\n neu([[F|RST]|Alt], N, [[F|RST]|Neu]):- N2 is N-1, neu(Alt, N2, Neu).\n neu([_|Alt], N, [_|Neu, F]):- neu(Alt, N2, Neu), N2 is N-1.\n',
    ClauseTypes=[basecase, basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes,DecMap, ErrorList, RelCounter),
    Exp_EL=[s7k,s7i, s1a2,s1g, s3d, s3d, s5b, s10a, post5a, s1f, s3d, s5b, post5b], 
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-9>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

test(exer8, 10, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
    SPDecList=[declaration(sp, sender,[d('A1','+','list','GesamtListe'), d('A2','+','atom','Sender'), d('A3','-','list','Liste')])],
    SPPred='sender([], _,[]).\n sender([H|T], S, [H|X]):-H=[S,_,_], sender(T, S,X).\n sender([H|T], S,X):-H\\= [S, _,_], sender(T, S,X).\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(8, null, SPDecList, SPPred, ClauseTypes,DecMap, ErrorList, RelCounter),    
    Exp_EL=[s1a2, s10c, s4a],  
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer8-10>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

%---------additional testcases------------------%
/**
test(exer8, add1):-
   SPDecList=[(sp, mysenderlist, [('A1','+','list','Gesamtliste'), ('A2','+','atom','Sender'), ('A3','-','list','Liste')])],
   SPPredicate = 'mysenderlist([],_,[]).\n mysenderlist([H|T],SN,[H|T1]):-H=[SN,_,_], mysenderlist(T, SN,T1).\n mysenderlist([H|T],SN, T1):-H=[SN1,_,_], SN\\=SN1, mysenderlist(T,SN,T1).\n',
   DecMap = [map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A1', 1, +, list, 'Gesamtliste'))],
   diagnose_predicate(8, null, SPDecList, SPPredicate, [basecase, recursivecase, recursivecase], DecMap, ErrorList),  
   Exp_EL=[],
   getErrorIdList(ErrorList, EIDL),
   Exp_EL=EIDL.

test(exer8, add2):-
   SPDecList=[(sp, mysenderlist, [('A1','+','list','Gesamtliste'), ('A2','+','atom','Sender'), ('A3','-','list','Liste')])],
   SPPredicate = 'mysenderlist([],_,[]).\n mysenderlist([H|T],SN,[H|T1]):-H=[SN,_,_,_], mysenderlist(T, SN,T1).\n mysenderlist([H|T],SN, T1):-H=[SN1,_,_], SN=SN1, mysenderlist(T,SN,T1).\n',
   DecMap = [map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A1', 1, +, list, 'Gesamtliste'))],
   diagnose_predicate(8, null, SPDecList, SPPredicate, [basecase, recursivecase, recursivecase], DecMap, ErrorList),   
   Exp_EL=[s1e, s10a, s4f],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-10>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.
  
test(exer8, add3):-
    SPDecList=[(sp, mysenderlist, [('A1','+','list','Gesamtliste'), ('A2','+','atom','Sender'), ('A3','-','list','Liste')])],
    SPPredicate = 'mysenderlist([],_,[]).\n mysenderlist([H|T],SN,[H|T1]):-H=[SN,_,A], mysenderlist(T, SN,T1).\n mysenderlist([H|T],SN, T1):-H=[SN1,_,_], SN\\=SN1, mysenderlist(T,SN,T1).\n',
    DecMap = [map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, mysenderlist, 3, mysenderlist/3, main, 'A1', 1, +, list, 'Gesamtliste'))],
    diagnose_predicate(8, null, SPDecList, SPPredicate, [basecase, recursivecase, recursivecase], DecMap, ErrorList),
    Exp_EL=[post5c],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer8, add4):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, list, 'GesamtListe'))],
    SPDecList=[(sp, sender,[('A1','+','atom','Sender'), ('A2','+','list','GesamtSenderListe'), ('A3','-','list','Liste')])],
    SPPredicate='sender(_,[],[]).\n sender(X, [[X,Y,Z]|T], [[X,Y,Z]|H]):-sender(X,T,H).\n',
    diagnose_predicate(8, null, SPDecList, SPPredicate, [basecase, recursivecase],DecMap, ErrorList),   
    Exp_EL=[s7h],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer8, add5):-
    DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, sender, 3, sender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, sender, 3, sender/3, main, 'A1', 1, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, sender, 3, sender/3, main, 'A2', 2, +, list, 'GesamtListe'))],
    SPDecList=[(sp, sender,[('A1','+','atom','Sender'), ('A2','+','list','GesamtSenderListe'), ('A3','-','list','Liste')])],
    SPPredicate='sender(X, [[X,Y,Z]|T], [[X,Y,Z]|H]):-sender(X,T,H).\n sender(_,[],[]).\n',
    diagnose_predicate(8, null, SPDecList, SPPredicate, [recursivecase, basecase],DecMap, ErrorList),
    Exp_EL=[s7h],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.
% wir tolerieren Rechtschreibfehler in Send=Program
test(exer8, add6):-
   DecMap=[map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg3', 3, -, list, ['Liste']), predicatedec(sp, einsender, 3, einsender/3, main, 'A3', 3, -, list, 'Liste')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg2', 2, +, atom, ['Sender']), predicatedec(sp, einsender, 3, einsender/3, main, 'A2', 2, +, atom, 'Sender')), map(dec, predicatedec(tp, tpsenderlist, 3, tpsenderlist/3, main, 'Arg1', 1, +, list, ['Gesamtliste']), predicatedec(sp, einsender, 3, einsender/3, main, 'A1', 1, +, list, 'GesamtListe'))],
   SPDecList=[(sp, einsender,[('A1','+','list','GesamtListe'), ('A2','+','atom','Sender'), ('A3','-','list','Liste')])],
   SPPredicate='einsender([], _, []).\n einsender([[Prog, Send, Zahl]|RZuschauer], Programm, [[Prog, Send, Zahl], RErg]):-Send = Programm, einsender(RZuschauer, Programm, RErg).\n einsender([[Prog, Send, Zahl]|RZuschauer], Programm, RErg):-Send\\== Programm, einsender(RZuschauer, Programm, RErg).\n',
   diagnose_predicate(8, null, SPDecList, SPPredicate, [basecase, recursivecase, recursivecase],DecMap, ErrorList),   
   Exp_EL=[s1f, s1d2, s1d2, post5a, post5a], 
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer8-add6>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.	
*/
%-------------------------exercise Probeklausur 2-----------------------------%
/** 1999, 20 Teilnehmer, Informatiker,
 11 Solutions, 0 not understandable, 1 not correctly analysed: Testcase9
In einer relationalen Datenbank sollen die finanziellen Einnahmen einer Firma verwaltet werden. Die Datenbank sei als Faktensammlung in Prolog implementiert und enthält ausgestellten Rechnungen in der Relation: rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), wobei der Betrag in Deutsche Mark ist. Definieren Sie ein Prädikat rechnung_e/4, das eine Abfrage der Geldbeträge in Euro ermöglicht. Hinweis: 1 Euro entspricht 1,95 Mark.
*/

test(exer9, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Kundennummer'),d('A2','+','number','Rechnungsnummer'),d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    SPPred='rechnung_e(Kundennummer, Rechnungsnummer, Betrage, Datum):-rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), Betrage is Betrag/195*100.\n',
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s6a2, s6d3],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer9, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Kundennummer'), d('A2','+','number','Rechnungsnummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    ClauseTypes=[nonrecursive],
    SPPred='rechnung_e(Knr, Rnr, B_ineuro, D):-B_ineuro is B_inDM*1.95, rechnung(Rnr, Knr, B_inDM, D).\n',
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s6d, post7b],
    getErrorIdList(ErrorList, EIDL),
    
    Exp_EL=EIDL.	

test(exer9, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Kundennummer'), d('A2','+','number','Rechnungsnummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    SPPred='rechnung_e(Kundennummer, Rechnungsnummer, EBetrag, Datum):-rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), EBetrag is Betrag/1.95.\n',
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer9, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Kundennummer'), d('A2','+','number','Rechnungsnummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    SPPred='rechnung_e(KundNr, RechNr, Euro, Datum):-rechnung(RechNr, KundNr, Betrag,Datum), Betrag is Euro/1.95.\n',
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s5a, s6a3, s6e1, s4b1, post7b],
    % [s5a, s6a3, s4b1, post7b]
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<9-4>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

test(exer9, 5, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Kundennummer'), d('A2','+','number','Rechnungsnummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    SPPred='rechnung_e(Kundennummer, Rechnungsnummer, Betrag_e, Datum):-rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), Betrag_e is Betrag/1.95.\n',
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.
/**
test(exer9, 1, DecMap, ErrorList):-	
	SPDecList=[(sp, rechnung_e,[('A1','+','number','Datum'), ('A2','-','number','Euro'), ('A3','+','number','Rechnungsnummer'), ('A4','+','number','Kundennummer')])],
	diagnose_declaration(9, SPDecList, DecMap, ErrorList).
*/

test(exer9, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Datum')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Euro']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Euro')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, +, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Kundennummer'))],
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Datum'), d('A2','-','number','Euro'), d('A3','+','number','Rechnungsnummer'), d('A4','+','number','Kundennummer')])],
    SPPred='rechnung_e(Betrag, Euro, Rnr, Knr):-Zs is Betrag*195, Euro is Zs/100.\n',
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s5b, s6a3, s6d3, post5b, post5b],   
    getErrorIdList(ErrorList, EIDL),
     debug(test, '<9-6>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

test(exer9, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPPred='rechnung_e(Rechnungsnummer, Kundennummer, BetragEuro, Datum):-rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), BetragEuro is Betrag/1.95.\n',
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Rechnungsnummer'), d('A2','+','number','Kundennummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    ClauseTypes= [nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer9, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPPred='rechnung_e(R,K,B,D):-rechnung(R,K,B,D), B is B*1.95.\n',
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Rechnungsnummer'), d('A2','+','number','Kundennummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s6d, s4a1],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

% Misinterpretation of 1,95
test(exer9, 9, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPPred='rechnung_e(Rechnungsnummer, Kundennummer, Betrag_e, Datum):-rechnung(Kundennummer, Kundennummer, Betrag, Datum), Betrag_e = Betrag/1,95.\n',
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Rechnungsnummer'), d('A2','+','number','Kundennummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[g7],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

test(exer9, 10, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
     SPPred='rechnung_e(RechnungsNr, KundenNr, Betrag/1.95, Datum):-rechnung(RechnungsNr, KundenNr, Betrag, Datum).\n',
     SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Rechnungsnummer'), d('A2','+','number','Kundennummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
     ClauseTypes=[nonrecursive],
     diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
     Exp_EL=[pre2e],
     getErrorIdList(ErrorList, EIDL),
     Exp_EL=EIDL.

/** Wir tolerieren die Syntaxfehler ?
SPPredicate='rechnung_e(RNr, KNr, BetragE, Datum):-rechnung(?RNr, ?KNr, ?BetragDM, ?Datum), BetragE is BetragDM*100/1.95.\n',
*/

test(exer9, 11, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kundennummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPPred='rechnung_e(RNr, KNr, BetragE, Datum):-rechnung(RNr, KNr, BetragDM, Datum), BetragE is BetragDM*100/1.95.\n',
    SPDecList=[declaration(sp, rechnung_e,[d('A1','+','number','Rechnungsnummer'), d('A2','+','number','Kundennummer'), d('A3','-','number','Betrag'), d('A4','+','number','Datum')])],
    ClauseTypes=[nonrecursive],
    diagnose_predicate(9, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s6a2],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

/**
test(exer9, add1):-
    DecMap=[map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg1', 1, +, number, ['Kunde']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A1', 1, +, number, 'Kundennummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg2', 2, +, number, ['Rechnungsnummer']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A2', 2, -, number, 'Rechnungsnummer')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg3', 3, -, number, ['Betrag']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A3', 3, -, number, 'Betrag')), map(dec, predicatedec(tp, tprechnung_e, 4, tprechnung_e/4, main, 'Arg4', 4, +, number, ['Datum']), predicatedec(sp, rechnung_e, 4, rechnung_e/4, main, 'A4', 4, +, number, 'Datum'))],
    SPDecList=[(sp, rechnung_e,[('A1','+','number','Kundennummer'), ('A2','+','number','Rechnungsnummer'), ('A3','-','number','Betrag'), ('A4','+','number','Datum')])],
    SPPredicate='rechnung_e(Kundennummer, Rechnungsnummer, Betrage, Datum):-rechnung(Rechnungsnummer, Kundennummer, Betrag, Datum), Betrage is Betrag/1.95.\n',
    diagnose_predicate(9, null, SPDecList, SPPredicate, [nonrecursive], DecMap, ErrorList),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.
*/

%----------------exercise Probeklausur 3: Gehaltsdatenbank-------------------------%
/** 1999, 20 Teilnehmer, Informatiker,
 6 Solutions, 2 not understandable: Testcase 1 uses ";", Testcase4 applies accu. 1 not correctly analysed: misinterpretation of G*1,03 
Eine Gehaltsdatenbank sei als Liste implementiert, wobei jedes ungeradzahlige Listenelement ein Name und jedes geradzahlige Listenelement eine Gehaltsangabe in DM ist, z.B. [meier, 3600, schulze, 5400, mueller, 6300, ..., bauer, 4200]. <br> Definieren Sie ein Prädikat, mit dem für eine gegebene Alt-Gehaltsliste beliebiger Länge eine neue Gehaltsliste berechnet wird, die die folgende Tarifregelung berücksichtigt: <br> 1) alle Gehälter bis einschließlich 5000 Euro werden um 3% angehoben; <br> 2) alle Gehälter oberhalb von 5000 Euro werden um 2% angehoben. Das heisst, das gewünschte Resultat für das oben angegebene Beispiel wäre demnach [meier, 3708, schulze, 5508, mueller, 6426, ..., bauer, 4326]. <br>Hinweis: die Darstellung für 3% und 2% entspricht 0.03 und 0.02 in Prolog.
*/

/**
test(exer10, 1, DecMap, ErrorList):-	
	SPDecList=[(sp, mytrans,[('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_declaration(10, SPDecList, DecMap, ErrorList).*/

/** Plus([], L2, L2).
Testcase1: not understandable due to ; 
Plus(Gehalt, L2, R):-Gehalt=[Kopf|Rest], 
			Rest=[Kopf1|Rest1],
			Kopf1<=5000,
			NKopf1 is Kopf1*1.03,
			plus(Rest1, [L2|Kopf,NKopf1], R]);
			Gehalt=[Kopf|Rest],
			Rest=[Kopf1|Rest1],
			Kopf1 >5000,
			NKopf1 is Kopf1*1.02,
			plus(Rest1, [L2|Kopf,NKopf,R]).*/

% Real testcase
% it interprets G2 is G*1,02 as two subgoals -> misinterpretation
test(exer10, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
    SPPred='gehalt([N,G|R], [N,G2|R2]):-G>5000, G2 is G*1,02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*1,03, gehalt(R,R2).\n',
    SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Liste'), d('A2','-','list','Gehaltsliste')])],
    ClauseTypes=[recursivecase, recursivecase],
    diagnose_predicate(10, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[g7,g7],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.
/**
test(exer10, add2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
    SPPred='gehalt([N,G|R], [N,G2|R2]):-G>5000, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*1.03, gehalt(R,R2).\n',
    SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Liste'), d('A2','-','list','Gehaltsliste')])],
    ClauseTypes=[recursivecase, recursivecase],
    diagnose_predicate(10, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList),
    Exp_EL=[s7g],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer10-add2>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.
*/

test(exer10, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A1', 1, +, list, 'Liste'))],	
    SPDecList=[declaration(sp, gehaelter, [d('A1','+','list','Liste'), d('A2','-','list','Gehaltsliste')])],
    SPPred='gehaelter([],[]).\n gehaelter([K|Xs], [K|Ys]):-odd(K), gehaelter(Xs, Ys).\n gehaelter([K|Xs], [Kb|Ys]):-even(K), K is K*1.03, gehaelter(Xs, Ys).\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(10, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[g7, g7],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer10-3>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

% Testcase4: 
% TODO: Accu approach.
% gehalttarif(Gehaltvorher, Gehaltnachher):-gtacc(Gehaltvorher, [], Gehaltnachher).
% gtacc(GLvor, Acc, GLnach)
% gtacc([GLvorName, GLvorDM|GLvorTail], Acc, GLnach):-gtacc(GLvorTail, [GLvorName,GLneuDM|Acc], GLnach), (GLneuDM is GLvorDM*103/100, Ge% halt<=5000); (GLneuDM is GLvorDM*105/100, Gehalt>5000).

test(exer10, 5, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-    
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt_neu, 2, gehalt_neu/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt_neu, 2, gehalt_neu/2, main, 'A1', 1, +, list, 'Liste'))],	
    SPDecList=[declaration(sp, gehalt_neu, [d('A1','+','list','Liste'), d('A2','-','list','Gehaltsliste')])],    
    SPPred ='gehalt_neu([], []).\n gehalt_neu([N,B|R], E):-B>5000,B is B+B*0.02,gehalt_neu(R,E),E is [N,B|E].\n gehalt_neu([N,B|R], E):-B is B+B*0.03,gehalt_neu(R,E),E is [N,B|E].\n',
    ClauseTypes=[basecase, recursivecase, recursivecase],
    diagnose_predicate(10, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer10-5>EIDL=~w',[EIDL]),
    Exp_EL=[s7e, s7e, s1a, s5b, s1a, s5b, s8a],  
    Exp_EL=EIDL.

/**	SPPredicate = 'gehalt([Name, Gehalt|Rest], [N2,G2|R2]):-Gehalt=<5000.\n',*/
test(exer10, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), 
		    predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), 
	map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), 
		    predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],	
    SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Liste'), d('A2','-','list','Gehaltsliste')])],
    SPPred = 'gehalt([Name, Gehalt|Rest], [N2,G2|R2]):-Gehalt=<5000.\n',
    ClauseTypes=[recursivecase],
    diagnose_predicate(10, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[pre3b],
    getErrorIdList(ErrorList, EIDL),
    Exp_EL=EIDL.

/**
test(exer10, a1, ErrorList):-
	DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
	SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>=5002, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*1.03, gehalt(R,R2).\n',
	SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList).
% OK
test(exer10, a2, ErrorList):-
	DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
	SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>=5001, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*1.03, gehalt(R,R2).\n',
	SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList).
% s8f
test(exer10, a3, ErrorList):-
	DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
	SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>=5002, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G<5001, G2 is G*1.03, gehalt(R,R2).\n',
	SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList).
% s8e, s8f
test(exer10, a4, ErrorList):-
	DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
	SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>=5002, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G<5000, G2 is G*1.03, gehalt(R,R2).\n',
	SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList).
*/

/**
% TODO: This testcase consumes 330.69 sec .
test(exer10, 2):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
    SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>5000, G2 is G*1.02, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*1.03, gehalt(R,R2).\n',
    SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
    diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList),    
    Exp_EL=[s7g],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer10-2>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.
*/
/**
test(exer10, 21, ErrorList):-
	DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
	SPPredicate='gehalt([N,G|R], [N,G2|R2]):-G>5000, G2 is G*0.02+G, gehalt(R,R2).\n gehalt([N,G|R], [N,G2|R2]):-G=<5000, G2 is G*0.03+G, gehalt(R,R2).\n',
	SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
	diagnose_predicate(10, null, SPDecList, SPPredicate, [recursivecase, recursivecase], DecMap, ErrorList).
*/
/**
test(exer10, 3):-
    DecMap=[map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg2', 2, -, list, ['Gehaltsliste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, list, 'Gehaltsliste')), map(dec, predicatedec(tp, tptrans, 2, tptrans/2, main, 'Arg1', 1, +, list, ['Liste']), predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Liste'))],
    SPPredicate='gehalt([N,G], [N,G2]):- G>5000, G2 is G*1.02.\n gehalt([N,G], [N,G2]):- G=<5000, G2 is G*1.03.\n',
    SPDecList=[(sp, gehalt, [('A1','+','list','Liste'), ('A2','-','list','Gehaltsliste')])],
    diagnose_predicate(10, null, SPDecList, SPPredicate, [nonrecursive, nonrecursive], DecMap, ErrorList),
    Exp_EL=[s7g, s7h, s7i1, s7i1],
    getErrorIdList(ErrorList, EIDL),   
    debug(test, '<exer10-3>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.*/

% --------------------------------------------%
/** Exercise 5a - Klausur 2000b, 31.03.2000 (39 Teilnehmer, Informatiker+UI)
% 17 Solutions, 1 not understandable: Testcase9 tends to apply an accu

Gegeben sei die Liste der Zuschauerzahlen eines Tages für eine Reihe von Fernsehprogrammen. Für jede Sendung enthält die Liste eine Teilliste mit den Angaben zu Sender, Titel der Sendung und Zuschauerzahl (in Tausend), wobei die Eintragungen zu den Sendungen nach fallender Zuschauerzahl sortiert sind. Die Gesamtliste sei als Argument des einstelligen Prädikats zuschauer/1 in der Datenbasis des Prolog-Systems abgespreichert:
zuschauer([[ard, goldmelodie, 5300], [rtl, blutrausch, 4200], [sat1, ran_an_die_bouletten, 3500], ...])
Definieren Sie ein Prädikat, das aus einer gegebenen Liste mit Zuschauerzahlen eine neue Liste berechnet, die die N meistgesehenen Sendungen des Tages enthält. In der erzeugten Liste soll die Sendung wiederum durch eine dreielementige Teilliste aus Sender, Titel und Zuschauerzahl beschrieben sein. 
Hinweis: Beachten Sie insbesondere den Fall, bei dem N größer ist als die Länge der gegebenen Liste */
% Musterlösung: anfang(Liste, Laenge, Anfang)
% anfang(L,0,[]).
% anfang([],N,[]):-N>0.
% anfang([H|T],N,[H|R]):-N1 is N-1, anfang(T,N1,R).

/**
test(exer11, 1, DecMap, ErrorList):-	
	SPDecList=[(sp, meist,[('A1','+','number','Datum'), ('A2','-','number','Euro'), ('A3','+','number','Rechnungsnummer'), ('A4','+','number','Kundennummer')])],
	diagnose_declaration(9, SPDecList, DecMap, ErrorList).*/

/** 1/4 Punkte
Meist(N,R), zuschauer([]):-meist(_, [keine Daten mehr]).
Meist(0,_), zuschauer([_]).
Meist(N, [E|R]), zuschauer([E|R1]):-N1 is N-1, meist(N1, R), zuschauer(R1). */
% Eher syntax error, aber wir tolerieren und eliminieren Syntaxfehler
test(exer11, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A3', 3, +, list, 'Liste')), 
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A1', 1, +, number, 'meistgesehenen')),
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A2', 2, -, list, 'Endliste'))
	       ],	
	SPDecList=[declaration(sp, meist, [d('A1','+','number','meistgesehenen'), d('A2','-','list','Endliste'), d('A3','+','list','Liste')])],
	SPPred = 'meist(N,R, zuschauer([])):-meist(_, [keine_daten_mehr]).\n meist(0,_, zuschauer([_])).\n meist(N, [E|R], zuschauer([E|R1])):-N1 is N-1, meist(N1, R, zuschauer(R1)).\n',
	ClauseTypes=[recursivecase, basecase, recursivecase],
	diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
	Exp_EL=[pre2c, pre2c, pre2c, pre3b],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-1>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.
	

/** 3.5/4 Punkte
Most(_, [], [keine_weitere_Sendung]).
Most(1, [Sendung|Rest], [Sendung]).
Most(N, [Sendung|GRest], [Sendung|Rest]):-N1 is N-1, most(N1, GRest, Rest). */

test(exer11, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		    predicatedec(sp, most, 3, most/3, main, 'A2', 2, +, list, 'Liste')), 
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		    predicatedec(sp, most, 3, most/3, main, 'A1', 1, +, number, 'meistgesehenen')),
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		    predicatedec(sp, most, 3, most/3, main, 'A3', 3, -, list, 'Endliste'))
	       ],	
	SPDecList=[declaration(sp, most, [d('A1','+','number','meistgesehenen'), d('A2','+','list','Liste'), d('A3','-','list','Liste')])],
	SPPred = 'most(_, [], [keineweiteresendung]).\n most(1, [Sendung|Rest], [Sendung]).\n most(N, [Sendung|GRest], [Sendung|Rest]):-N1 is N-1, most(N1, GRest, Rest).\n',	
	ClauseTypes=[basecase, basecase, recursivecase],
	diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
	Exp_EL=[s7c, s7g1, s7g1, s7k, s8a, post5a],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-2>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 1/4 Punkte
bestsendung(zuschauer, N, Neulist).
Bestsendung(zuschauer, 0, NeuerList).
Bestsendung(zuschauer, N, Neuelist):- zuschauer = [T, N,Z].
*/
test(exer11, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		    predicatedec(sp, bestsendung, 3, bestsendung/3, main, 'A1', 1, +, list, 'Liste')), 
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		    predicatedec(sp, bestsendung, 3, bestsendung/3, main, 'A2', 2, +, number, 'meistgesehenen')),
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		    predicatedec(sp, bestsendung, 3, bestsendung/3, main, 'A3', 3, -, list, 'Endliste'))
	       ],	
	SPDecList=[declaration(sp, bestsendung, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehenen'), d('A3','-','list','EndListe')])],
	SPPred = 'bestsendung(zuschauer, N, Neulist).\n bestsendung(zuschauer, 0, NeuerList).\n bestsendung(zuschauer, N, Neuelist):- zuschauer = [T, N,Z].\n',	
	ClauseTypes=[basecase, basecase, recursivecase],
	diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
	Exp_EL=[pre2c, pre2c, pre2c, pre3a, pre3a, pre3b],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-3>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 3/4 Punkte
zuschauer([], 0, []).
Zuschauer([[Sender, Sendung, Zuschauer]|R], N, [[Sender, Sendung, Zuschauer|R1]]):-N1 is N-1, zuschauer(R, N1, R1).*/
test(exer11, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		    predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A1', 1, +, list, 'Liste')), 
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		    predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A2', 2, +, number, 'meistgesehenen')),
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		    predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A3', 3, -, list, 'Endliste'))
	       ],	
	SPDecList=[declaration(sp, zuschauer, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehenen'), d('A3','-','list','EndListe')])],
	SPPred = 'zuschauer([],0,[]).\n zuschauer([[Sender, Sendung, Zuschauer]|R], N, [[Sender,Sendung,Zuschauer|R1]]):- N1 is N-1, zuschauer(R,N1,R1).\n',
	ClauseTypes=[basecase,recursivecase],
	diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
	Exp_EL=[s7g, s1f],

	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-4>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 2/4 Punkte
auswahl(L,0).
auswahl([[X,Y,Z]|T], N):-N=<M, zuschauer([[X,Y,Z]|H]), auswahl(T, N1), N1 is N-1.
auswahl([[X,Y,Z]|T], N):- N>M, zuschauer(P).
*/
test(exer11, 5, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-	
	SPDecList=[declaration(sp, auswahl,[d('A1','+','list','Liste'), d('A2','+','number','Laenge')])],
	SPPred='auswahl(L,0).\n auswahl([[X,Y,Z]|T], N):-N=<M, zuschauer([[X,Y,Z]|H]), auswahl(T, N1), N1 is N-1.\n auswahl([[X,Y,Z]|T], N):- N>M, zuschauer(P).\n',
	diagnose_declaration(11, SPDecList, DecMap, ErrorList, RelCounter),
	Exp_EL=[d2a],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-dec1>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** ¾ Punkte
meistgesehen(N,E):- meist(zuschauer, N,E).
meist(A,0,[]).
Meist([], _, [keine, weiteren, sendungen]).
Meist([HZuschauer|RZuschauer], N, [HZuschauer|RErgebnis]):-N1 is N-1, meist(RZuschauer, N1, RErgebnis).
*/
test(exer11, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A1', 1, +, list, 'Liste')), 
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A2', 2, +, number, 'meistgesehenen')),
		map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		    predicatedec(sp, meist, 3, meist/3, main, 'A3', 3, -, list, 'Endliste'))
	       ],	
	SPDecList=[declaration(sp, meist, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehenen'), d('A3','-','list','EndListe')])],
	SPPred = 'meist(A,0,[]).\n meist([],_,[keine_weiteren_sendungen]).\n meist([HZuschauer|RZuschauer],N,[HZuschauer|RErgebnis]):-N1 is N-1, meist(RZuschauer, N1, RErgebnis).\n',
	ClauseTypes=[basecase,basecase,recursivecase],
	diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
	Exp_EL=[s7g1, s7k, s8a, post5b],
	% [s7a, s7g1, s7k, s8a, post5b]
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-5>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 3,5/4 Punkte
% gesehen(Zuschauerzahlen, N, Ergebnisliste)
% Rekursionsabschluss
gesehen(_,0,[]).
% Rekursion
gesehen([Eintrag|Rest], N, [Eintrag|Rest2]):- gesehen(Rest, Z, Rest2), Z is N-1.*/
test(exer11, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
	       predicatedec(sp, gesehen, 3, gesehen/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	   map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
	       predicatedec(sp, gesehen, 3, gesehen/3, main, 'A2', 2, +, number, 'Laenge')),
	   map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
	       predicatedec(sp, gesehen, 3, gesehen/3, main, 'A3', 3, -, list, 'Endliste'))
	  ],	
   SPDecList=[declaration(sp, gesehen, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehenen'), d('A3','-','list','EndListe')])],
   SPPred = 'gesehen(_,0,[]).\n gesehen([Eintrag|Rest],N,[Eintrag|Rest2]):- gesehen(Rest,Z,Rest2), Z is N-1.\n',	
   ClauseTypes=[basecase,recursivecase],
   diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s7g, s4b5],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer11-6>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.
/** 2/4 Punkte
beliebt(_,0,_).
beliebt([Kgeg|Rgeg],Anzahl,[Kgeg|R]):- Anzahl1 is Anzahl-1, beliebt(Rgeg,Anzahl1,R).*/
test(exer11, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, beliebt, 3, beliebt/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, beliebt, 3, beliebt/3, main, 'A2', 2, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, beliebt, 3, beliebt/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, beliebt, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'), d('A3','-','list','neue Liste')])],
    SPPred = 'beliebt(_,0,_).\n beliebt([Kgeg|Rgeg],Anzahl,[Kgeg|R]):- Anzahl1 is Anzahl - 1, beliebt(Rgeg,Anzahl1,R).\n',
    ClauseTypes=[basecase,recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7g1, s7g],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-7>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** ¼ Punkte
Testcase9
% liebsten(TopN, [Zuschauer], [])
liebsten(N, [], []).
liebsten(N, [Zuschauer], Erg):-lieb(N, [Zuschauer], [], Erg).
lieb(N, [H|T], Acc, Erg):- N1, is N-1, Acc1 is [H|Acc], lieb(N1, T, Acc1, Erg).
Accu Approach. Das kann Noch Nicht verstanden werden.
*/

/** ¾ Punkte
zuschauer([],_,[]).
zuschauer([], 0, []).
zuschauer([H|T], N1, [H2|T2]):-zuschauer(T, N,T2), N = N1-1. */
test(exer11, 10, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A2', 2, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, zuschauer, 3, zuschauer/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, zuschauer, [d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'), d('A3','-','list','neue Liste')])],
    SPPred = 'zuschauer([],_,[]).\n zuschauer([],0,[]).\n zuschauer([H|T],N1,[H2|T2]):-zuschauer(T,N,T2), N=N1-1.\n',	
    ClauseTypes=[basecase,basecase,recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7k, s5a, s4f, post5a, post5a, s8a],	
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-8>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 1,5/4 Punkte
% meist(N, Liste) Prädikat liefert Liste der N meist gesehenen Sendungen, unter der Voraussetzung, dass N höchstens so groß ist wie die Liste lang ist.
Meist(0, []).
Meist(N, [H|T]):- N1 is N-1, meist(N1, [T]).*/
test(exer11, 11, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-	
	SPDecList=[declaration(sp, auswahl,[d('A1','+','number','Laenge'), d('A2','-','list','Liste')])],
	SPPred='Meist(0, []).\n Meist(N, [H|T]):- N1 is N-1, meist(N1, [T]).\n',
	diagnose_declaration(11, SPDecList, DecMap, ErrorList, RelCounter),
	Exp_EL=[d2a],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer11-dec1>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** ¾ Punkte
% Rekursion
meistgesehen(X,N, Resultat):- N>0, X=[H|T], H = [_, Sendung|_], N1 is N-1, meistgesehen(T, N1, R1), Resultat = [Sendung|R1].
% Rekursionsabschluss
meistgesehen(_, 0,[]).
meistgesehen([], _, []). */
test(exer11, 12, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, meistgesehen, 3, meistgesehen/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, meistgesehen, 3, meistgesehen/3, main, 'A2', 2, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, +, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, meistgesehen, 3, meistgesehen/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, meistgesehen,[d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'), d('A3','-','list','neue Liste')])],
    SPPred = 'meistgesehen(X,N,Resultat):- N>0, X=[H|T], H=[_,Sendung|_], N1 is N-1, meistgesehen(T,N1,R1), Resultat=[Sendung|R1].\n meistgesehen(_,0,[]).\n meistgesehen([],_,[]).\n',	
    ClauseTypes=[recursivecase,basecase,basecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7k, s8a1, s1d1, s8a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-9>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** ¾ Punkte
neu([], [], _).    % N größer als Liste
neu(_, [], 0)     % N=0
neu([X|Y], [X|Z], N):- N1 is N-1, neu(Y,Z, N1).
Besten(L, N):- neu(Zuschauer, L, N). */

test(exer11, 13, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, neu, 3, neu/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, neu, 3, neu/3, main, 'A3', 3, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, -, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, neu, 3, neu/3, main, 'A2', 2, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, neu,[d('A1','+','list','Liste'), d('A2','-','list','neue Liste'),d('A3','+','number','meistgesehene')])],
    SPPred = 'neu([],[],_).\n neu(_,[],0).\n neu([X|Y],[X|Z],N):- N1 is N-1, neu(Y,Z, N1).\n',
    ClauseTypes=[basecase,basecase, recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7k, s8a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-10>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** ¾ Punkte
% meist_gesehene_sendung(Eingabe, Eingabe, Ausgabe)
% werden mehr Sendungen angefordert als in der Eingabeliste enthalten ist, so wird die größmöglich Anzahl zurückgegeben
m_s([_],0,[]).
m_s(E, Z, E):-Z>length(E).
m_s([H|TE], Z, [H|TA]):-Z1 is Z-1, m_s(TE, Z1, TA).
*/
test(exer11, 14, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, m_s, 3, m_s/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, m_s, 3, m_s/3, main, 'A2', 2, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, -, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, m_s, 3, m_s/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, m_s,[d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'),d('A3','-','list','neue Liste')])],
    SPPred = 'm_s([_],0,[]).\n m_s(E, Z, E):-Z>length(E).\n m_s([H|TE], Z, [H|TA]):-Z1 is Z-1, m_s(TE, Z1, TA).\n',
    ClauseTypes=[basecase,basecase, recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7g1, s7g1, s8c, s8g],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-11>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 4/4 Punkte. Wir tolerieren Rechtschreibfehler: [First|AltList]
neulist(_, 0,[_]). % wenn N=0 wird nicht mehr angehängt, außer leere Liste
neulist([First|AltList], N, [First|Neulist]):- N2 is N-1, neulist(Altlist, N2, Neulist).
neulist([], N, []).  % falls N zu groß wird aus leer wieder leer */
test(exer11, 15, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
	       predicatedec(sp, neulist, 3, neulist/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	   map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
	       predicatedec(sp, neulist, 3, neulist/3, main, 'A2', 2, +, number, 'Laenge')),
	   map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, -, list, ['Anfang, erzeugte Liste, Endliste']), 
	       predicatedec(sp, neulist, 3, neulist/3, main, 'A3', 3, -, list, 'Endliste'))
	  ],	
   SPDecList=[declaration(sp, neulist,[d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'), d('A3','-','list','neue Liste')])],
   SPPred = 'neulist(_,0,[_]).\n neulist([First|AltList],N,[First|Neulist]):- N2 is N-1, neulist(AltList,N2,Neulist).\n neulist([], N, []).\n',
   ClauseTypes=[basecase, recursivecase, basecase],
   diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s7g1, s8a, post5b],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer11-12>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/** ¾ Punkte
meist(0, [], []).
meist(N, [H|T], [H|R]):- N1 is N-1, meist(N1, T, R). */
test(exer11, 16, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A2', 2, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A1', 1, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, -, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, meist,[d('A1','+','number','meistgesehene'), d('A2','+','list','Liste'), d('A3','-','list','neue Liste')])],
    SPPred = 'meist(0, [], []).\n meist(N, [H|T], [H|R]):- N1 is N-1, meist(N1, T, R).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7g],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-13>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 3,5/4 Punkte
% meist(Liste, N, Ergebnis)
meist([], _,[]). % Wenn die Liste leer ist, ist das Resultat []
meist(_, 0, []). % Rekursionsabschluss wenn N=0
meist([H|T], N, [H|Y]):- N1 is N-1, meist(T, N1, Y). */
test(exer11, 17, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg1', 1, +, list, ['Liste, Gesamtliste']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A1', 1, +, list, 'Zuschauerzahlen')), 
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg2', 2, +, number, ['Laenge, meistgegehene Sendungen']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A2', 2, +, number, 'Laenge')),
	    map(dec, predicatedec(tp, anfang, 3, anfang/3, main, 'Arg3', 3, -, list, ['Anfang, erzeugte Liste, Endliste']), 
		predicatedec(sp, meist, 3, meist/3, main, 'A3', 3, -, list, 'Endliste'))
	   ],	
    SPDecList=[declaration(sp, meist,[d('A1','+','list','Liste'), d('A2','+','number','meistgesehene'), d('A3','-','list','neue Liste')])],
    SPPred = 'meist([],_,[]).\n meist(_,0,[]).\n meist([H|T], N, [H|Y]):- N1 is N-1, meist(T, N1, Y).\n',
    ClauseTypes=[basecase, basecase, recursivecase],
    diagnose_predicate(11, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7k, s8a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer11-14>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

%-----------------------------------------------------------------------%
/** Exercise10 - WS98/99a 01.02.99 - 65 Teilnehmer
% 58 Solutions, 2 not understandable (Testcase17, 36) using helper predicates; 2 not correctly analysed: (Testcases11, 13) define helpers

Eine Gehaltsdatenbank sei als Liste implementiert, wobei jedes ungeradzahlige Listenelement ein Name und jedes geradzahlige Listenelement eine Gehaltsangabe in DM ist, z.B. [meier, 3600, schulze, 5400, mueller, 6300, ..., bauer, 4200]. <br> 
Definieren Sie ein Prädikat, das die Summe aller Gehälter für eine beliebig lange Liste berechnet.*/
/** 5,5 Punkte
kohle([], 0).
kohle([Name,Geld|Tail], Ges):-kohle([Tail], GZ), Ges is Geld +GZ.*/
test(exer12, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, kohle, 2, kohle/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, kohle, 2, kohle/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, kohle,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'kohle([],0).\n kohle([Name,Geld|Tail], Ges):-kohle([Tail], GZ), Ges is Geld + GZ.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s3a, post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-1>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summe([], 0).
summe([_,Gehalt|Rest], Betrag):-summe(Rest, Betrag1), Betrag is Betrag1+Gehalt. */
test(exer12, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], 0).\n summe([_,Gehalt|Rest], Betrag):-summe(Rest, Betrag1), Betrag is Betrag1+Gehalt.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-2>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
gehalt([], 0).
gehalt([N1,G1|Rest], Gehalt):-gehalt(Rest, GehaltZ), Gehalt is GehaltZ+G1.*/
test(exer12, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehalt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehalt([],0).\n gehalt([N1,G1|Rest], Gehalt):-gehalt(Rest, GehaltZ), Gehalt is GehaltZ+G1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-3>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
summe([], S):-S is 0.
summe([X|[Y|Rest]], S):- summe(Rest, SNeu), S is Y+Sneu.*/
test(exer12, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], S):-S is 0.\n summe([X|[Y|Rest]], S):- summe(Rest, SNeu), S is Y+SNeu.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, post5a, s5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-4>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte. Wir fügen ein klasel hinzu, die das Akku-Prädikat aufruft.
% addlist(Liste, Akku, Ergebnis)
addlist([], R, R).
addlist([_, K|R], A, Res):- A1 is A+K, addlist(R, A1, Res). 
Accu approach*/
test(exer12, 5, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, addlist, 3, gehalt/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, addlist, 3, gehalt/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, addlist, 3, gehalt/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, addlist, gehalt/2, accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred='gehalt(LS, G):-addlist(LS,0,G).\n addlist([], R, R).\n addlist([_, K|R], A, Res):- A1 is A+K, addlist(R, A1, Res).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-5>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.


/** 5 Punkte
sum([], 0).
sum([A,B|C], S1):-sum(C, S2), S1 is S2+B. */
test(exer12, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, sum, 2, sum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, sum, 2, sum/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, sum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'sum([],0).\n sum([A,B|C], S1):-sum(C, S2), S1 is S2+B.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-6>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte. Wir tolerieren die 2. Klausel, indem der Klauselkopf als Kommmentar interpretiert wird.
gehaelter([], 0).
gehaelter(Liste, Summe):-gehaelter([[Name|Geh]|Rest], Summe), gehaelter(Rest, ZS), Summe is Geh+ZS.*/
test(exer12, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehaelter,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehaelter([], 0).\n gehaelter([[Name|Geh]|Rest], Summe):- gehaelter(Rest, ZS), Summe is Geh+ZS.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s1f, post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-7>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte. Wir tolerieren Syntaxfehler im Klauselkopf der 2. KLausel.
sum([], 0).
sum(_,Gehalt|R, Summe):-sum(R, ZwiSumme), Summe is ZwiSumme+Gehalt.*/
test(exer12, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, sum, 2, sum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, sum, 2, sum/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, sum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'sum([], 0).\n sum([_,Gehalt|R], Summe):-sum(R, ZwiSumme), Summe is ZwiSumme+Gehalt.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-8>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
gehalt(LS, G):-gh(LS,0,G).
gh([], X,X).
gh([_,G|R], A, R):-GS is A+G, gh(R,GS,R).
TODO: this implementation applies Accu strategy */
test(exer12, 9, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gh, 3, gehalt/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, gh, 3, gehalt/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, gh, 3, gehalt/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, gh, gehalt/2, accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred='gehalt(LS, G):-gh(LS,0,G).\n gh([], X,X).\n gh([_,G|R], A, R):-GS is A+G, gh(R,GS,R).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s4a1, s4d],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-9>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 1 Punkt
f(0, []). */
test(exer12, 10, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, f, 2, f/2, main, 'A2', 2, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, f, 2, f/2, main, 'A1', 1, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, f,[d('A1','-','number','Summe'), d('A2','+','list','Gehaltsliste')])],
    SPPred = 'f(0,[]).\n',
    ClauseTypes= [basecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[pre3a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-10>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
Testcase11: 
summe([K,R], S):- hilf(R,S1), S is S1.
Hilf([K1|R1], S1):-S is K1+S1, summe(R1, S).
summe([],S). 
TODO: This applies helper predicate */

/** 5 Punkte
gesamt([], 0).
gesamt([_,H|T], N):- N is H+N1, gesamt(T,N1).*/
test(exer12, 12, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gesamt, 2, gesamt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gesamt, 2, gesamt/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gesamt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gesamt([], 0).\n gesamt([_,H|T], N):- N is H+N1, gesamt(T,N1).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s3fa, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-12>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 2 Punkte
Testcase13:
gehaltsumm(Element, Summe):- Element=[Kopf|Rest], gehalt2(Rest, Summe).
gehalt2(Element2, Summe):- Element2=[Kopf|Rest], Summe = [Kopf+Summe], gehaltsumme(Rest, Summe).
TODO: this applies helper predicate */

/** 6 Punkte
summe([], 0).
summe([_,Zahl|Rest], Ergebnis):-summe(Rest, Ergebnis1), Ergebnis is Ergebnis1+Zahl. */
test(exer12, 14, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([],0).\n summe([_,Zahl|Rest], Ergebnis):-summe(Rest, Ergebnis1), Ergebnis is Ergebnis1+Zahl.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-14>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 2 Punkte
summe(Liste, Ergebnis):-L1=[K1,K2|R1], X is Ergebnis+K2, summe(R1,X).*/
test(exer12, 15, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe(Liste, Ergebnis):-L1=[K1,K2|R1], X is Ergebnis+K2, summe(R1,X).\n',	
    ClauseTypes=[recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7e, s7g, s1a, s1h, s3a, s3fa, s5a, s6b1, s4b1, post5b, post5c, post5c, post7b, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-15>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
calc([],0).
calc([_,G|R], X):-calc(R,Y), Y is X-G.*/
test(exer12, 16, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, calc, 2, calc/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, calc, 2, calc/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, calc,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'calc([],0).\n calc([_,G|R], X):-calc(R,Y), Y is X-G.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s5a, s9a, s6b1, s4b1, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-16>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
Testcase17:
gehalt([K|R] :- R>0, R
gehalt1([], X,F).
gehalt1([K|R], X,F):-X1 is X+1,
			odd(X1), gehalt1(R,X1, F);
			X1 is X+1, even(X1), F1 is F+K,
			Gehaltq1(R, X1, F1).
Gehalt(L,R):-gehalt1(L, 0,0).

Odd(X):-1 is X mod Z.
Even(X):- 0 is X mod Z. 
TODO: this applies helper predicates*/

/** 6 Punkte
% summe(Liste, Summe)
summe([], 0). % REkursionsabschluss
summe([_,A|R], S):-summe(R,S1), S is S1+A.*/
test(exer12, 18, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([],0).\n summe([_,A|R], S):-summe(R,S1), S is S1+A.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-18>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summe([], 0).
summe([_,Gehalt|Rest],X):-summe(Rest, Y), X is Y+Gehalt.*/
test(exer12, 19, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	    predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], 0).\n summe([_,Gehalt|Rest],X):-summe(Rest, Y), X is Y+Gehalt.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-19>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
sum([],0).
sum([_,Wert|Tail], S):-sum(Tail, Zw), S is Zw+Wert.*/
test(exer12, 20, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, sum, 2, sum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, sum, 2, sum/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, sum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'sum([],0).\n sum([_,Wert|Tail], S):-sum(Tail, Zw), S is Zw+Wert.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-20>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
summe([], X):- X is 0.
summe([_|[Gehalt|Rest]], X):- summe(Rest, X1), X is X1+Gehalt. */
test(exer12, 21, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], X):- X is 0.\n summe([_|[Gehalt|Rest]], X):- summe(Rest, X1), X is X1+Gehalt.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-21>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** Prädikatsname: gehalt(Liste,Summe)
Abschluss: die leere Liste hat keine Gehälter
Rekursion: Die n-elementige Liste hat als Summe das 2. Element plus die Summe der (n-2)-Elementige Liste.
Endrekursive Implementation mit Akkumulator.
gehalt(Liste, Summe):-g(Liste, Summe, 0).
g([], Summe, Summe).
g([_,X|Tail], Summe, Akku):-Akku1 is Akku+X, g(Tail, Summe, Akku1).
accu approach */
test(exer12, 22, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, g, 3, gehalt/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, g, 3, gehalt/2, accu, 'A2', 2, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, g, 3, gehalt/2, accu, 'A3', 3, +, number, 'accu'))],
  SPDecList=[declaration(sp, gehalt, [d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, g, gehalt/2, accu,[d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe'), d('A3','+','number','accu')])],
  SPPred='gehalt(Liste, Summe):-g(Liste, Summe, 0).\n g([], Summe, Summe).\n g([_,X|Tail], Summe, Akku):-Akku1 is Akku+X, g(Tail, Summe, Akku1).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-22>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 5 Punkte. Wir tolerieren Rechtschreibfehler in myadd([_|[X|T], R])
myadd([_|[X|T], R]):-myadd(T, R1), R is R1+X.
myadd([],0). */
test(exer12, 23, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, myadd, 2, myadd/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, myadd, 2, myadd/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, myadd,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'myadd([_|[X|T]], R):-myadd(T, R1), R is R1+X.\n myadd([],0).\n',	
    ClauseTypes=[recursivecase, basecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-23>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
prädikatsschema: gehalt-sum(Liste, Resultat).
gehalt_sum([], 0). % Rekursionsabbruch
gehalt_sum([_,Kopf2|Rest], R):-gehalt_sum(Rest, R1), R is R1+Kopf2.*/
test(exer12, 24, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehalt_sum, 2, gehalt_sum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehalt_sum, 2, gehalt_sum/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehalt_sum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehalt_sum([], 0).\n gehalt_sum([_,Kopf2|Rest], R):-gehalt_sum(Rest, R1), R is R1+Kopf2.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-24>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summe(0, []).
summe(Wert, [A,B|R]):-Wert1 is Wert +B, summe(Wert1,R).*/
test(exer12, 25, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','-','number','Summe'), d('A2','+','list','Gehaltsliste')])],
    SPPred = 'summe(0, []).\n summe(Wert, [A,B|R]):-Wert1 is Wert +B, summe(Wert1,R).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s3fa, s5a, s6b1, s4b1, post5a, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-25>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summegehalt([], 0).
summegehalt([_,Gehalt|Restliste], Summe):-
	summegehalt(RestListe, Restsumme),
	Summe is Restsumme + Gehalt.*/
test(exer12, 26, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, summegehalt, 2, summegehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, summegehalt, 2, summegehalt/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, summegehalt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
  SPPred='summegehalt([],0).\n summegehalt([_,Gehalt|RestListe],Summe):-summegehalt(RestListe,Restsumme),Summe is Restsumme+Gehalt.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-26>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 5 Punkte
rechne([], 0).
rechne([[Head|Zahl]|Tail], N):-rechne(Tail, N1), N is Zahl +N1.*/
test(exer12, 27, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, rechne, 2, rechne/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, rechne, 2, rechne/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, rechne,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'rechne([], 0).\n rechne([[Head|Zahl]|Tail], N):-rechne(Tail, N1), N is Zahl +N1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s1f, post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-27>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte. The 1st subgoal of the 1st claus will be interpreted as Liste=[G,_] by atom_to_term. We still do not have a better solution.
gehalt(Liste, Summe):-Liste=[G, _|[]], Summe=G.
gehalt(Liste, Summe):- Liste=[G1,_,G2,_|T], gehalt([G3,_|T], Summe), G3 is G1+G2.*/
test(exer12, 28, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehalt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehalt(Liste, Summe):- Liste=[G,_|[]], Summe=G.\n gehalt(Liste, Summe):- Liste=[G1,_,G2,_|T], gehalt([G3,_|T], Summe), G3 is G1+G2.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7d, s7g2, s1e, s3a, s5a, s6b1, s6b1, s4a1, s4b1, s1h, s4f],    
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-28>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 2 Punkte
berechne([], 0).
berechne([A,B|T], Res):-berechne(T, Res1), Res1 is Res1+B.*/
test(exer12, 29, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, berechne, 2, berechne/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, berechne, 2, berechne/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, berechne,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'berechne([], 0).\n berechne([A,B|T], Res):-berechne(T, Res1), Res1 is Res1+B.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s5a, s4b1, post5a, post5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-29>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte. sum just calls summiere. We ignore sum.
sum(Liste, Betrag):-summiere(Liste, Betrag).
summiere([], 0).
summiere([_|RestL], Betrag):-RestL=[BetragZ|Rest], summiere(Rest, Betrag1), Betrag is BetragZ+Betrag1.*/
test(exer12, 30, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summiere, 2, summiere/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summiere, 2, summiere/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summiere,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summiere([], 0).\n summiere([_|RestL], Betrag):-RestL=[BetragZ|Rest], summiere(Rest, Betrag1), Betrag is BetragZ+Betrag1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-30>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 3 Punkte
summe([], Ergebnis).
summe(Liste, Ergebnis):- Liste=[Name, Gehalt|Rest], Ergebnis1 is Ergebnis+Gehalt, summe(Rest, Ergebnis).*/
test(exer12, 31, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], Ergebnis).\n summe(Liste, Ergebnis):- Liste=[Name, Gehalt|Rest], Ergebnis1 is Ergebnis+Gehalt, summe(Rest, Ergebnis).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s3fa, s5a, s4a1, s4b1, post5c, post5c, post7b, post5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-31>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
gehaltsum([], 0).
gehaltsum(Liste, Summe):- Liste=[_,Gehalt|Rest], gehaltsum(Rest, Summ1), Summe is Gehalt +Summ1.*/
test(exer12, 32, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	    predicatedec(sp, gehaltsum, 2, gehaltsum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehaltsum, 2, gehaltsum/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, gehaltsum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
  SPPred = 'gehaltsum([], 0).\n gehaltsum(Liste, Summe):- Liste=[_,Gehalt|Rest], gehaltsum(Rest, Summ1), Summe is Gehalt +Summ1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-32>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 5,5 Punkte. Dies ist keine Accu-Implementation
sum([], N, 0).
sum(L, N, R):-L=[K1,K2|Rest], N1 is N+2, sum(Rest, N1, R1), R is K2+R1.*/
test(exer12, 33, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
	SPDecList=[declaration(sp, sum, [d('A1','+','list','Gehaltsliste'),d('A2','+','number','Accu'), d('A3','-','number','Summe')])],
	SPPred='sum([], N, 0).\n sum(L, N, R):-L=[K1,K2|Rest], N1 is N+2, sum(Rest, N1, R1), R is K2+R1.\n',
	diagnose_declaration(12, SPDecList, DecMap, ErrorList, RelCounter),
	Exp_EL=[d2b],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer12-dec33>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 6 Punkte
summe([], X,X).
summe([_,Gehalt|Rest], X,Y):-Z=X+Gehalt, summe(Rest,Z,Y).
summe(Liste, Gesamtgehalt):-summe(Liste, 0, Gesamtgehalt).
Accu Approach*/
test(exer12, 34, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, summe, 3, summe/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, summe, 3, summe/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, summe, 3, summe/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp, summe, [d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, summe, summe/2, accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred='summe([], X,X).\n summe([_,Gehalt|Rest], X,Y):-Z=X+Gehalt, summe(Rest,Z,Y).\n summe(Liste, Gesamtgehalt):-summe(Liste, 0, Gesamtgehalt).\n',
  ClauseTypes=[basecase, recursivecase, nonrecursive],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s5a, s4f],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-34>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 6 Punkte
gehalt([], A,A).
gehalt(L, A, R):-L=[K1, K2|Rest], A1 is A+K2, gehalt(Rest, A1, R).
gehaelter_in_summe(L,R):-gehalt(L,0,R).

Das Prädikat gehaelter_in_summe ruft gehalt auf. Dies Prädikat sammelt die Gehälter im Akkumulator A und liefert die Summe a.d. dritten Argumentsposition zurück, sobald die Liste abgearbeitet ist.
Accu Approach */
test(exer12, 35, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehaelter_in_summe, 2, gehaelter_in_summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehaelter_in_summe, 2, gehaelter_in_summe/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehalt, 3, gehaelter_in_summe/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, gehalt, 3, gehaelter_in_summe/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, gehalt, 3, gehaelter_in_summe/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp, gehaelter_in_summe, [d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, gehalt, gehaelter_in_summe/2,accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred='gehalt([],A,A).\n gehalt(L,A,R):-L=[K1,K2|Rest], A1 is A+K2, gehalt(Rest,A1,R).\n gehaelter_in_summe(L,R):- gehalt(L,0,R).\n',
  ClauseTypes=[basecase, recursivecase, nonrecursive],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-35>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
Testcase36 
geld(_, [], 0).
geld(X,Y,R):-length(X,Z), Z is gerade, X=[K|S], X is S, Y is S, geld(X,Y, R1), R is R1+K.
geld(X,Y,R):- X=[K|S], X is S, geld(X,Y,R).
TODO: kann nicht verstanden werden. */

/** 3,5 Punkte. Wir tolerieren Rechtschreibfehler in 1. Klausel
gehaeltersumme([], Summe).
gehaeltersumme1(Liste, Summe):-Liste=[Name, Gehalt|Rest], NSumme is Summe +Gehalt, gehaeltersumme1(Rest, NSumme).
gehaeltersumme(Gehaltsdatenbank, Summe):-gehaeltersumme1(Gehaltsdatenbank,0).*/
test(exer12, 37, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehaeltersumme1, 2, gehaeltersumme1/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehaeltersumme1, 2, gehaeltersumme1/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehaeltersumme1,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehaeltersumme1([], Summe).\n gehaeltersumme1(Liste, Summe):-Liste=[Name, Gehalt|Rest], NSumme is Summe +Gehalt, gehaeltersumme1(Rest, NSumme).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s3fa, s5a, s6b1, s4b1, post5c, post7b, post5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-37>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 4 Punkte
summe([Name, Zahl|[]], Zahl).
summe([Name,Zahl|Tail], R):- summe(Tail, R1), R is R1+Zahl.*/
test(exer12, 38, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([Name, Zahl|[]], Zahl).\n summe([Name,Zahl|Tail], R):- summe(Tail, R1), R is R1+Zahl.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s7g1, post5a, post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-38>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
addiere([], R,R).
addiere([_,G|L], T, R):-G1 is G+T, addiere(L,G1, R).
Accu Approach*/
test(exer12, 39, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, g_summe, 2, g_summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, g_summe, 2, g_summe/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, addiere, 3, g_summe/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, addiere, 3, g_summe/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, addiere, 3, g_summe/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp,g_summe,[d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp, addiere, g_summe/2,accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred ='g_summe(GListe,Summe):-addiere(GListe,0,Summe).\n addiere([],R,R).\n addiere([_,G|L],T,R):-G1 is G+T, addiere(L,G1, R).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-39>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 5.5 Punkte. Wir tolerieren Syntxfehler in G_>Liste.
g_summe(G_>Liste, Summe):-g_summe(G_>Liste, 0, Summe).
g_summe([], Akku, Akku).
g_summe([[_,Gehalt]|Rest], Akku, Summe):-Akku2 is Akku+Gehalt, g_summe(Rest, Akku2, Summe).
Accu Approach*/
test(exer12, 40, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, g_summe, 2, g_summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')),	
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, g_summe, 2, g_summe/2, main, 'A2', 2, -, number, 'Summe')),

	  map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, g_summe, 3, g_summe/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	  map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	      predicatedec(sp, g_summe, 3, g_summe/2, accu, 'A3', 3, -, number, 'Summe')),
	  map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	      predicatedec(sp, g_summe, 3, g_summe/2, accu, 'A2', 2, +, number, 'accu'))],
  SPDecList=[declaration(sp,g_summe,[d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	     declaration(sp,g_summe, g_summe/2,accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred ='g_summe(GListe, Summe):-g_summe(GListe, 0, Summe).\n g_summe([], Akku, Akku).\n g_summe([[_,Gehalt]|Rest], Akku, Summe):-Akku2 is Akku+Gehalt, g_summe(Rest, Akku2, Summe).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s1f],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-40>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 5 Punkte. Wir tolerieren Rechtschreibfehler im Kopf der 3. Klausel und in HAT, 
gehaltssumme([], 0).
gehaltssumme([_],0).
gehaltssumme([H|[HT|T], Summe]):-gehaltssumme(T,S), Summe is HAT+S.*/
test(exer12, 41, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	      predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	  map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	      predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, gehaltssumme,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
  SPPred = 'gehaltssumme([], 0).\n gehaltssumme([_],0).\n gehaltssumme([H|[HT|T]],Summe):-gehaltssumme(T,S),Summe is HT+S.\n',	
  ClauseTypes=[basecase, basecase, recursivecase],
  diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s7i, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer12-41>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 6 Punkte. Wir tolerieren Rechtschreibfehler im Kopf der 2. Klausel.
gehalt_sum/2
gehalt_sum([],0).
gehalt_sum(Head, Head2|Tail, X):-gehalt_sum(Tail, X1), X is Head2 +X1.*/
test(exer12, 42, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehalt_sum, 2, gehalt_sum/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehalt_sum, 2, gehalt_sum/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehalt_sum,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehalt_sum([],0).\n gehalt_sum([Head, Head2|Tail], X):-gehalt_sum(Tail, X1), X is Head2 +X1.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-42>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte. Warum nur 5 Punkte?
addlist([], 0).
addlist([_,K|Rest], E):-addlist(Rest, Ezw), E is Ezw+K.*/
test(exer12, 43, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, addlist, 2, addlist/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, addlist, 2, addlist/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, addlist,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'addlist([], 0).\n addlist([_,K|Rest], E):-addlist(Rest, Ezw), E is Ezw+K.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-43>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summe([_,X], X).
summe([_,X|Rest], Y):-summe(Rest, X1), Y is X+X1. */
test(exer12, 44, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([_,X], X).\n summe([_,X|Rest], Y):-summe(Rest, X1), Y is X+X1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s7g1],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-44>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte. Wir haben eine Klausel hinzugefügt, die das Akku-Prädikat aufruft.
summe([], S,S).
summe([N,G|Rest], S,E):-S1 is S+G, summe(Rest, S1, E).
Erklärung: wenn die Lsite leer ist, wird die Sume auf dem zweiten Argument an das dritte Argument als Ergebnis übergeben. Das zweite Argument muss mit 0 aufgerufen werden (durch Hilfsprädikat). Die Liste (wenn ise nicht leer ist), wird in ihre ersten beiden Elemente und die Restliste zerlegt. Auf dem zweiten Argument werden die jeweils zweiten Elemente, mit den noch folgenden zweiten Elementen der Restliste aufsummiert.
Accu Approach*/
test(exer12, 45, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
   DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	       predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	   map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
	       predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe')),

	   map(dec, predicatedec(tp, tpsalarysumaccu, 3,tpsalarysum/2, accu,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
	       predicatedec(sp, summeaccu, 3, summe/2, accu, 'A1', 1, +, list, 'Gehaltsliste')),
	   map(dec, predicatedec(tp,tpsalarysumaccu, 3,tpsalarysum/3, accu,'Arg2',2,-,number,['Gehaltsumme,Summe aller Gehälter']), 
	       predicatedec(sp, summeaccu, 3, summe/2, accu, 'A3', 3, -, number, 'Summe')),
	   map(dec, predicatedec(tp, tpsalarysumaccu, 3, tpsalarysum/3, accu,'Arg3',3,+,number,['Akku, accu']), 
	       predicatedec(sp, summeaccu, 3, summe/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,summe,[d('A1','+','list','Gehaltsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,summeaccu,summe/2,accu,[d('A1','+','list','Gehaltsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred ='summe(L,G):-summeaccu(L,0,G).\n summeaccu([],S,S).\n summeaccu([N,G|Rest],S,E):-S1 is S+G, summeaccu(Rest,S1,E).\n',
   ClauseTypes=[nonrecursive, basecase, recursivecase],
   diagnose_predicate(12, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[post5a],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer12-45>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.


/** 6 Punkte
gehaltssumme([], 0).  % Rekursionsabschluss
gehaltssumme([_,G|R], S):-gehaltssumme(R, S1), S is S1+G. % G is das Gehalt der aktuellen Rekursionsliste.*/
test(exer12, 46, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehaltssumme,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehaltssumme([], 0).\n gehaltssumme([_,G|R], S):-gehaltssumme(R, S1), S is S1+G.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-46>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte. I think, the repetation of Summe is Summe1+K2 is a typo.
gehaelter(0, []).
gehaelter(Summe, Liste):- Liste=[K1|R1], R1=[K2|R2], gehaelter(Summe, R2), Summe is Summe1+K2, Summe is Summe1+K2.*/
test(exer12, 47, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A2', 2, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehaelter, 2, gehaelter/2, main, 'A1', 1, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehaelter,[d('A1','-','number','Summe'), d('A2','+','list','Gehaltsliste')])],
    SPPred = 'gehaelter(0,[]).\n gehaelter(Summe,Liste):-Liste=[K1|R1], R1=[K2|R2], gehaelter(Summe,R2),Summe is Summe1+K2.\n',	
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s1e, s6b1, s4a1, post5c, post5c, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-47>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
gehalt([], 0).
gehalt([K1,K2|R1], E):-gehalt(R1, E1), E is K2+E1.*/
test(exer12, 48, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehalt, 2, gehalt/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehalt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehalt([], 0).\n gehalt([K1,K2|R1], E):-gehalt(R1, E1), E is K2+E1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-48>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 1 Punkte
rechne(E,L):-L=[Kopf|Rest],Kopf=E.
rechne(E,L):-L=[Kopf/2|Rest].*/
test(exer12, 49, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, rechne, 2, rechne/2, main, 'A2', 2, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, rechne, 2, rechne/2, main, 'A1', 1, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, rechne,[d('A2','-','number','Summe'), d('A1','+','list','Gehaltsliste')])],
    SPPred = 'rechne(E,L):-L=[Kopf|Rest],Kopf=E.\n rechne(E,L):-L=[Kopf/2|Rest].\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[pre3a, pre3b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-49>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
sumgehalt([],0).
sumgehalt([Name,Gehalt|Rest], Summe):-sumgehalt(Rest,Sum1), Summe is Sum1+Gehalt.*/
test(exer12, 50, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, sumgehalt, 2, sumgehalt/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, sumgehalt, 2, sumgehalt/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, sumgehalt,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'sumgehalt([],0).\n sumgehalt([Name,Gehalt|Rest], Summe):-sumgehalt(Rest,Sum1), Summe is Sum1+Gehalt.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[post5a],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-50>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 6 Punkte
summe([], 0).
summe([_,Gehalt|Tail], R):-summe(Tail, R1), R is R1+ Gehalt.*/
test(exer12, 51, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], 0).\n summe([_,Gehalt|Tail], R):-summe(Tail, R1), R is R1+ Gehalt.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-51>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 3 Punkte
length(Gehalt, []).
length(Gehalt, [_,Rest]):-length(Gehalt1, Rest), Gehalt is Name.*/
test(exer12, 52, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-	
	SPDecList=[declaration(sp, length,[d('A1','-','number','Summe'), d('A2','+','list','Liste')])],
	SPPred='length(Gehalt, []).\n length(Gehalt, [_,Rest]):-length(Gehalt1, Rest), Gehalt is Name.\n',
	diagnose_declaration(12, SPDecList, DecMap, ErrorList, RelCounter),
	Exp_EL=[d1a],
	getErrorIdList(ErrorList, EIDL),
	debug(test, '<exer12-dec52>EIDL=~w',[EIDL]),
	Exp_EL=EIDL.

/** 6 Pnukte
summe([_,X], X).
summe(X,Y):- X=[Kopf1, Kopf2|Rest], summe(Rest, Y1), Y is Kopf2 +Y1.*/
test(exer12, 53, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([_,X], X).\n summe(X,Y):- X=[Kopf1, Kopf2|Rest], summe(Rest, Y1), Y is Kopf2 +Y1.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s7g1, post5c],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-53>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 1 Punkte
gehaltssumme(Gehaltsliste, Bisher):-[_,X|Rest], Y is X+bisher, gehaltssumme(Rest, Y).
gehaltssumme([], X).*/
test(exer12, 54, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, gehaltssumme, 2, gehaltssumme/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, gehaltssumme,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'gehaltssumme(Gehaltsliste, Bisher):-[_,X|Rest], Y is X+Bisher, gehaltssumme(Rest, Y).\n gehaltssumme([], X).\n',
    ClauseTypes=[recursivecase, basecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[g7],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-54>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 4 Punkte. Wir tolerieren Rechtschreibfehler im Kopf der 2. Klausel
summe([], Erg).
summe([_,Gehalt|Rest]):-Erg is Erg1+Gehalt, summe(Rest, Erg1).*/
test(exer12, 55, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], Erg).\n summe([_,Gehalt|Rest], Erg):-Erg is Erg1+Gehalt, summe(Rest, Erg1).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s3fa, post7b,  post5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-55>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 2 Punkte
summe([], R).
summe([H|T], R1):-summe(T,R1), mod(length(H))=0, R1 is R+H.*/
test(exer12, 56, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([], R).\n summe([H|T], R1):-summe(T,R1), mod(length(H))=0, R1 is R+H.\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s1f, s6b1, s6b1, s4a1, s4g,  post5c, post7b, post5b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-56>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 2 Punkte. Wir teolerieren Rechtschreibfehler in "sum"
geh([], []).
geh(sum,[Kopf|Ende]):-sum is sum1+[Ende|Ende1], geh(Sum1, End1).*/
test(exer12, 57, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, geh, 2, geh/2, main, 'A2', 2, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, geh, 2, geh/2, main, 'A1', 1, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, geh,[d('A1','-','number','Summe'),d('A2','+','list','Gehaltsliste')])],
    SPPred = 'geh([], []).\n geh(Sum,[Kopf|Ende]):-Sum is Sum1+[Ende|Ende1], geh(Sum1, End1).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[pre2e],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-57>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

/** 5 Punkte
summe([_,B],B).
summe([_,B|C], X):-X is B+Z, summe(C,Z).*/
test(exer12, 58, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
    DecMap=[map(dec, predicatedec(tp, tpsalarysum, 2,tpsalarysum/2, main,'Arg1',1,+,list, ['Gehaltsdatenbank, Gehaltsliste']), 
		predicatedec(sp, summe, 2, summe/2, main, 'A1', 1, +, list, 'Gehaltsliste')), 
	    map(dec, predicatedec(tp, tpsalarysum, 2, tpsalarysum/2, main,'Arg2',2,-,number,['Gehaltsumme, Summe aller Gehälter']),
		predicatedec(sp, summe, 2, summe/2, main, 'A2', 2, -, number, 'Summe'))],	
    SPDecList=[declaration(sp, summe,[d('A1','+','list','Gehaltsliste'), d('A2','-','number','Summe')])],
    SPPred = 'summe([_,B],B).\n summe([_,B|C], X):-X is B+Z, summe(C,Z).\n',
    ClauseTypes=[basecase, recursivecase],
    diagnose_predicate(12, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
    Exp_EL=[s7c, s7g1, s3fa, post7b],
    getErrorIdList(ErrorList, EIDL),
    debug(test, '<exer12-58>EIDL=~w',[EIDL]),
    Exp_EL=EIDL.

%----------------------------------------------------------------------%
% Exercise 5a, ws99/00a 18.02.2000 (108 Teilnehmer)
% 81 Solutions, 0 not understandable. 2 not correctly analysed: helper predicates (Testcase9, 40)

/**
Der Bestand an Kraftfehrzeugen einer Firma sei als Liste von zweielementigen Listen gegeben, wobei das erste Element einer Unterliste das polizeiliche Kennzeichen und das zweite Baujahr angibt, z.B. [[hh-gu_12-67, 1992], [hh-wa_34-25, 1987], [hh-ig_84-62, 1998], ...[hh-ba_39-29, 1983]]. Die Leitung des Unternehmens benötigt einen Überblick über die Alterstruktur der vorhandenen Fahrzeuge und bittet sie um verschiedene Informationen. Definieren Sie ein Prädikat, das die Anzahl der Kraftfahrzeuge im derzeitigen Bestand berechnet.*/

/** 2 Punkte
zaehlen([],[]).
zaehlen([H|T], X):-X is X+1, zaehlen([T],X). */
test(exer13, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, zaehlen, 2, zaehlen/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, zaehlen, 2, zaehlen/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, zaehlen,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'zaehlen([],[]).\n zaehlen([H|T], X):-X is X+1, zaehlen([T],X).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre2e],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-1>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**
anzahl(Liste, Zahl):-anz(Liste, 0, Zahl).
anz([], Acc, Acc).
anz([_|Tail], Acc, Zahl):- Acc2 is Acc +1, anz(Tail, Acc2, Zahl).*/
test(exer13, 2, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, anz, 3, anzahl/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, anz, 3, anzahl/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, anz, 3, anzahl/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,anzahl,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,anz,anzahl/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred ='anzahl(Liste, Zahl):-anz(Liste, 0, Zahl).\n anz([], Acc, Acc).\n anz([_|Tail], Acc, Zahl):- Acc2 is Acc +1, anz(Tail, Acc2, Zahl).\n',
   ClauseTypes=[nonrecursive, basecase, recursivecase],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-2>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/** 3 Punkte
fahrzeug([],0).
fahrzeug([K|R], N):-fahrzeug(R,N1), N is N1+1.*/
test(exer13, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, fahrzeug, 2, fahrzeug/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, fahrzeug, 2, fahrzeug/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, fahrzeug,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'fahrzeug([],0).\n fahrzeug([K|R], N):-fahrzeug(R,N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase], 
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-3>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl([],0).
anzahl([_|Rest], Anzahl):-Anzahl is Anzahl1+1, anzahl(Rest, Anzahl1).*/
test(exer13, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([_|Rest], Anzahl):-Anzahl is Anzahl1+1, anzahl(Rest, Anzahl1).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s3fa, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-4>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl(Z, Liste):-Liste=[], Z is 0.
anzahl(Z, Liste):-Liste=[Kopf|Rest], anzahl(Z1, Rest), Z is Z1+1.*/
test(exer13, 5, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(Z, Liste):-Liste=[], Z is 0.\n anzahl(Z, Liste):-Liste=[Kopf|Rest], anzahl(Z1, Rest), Z is Z1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5b, s7c, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-5>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).

/** 1 Punkte. Wir interpretieren die 3. Klausel als ein Kommmentar und tolerieren den Prädikatsname mit einem anderen.
length(N,L):-L=[], N is 0.
length(N,L):-L=[Kopf,Rest], N is N1+1.
length(Laenge, [_X,_Y]).*/
test(exer13, 6, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(N,L):-L=[], N is 0.\n splength(N,L):-L=[Kopf,Rest], N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre3a, pre3b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-6>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length(0,[]).
length(Bestand, [_|Rest]):-length(Bestand1, Rest), Bestand is Bestand1 +1.
*/
test(exer13, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0,[]).\n splength(Bestand, [_|Rest]):-splength(Bestand1, Rest), Bestand is Bestand1 +1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-7>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
zaehlen(Bestandsliste, Anzahl):- Bestandsliste=[], Anzahl is 0.
zaehlen(Bestandsliste, Anzahl):- Bestandsliste=[_|Rest], zaehlen(Rest, Anz), Anzahl is Anz+1.*/
test(exer13, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, zaehlen, 2, zaehlen/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, zaehlen, 2, zaehlen/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, zaehlen,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'zaehlen(Bestandsliste, Anzahl):- Bestandsliste=[], Anzahl is 0.\n zaehlen(Bestandsliste, Anzahl):- Bestandsliste=[_|Rest], zaehlen(Rest, Anz), Anzahl is Anz+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5b, s7c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-8>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
  
/** 2,5 Punkte
Testcase9
length(0, []).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1.
Anzahl_fahrzeuge(Liste, Anzahl):-length(Anzahl, Liste).
TODO: Approach applies helper predicate */

/** 3 Punkte
%wieviel(Anzahl, Liste)
wieviel(0,[]).
wieviel(Anzahl, [H|Rest]):-wieviel(Anzahl1, Rest), Anzahl is Anzahl1+1.*/
test(exer13, 10, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviel, 2, wieviel/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviel, 2, wieviel/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviel,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'wieviel(0,[]).\n wieviel(Anzahl, [H|Rest]):-wieviel(Anzahl1, Rest), Anzahl is Anzahl1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-10>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte. Wir tolerieren die Definition mit einem zusätzlicher Klausel.
length([],A,A).
length([_,T], Acc, E):-Acc1 is Acc+1, length(T,Acc1, E).
Accu Approach*/
test(exer13, 11, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, length, 3, anzahl/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, length, 3, anzahl/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, length, 3, anzahl/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,anzahl,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,length,anzahl/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred='anzahl(Liste, Zahl):-length(Liste, 0, Zahl).\n length([],A,A).\n length([_,T],Acc, E):-Acc1 is Acc+1, length(T,Acc1, E).\n',	
   ClauseTypes=[nonrecursive, basecase, recursivecase],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[s1f],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-11>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/** 1,5 Pnukte
bestand([],0).
bestand([H|T], N):-N is NT+1, bestand(T,NT).*/
test(exer13, 12, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')])],
  SPPred = 'bestand([],0).\n bestand([H|T], N):-N is NT+1, bestand(T,NT).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s3fa, post5a, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-12>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
bestand([], Anzahl).
bestand([Kopf|Rest], Anzahl):-Restanzahl is Anzahl+1, bestand(Rest, Restanzahl).*/
test(exer13, 13, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')])],
  SPPred = 'bestand([], Anzahl).\n bestand([Kopf|Rest], Anzahl):-Restanzahl is Anzahl+1, bestand(Rest, Restanzahl).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s3fa, s5a, s6b1, s7c, s4b1, post5a, post5b, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-13>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
 
/** 2,5 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length([],0).
length([_|R], Laenge):-length(R, Laenge1), Laenge is Laenge1 +1.*/
test(exer13, 14, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, bestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')])],
  SPPred = 'splength([],0).\n splength([_|R], Laenge):-splength(R, Laenge1), Laenge is Laenge1 +1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-14>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl([],0).
anzahl([_|T], X):- anzahl(T,X1), X is X1+1.*/
test(exer13, 15, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([_|T], X):- anzahl(T,X1), X is X1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-15>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl(X,Y):- N is 0, Y=[].
anzahl(X, [_|R]):- anzahl(X1,R), X is X1+1.*/
test(exer13, 16, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(X,Y):- N is 0, Y=[].\n anzahl(X, [_|R]):- anzahl(X1,R), X is X1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5b, s7c, post5b, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-16>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).

/** 3 Punkte
anzahl([],0).
anzahl([_|Rest], A):-anzahl(Rest, A1), A is A1+1.*/
test(exer13, 17, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([_|Rest], A):-anzahl(Rest, A1), A is A1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-17>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
%hp_anz(Bestand, Anzahl)
hp_anz([], Anzahl, Anzahl).
hp_anz([H|T], Acc, Anzahl):-Acc1 is Acc+1, hp_anz(T,Acc1, Anzahl).
anz(Bestand, Anzahl):-hp_anz(Bestand, 0, Anzahl).
Accu Approach */
test(exer13, 18, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, anz, 2, anz/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, anz, 2, anz/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, hp_anz, 3, anz/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, hp_anz, 3, anz/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, hp_anz, 3, anz/2, accu, 'A2', 2, +, number, 'accu'))],
 SPDecList=[declaration(sp,anz,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,hp_anz,anz/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
 SPPred ='hp_anz([], Anzahl, Anzahl).\n hp_anz([H|T], Acc, Anzahl):-Acc1 is Acc+1, hp_anz(T,Acc1, Anzahl).\n anz(Bestand, Anzahl):-hp_anz(Bestand, 0, Anzahl).\n',	
 ClauseTypes=[basecase, recursivecase, nonrecursive],
 diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
 Exp_EL=[post5a],
 getErrorIdList(ErrorList, EIDL),
 debug(test, '<exer13-18>EIDL=~w',[EIDL]),
 Exp_EL=EIDL.

/** 2 Punkte
lang(0,[]).
lang(N, [_|R]):-lang(N1,R), N is N1+1.*/
test(exer13, 19, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, lang, 2, lang/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, lang, 2, lang/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, lang,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'lang(0,[]).\n lang(N, [_|R]):-lang(N1,R), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-19>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl([],0).
anzahl([H|T], E):- anzahl(T,E1), E is E1+1.*/
test(exer13, 20, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([H|T], E):- anzahl(T,E1), E is E1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-20>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
autos([],0).
autos([_|Rest], Anzahl):-autos(Rest, Anzahl1), Anzahl is Anzahl1+1.*/
test(exer13, 21, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, autos, 2, autos/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, autos, 2, autos/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, autos,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'autos([],0).\n autos([_|Rest], Anzahl):-autos(Rest, Anzahl1), Anzahl is Anzahl1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-21>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
bestand(0,[]).
bestand(N, [_,_T]):-N is N1+1, bestand(N1, _T).*/
test(exer13, 22, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'bestand(0,[]).\n bestand(N, [_,_T]):-N is N1+1, bestand(N1,_T).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s1f, s3fa, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-22>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anz([],0).
anz([_|T], N):-anz(T,N1), N is N1+1.*/
test(exer13, 23, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anz, 2, anz/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anz, 2, anz/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anz,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anz([],0).\n anz([_|T], N):-anz(T,N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-23>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length(0,[]).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1*/
test(exer13, 24, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0,[]).\n splength(N, [_|Rest]):-splength(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-24>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl(0, []).
anzahl(Anz, [_|Rest]):-anzahl(Anz1, Rest), Anz is Anz1+1.*/
test(exer13, 25, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl,[d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(Anz, [_|Rest]):-anzahl(Anz1, Rest), Anz is Anz1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-25>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length([],0).
length([H|T], L):-length(T,L1), L is L1+1.*/
test(exer13, 26, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'splength([],0).\n splength([H|T], L):-splength(T,L1), L is L1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-26>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
count([], 0).
count([H|T], N):-count(T, N1), N is N1+1.*/
test(exer13, 27, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, count, 2, count/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, count, 2, count/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, count, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'count([], 0).\n count([H|T], N):-count(T, N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-27>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
anz_kfz([[]], 0).
anz_kfz([H|T], N):- N is N1+1, anz_kfz(T, N1).*/
test(exer13, 28, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anz_kfz, 2, anz_kfz/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anz_kfz, 2, anz_kfz/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anz_kfz, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anz_kfz([[]], 0).\n anz_kfz([H|T], N):- N is N1+1, anz_kfz(T, N1).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s7g1, s3fa, post5a, post7b], 
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-28>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
 

/**2,5 Punkte
wieviele(Nat_Zahl, Liste):- Liste=[], Nat_Zahl=0.
wieviele(Nat_Zahl, Liste):- Liste=[KZ,BJ|Rest], wieviele(Nat_Zahl1, Rest), N is N1+1.*/
test(exer13, 29, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviele, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'wieviele(Nat_Zahl, Liste):- Liste=[], Nat_Zahl=0.\n wieviele(Nat_Zahl, Liste):- Liste=[KZ,BJ|Rest], wieviele(Nat_Zahl1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s1e, s5a, s6b1, s4b1, post5b, post5c, post5c, post5c, post5c, post5c, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-29>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length(0, []).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1.*/
test(exer13, 30, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0, []).\n splength(N, [_|Rest]):-splength(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-30>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahl([[]], 0).
anzahl([[H]|T], N):- anzahl(T, N1), N is N1+1.*/
test(exer13, 31, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([[]], 0).\n anzahl([[H]|T], N):- anzahl(T, N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s7g1, post5a], 
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-31>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte. Wir tolerieren den Prädikatsname mit einem anderen Name.
length(0,[]).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1.*/
test(exer13, 32, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0,[]).\n splength(N, [_|Rest]):-splength(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-32>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
kfz_anz([],0).
kfz_anz([_|R], Anz):-kfz_anz(R, Anzr), Anz is Anzr+1.*/
test(exer13, 33, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfz_anz, 2, kfz_anz/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, kfz_anz, 2, kfz_anz/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, kfz_anz, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'kfz_anz([],0).\n kfz_anz([_|R], Anz):-kfz_anz(R, Anzr), Anz is Anzr+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-33>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl(0, []).
anzahl(N, [_|Rest]):-anzahl(N1, Rest), N is N1+1.*/
test(exer13, 34, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(N, [_|Rest]):-anzahl(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-34>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
laenge([], 0).
laenge([H|T], L):- laenge(T, LT), L is LT+1.*/
test(exer13, 35, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, laenge, 2, laenge/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, laenge, 2, laenge/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, laenge, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'laenge([], 0).\n laenge([H|T], L):- laenge(T, LT), L is LT+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-35>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
% wie viele(X, liste_vonKFZ).
wieviele(0, []).
wieviele(N, [K|R]):-wieviele(N1, R), N is N1+1.*/
test(exer13, 36, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviele, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'wieviele(0, []).\n wieviele(N, [K|R]):-wieviele(N1, R), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-36>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 1 Punkte
bestand([H|T], Bestand):- Bestand1 is Bestand+1, bestand(T, Bestand1).
bestand([], 0).*/
test(exer13, 37, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([H|T], Bestand):- Bestand1 is Bestand+1, bestand(T, Bestand1).\n bestand([], 0).\n',
  ClauseTypes=[recursivecase, basecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s3fa, s5a, s6b1, s4b1, post5a, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-37>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
anzahl(N, L):- L=[], N=0.
anzahl(N,L):- L=[Kopf|Rest], anzahl(N1, Rest), N is N1+1.*/
test(exer13, 38, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(N, L):- L=[], N=0.\n anzahl(N,L):- L=[Kopf|Rest], anzahl(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-38>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 1 Punkt
kfz_liste([], N).
kfz_liste([Kfz|Restliste_kfz], N):-kfz_liste([Restliste_kfz], N1), N is N1+1.*/
test(exer13, 39, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfz_liste, 2, kfz_liste/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, kfz_liste, 2, kfz_liste/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, kfz_liste, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'kfz_liste([], N).\n kfz_liste([Kfz|Restliste_kfz], N):-kfz_liste([Restliste_kfz], N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s3a, s7c, post5a, post5b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-39>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/** Testcase40
bestand(Liste, B):- length(Liste, B).
Approach applies helper predicate*/

/** 3 Punkte
bestand_anz(0, []).
bestand_anz(Anz, [_|Rest]):- bestand_anz(Anz1, Rest), Anz is Anz1+1.*/
test(exer13, 41, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand_anz, 2, bestand_anz/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand_anz, 2, bestand_anz/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand_anz, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'bestand_anz(0, []).\n bestand_anz(Anz, [_|Rest]):- bestand_anz(Anz1, Rest), Anz is Anz1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-41>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 punkte
anzahl([H|T], N):-anzahl(T, _N), N is _N +1.
anzahl([], 0).*/
test(exer13, 42, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([H|T], N):-anzahl(T, _N), N is _N +1.\n anzahl([], 0).\n',
  ClauseTypes=[recursivecase, basecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-42>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
bestand(X,L):-L=[], X is 0.
bestand(X,L):-L=[H|T], bestand(X1, T), X is X1+1. */
test(exer13, 43, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'bestand(X,L):-L=[], X is 0.\n bestand(X,L):-L=[H|T], bestand(X1, T), X is X1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5b, s7c, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-42>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).  

/** 3 Punkte
anzahl(0, []).
anzahl(N, [_|Tail]):-anzahl(N1, Tail), N is N1+1.*/
test(exer13, 44, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(N, [_|Tail]):-anzahl(N1, Tail), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-44>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
kfzbestand([], Anzahl).
kfzbestand([Kopf|Rest], Anzahl):-kfzbestand([Rest], Anzahl1), Anzahl1 is Anzahl+1.*/
test(exer13, 45, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfzbestand, 2, kfzbestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, kfzbestand, 2, kfzbestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, kfzbestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'kfzbestand([], Anzahl).\n kfzbestand([Kopf|Rest], Anzahl):-kfzbestand([Rest], Anzahl1), Anzahl1 is Anzahl+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s3a, s5a, s6b1, s7c, s4b1, post5a, post5b, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-45>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).  

/** 3 Punkte
wieviele(0, []).
wieviele(Zahl, [_|Rest]):-wieviele(Zahl2, Rest), Zahl is Zahl2 +1.*/
test(exer13, 46, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviele, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'wieviele(0, []).\n wieviele(Zahl, [_|Rest]):-wieviele(Zahl2, Rest), Zahl is Zahl2 +1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-46>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
length(0, []).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1.*/
test(exer13, 47, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0, []).\n splength(N, [_|Rest]):-splength(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-47>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 1 Punkte
anzahl(X,Y):-anzahl2(X,[],Y).
anzahl2([],[],0).
anzahl2([],[_|_], Y).
anzahl2([H|X], Z,Y):-anzahl2(X,[H|Z],Y), Y is Y+1.*/
test(exer13, 48, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-	
   SPDecList=[declaration(sp,anzahl,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Anzahl der Kraftfahrzeuge')]),
	      declaration(sp,anzahl2,anzahl/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','list','Akkumulator'),d('A3','-','number','Anzahl der Kraftfahrzeuge')])],   	
   SPPred='anzahl(X,Y):-anzahl2(X,[],Y).\n anzahl2([],[],0).\n anzahl2([],[_|_], Y).\n anzahl2([H|X], Z,Y):-anzahl2(X,[H|Z],Y), Y is Y+1.\n',
   diagnose_declaration(13, SPDecList, DecMap, ErrorList, RelCounter), 
   Exp_EL=[d4],
   % EIDL=[]
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-dec48>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/**3 Punkte
kfanzahl([], 0).
kfanzahl([K|R], Anzahl):-kfanzahl(R, Anzahlvor), Anzahl is Anzahlvor+1.*/
test(exer13, 49, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfanzahl, 2, kfanzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, kfanzahl, 2, kfanzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, kfanzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'kfanzahl([], 0).\n kfanzahl([K|R], Anzahl):-kfanzahl(R, Anzahlvor), Anzahl is Anzahlvor+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-49>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
length([], 0).
length([_|R], Y):- length(R, X), Y=X+1.
% Length(Liste, Length)*/
test(exer13, 50, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'splength([], 0).\n splength([_|R], Y):-splength(R, X), Y=X+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s5a, s4f],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-50>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**
anzahl(X, Erg):-anzahl(X,0, Erg).
anzahl([], A,A).
anzahl([H|T], Acc, E):-Acc1 is Acc+1, anzahl(T, Acc1, E).
Accu Approach*/
test(exer13, 51, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, anzahl, 3, anz/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, anzahl, 3, anz/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, anzahl, 3, anz/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,anzahl,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,anzahl,anzahl/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred ='anzahl(X, Erg):-anzahl(X,0, Erg).\n anzahl([], A,A).\n anzahl([H|T], Acc, E):-Acc1 is Acc+1, anzahl(T, Acc1, E).\n',
   ClauseTypes=[nonrecursive, basecase, recursivecase],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[post5a],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-51>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/**2 Punkte 
bestand([], 0).
bestand([Kopf|Rest], X):-bestand(Rest, X1), X is X1+1.*/
test(exer13, 52, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([], 0).\n bestand([Kopf|Rest], X):-bestand(Rest, X1), X is X1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-52>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 1 Punkt
bestand(0, []).
bestand(X, [_,_|R]):-bestand(X1, R), X is X1+1.*/
test(exer13, 53, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'bestand(0, []).\n bestand(X, [_,_|R]):-bestand(X1, R), X is X1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s1f],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-53>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 3 Punkte
mylen([], 0).
mylen([Head|Tail], N):-mylen(N1, Tail), N is N1+1.
% Mylen(Kraftfahrzeugliste, Anzahl)*/
test(exer13, 54, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, mylen, 2, mylen2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, mylen, 2, mylen/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, mylen, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'mylen([], 0).\n mylen([Head|Tail], N):-mylen(N1, Tail), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s3a, s3c, s6b1, s1d2, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-54>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
length_kfz([], 0).
length_kfz([_|R], Laenge2):-length_kfz(R, Laenge1), Laenge2 is Laenge1+1.*/
test(exer13, 55, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, length_kfz, 2, length_kfz/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, length_kfz, 2, length_kfz/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, length_kfz, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'length_kfz([], 0).\n length_kfz([_|R], Laenge2):-length_kfz(R, Laenge1), Laenge2 is Laenge1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-55>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** 2 Punkte
anzahlz(N,L):-L=[], N is 0.
anzahlz(N,L):- L=[Kopf|Rest], anzahlz(N1, Rest), N is N1+1.*/
test(exer13, 56, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahlz, 2, anzahlz/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahlz, 2, anzahlz/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahlz, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahlz(N,L):-L=[], N is 0.\n anzahlz(N,L):- L=[Kopf|Rest], anzahlz(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5b, s7c, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-56>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).   

/**3 Punkte
anzahl(0, []).
anzahl(Zahl, [H|T]):-anzahl(Z, T), Zahl is Z+1.*/
test(exer13, 57, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(Zahl, [H|T]):-anzahl(Z, T), Zahl is Z+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-57>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
length(0, []).
length(N, [_|Rest]):-length(N1, Rest), N is N1+1.*/
test(exer13, 58, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, splength, 2, splength/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, splength, 2, splength/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, splength, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'splength(0, []).\n splength(N, [_|Rest]):-splength(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-58>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
anzahl(0, []).
anzahl(N, [_|Rest]):-anzahl(N1, Rest), N is N1+1.*/
test(exer13, 59, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(N, [_|Rest]):-anzahl(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-59>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl([], 0).
anzahl([_|T], X):-anzahl(T,Y), X is Y+1.*/
test(exer13, 60, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([], 0).\n anzahl([_|T], X):-anzahl(T,Y), X is Y+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-60>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
%wie viele(Anzahl, Liste)
wieviele(0, []).
wieviele(Anzahl, [_|Rest]):-wieviele(Anzahl1, Rest), Anzahl is Anzahl1+1.*/
test(exer13, 61, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviele, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'wieviele(0, []).\n wieviele(Anzahl, [_|Rest]):-wieviele(Anzahl1, Rest), Anzahl is Anzahl1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-61>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl_der_paare(0,[]).
anzahl_der_paare(N, [K|R]):-anzahl_der_paare(N1,R), N is N1+1.*/
test(exer13, 62, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl_der_paare, 2, anzahl_der_paare/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl_der_paare, 2, anzahl_der_paare/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl_der_paare, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl_der_paare(0,[]).\n anzahl_der_paare(N, [K|R]):-anzahl_der_paare(N1,R), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-62>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2.5 Punkte
anzkfz(X,Liste):-length(X, Liste).*/
test(exer13, 63, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzkfz, 2, anzkfz/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzkfz, 2, anzkfz/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzkfz, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzkfz(X,Liste):-length(X, Liste).\n',
  ClauseTypes=[nonrecursive],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g7],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-63>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**1,5 Punkte
bestand(N,L):-L=[], N=0.
bestand(N,L):-L=[Kopf|Rest], length(N1, Rest), N is N1+1.*/
test(exer13, 64, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'bestand(N,L):-L=[], N=0.\n bestand(N,L):-L=[Kopf|Rest], length(N1, Rest), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre3a, pre3b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-64>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
anz(_,[]).
anz(N, [H|T]):-anz(N1,T), N1 is N+1.*/
test(exer13, 65, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anz, 2, anz/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anz, 2, anz/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anz, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anz(_,[]).\n anz(N, [H|T]):-anz(N1,T), N1 is N+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5a, s6b1, s7c, s4b1, post5a, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-65>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 
 

/**2 Punkte
anzahl([_|Rest], Summe):- anzahl(Rest, Summe1), Summe is Summe1+1.*/
test(exer13, 66, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([_|Rest], Summe):- anzahl(Rest, Summe1), Summe is Summe1+1.\n',
  ClauseTypes=[recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g6],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-66>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 punkte
bestand([], X).
bestand([H|T], X):-bestand(T,X1), X1 is X+1.*/
test(exer13, 67, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([], X).\n bestand([H|T], X):-bestand(T,X1), X1 is X+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s5a, s6b1, s7c, s4b1, post5a, post5b, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-67>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**
b([], 0).
b([F_|Tail], S):-b(Tail, S1), S is S1+1.*/
test(exer13, 68, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, b, 2, b/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, b, 2, b/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, b, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'b([], 0).\n b([F_|Tail], S):-b(Tail, S1), S is S1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-68>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 punkte
bestand([],0).
bestand([H|T], Anzahl):-bestand(T, Anzahl1),Anzahl is Anzahl1+1.*/
test(exer13, 69, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([],0).\n bestand([H|T], Anzahl):-bestand(T, Anzahl1), Anzahl is Anzahl1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-69>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
wieviele([],0).
wieviele([K|R], E):-wieviele(R, EL), E is EL+1.*/
test(exer13, 70, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, wieviele, 2, wieviele/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, wieviele, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'wieviele([],0).\n wieviele([K|R], E):-wieviele(R, EL), E is EL+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-70>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl([],0).
anzahl([H|T], N):-anzahl(T,N1), N is N1+1.*/
test(exer13, 71, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([H|T], N):-anzahl(T,N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-71>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
laenge([], 0).
laenge([K|R], Anz):-laenge(R, Anz), Laenge is LaengeZ+1.*/
test(exer13, 72, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, laenge, 2, laenge/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, laenge, 2, laenge/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, laenge, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'laenge([], 0).\n laenge([K|R], Anz):-laenge(R, Anz), Laenge is LaengeZ+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s5a, s6b1, s4a1, s4b1, post5a, post5c, post5c, post7b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-72>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl([],0).
anzahl([H|Rest], Bestand):-anzahl(Rest, Restbestand), Bestand is Restbestand+1.*/
test(exer13, 73, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([],0).\n anzahl([H|Rest], Bestand):-anzahl(Rest, Restbestand), Bestand is Restbestand+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-73>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
count([], 0).
count([H|T], N):-count(T, N), N is N+1. */
test(exer13, 74, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, count, 2, count/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, count, 2, count/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, count, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'count([], 0).\n count([H|T], N):-count(T, N), N is N+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s4a1, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-74>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
anzahl([], 0).
anzahl([X|Y], N):-anzahl(Y,N1), N is N1+1.*/
test(exer13, 75, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'anzahl([], 0).\n anzahl([X|Y], N):-anzahl(Y,N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-75>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte
bestand([], 0).
bestand([_|Y], N):- bestand(Y,N1), N is N1+1.*/
test(exer13, 76, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([], 0).\n bestand([_|Y], N):- bestand(Y,N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-76>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
anzahl2([], X,X).
anzahl2([A|B], C,X):-D is C+1, anzahl2(B,D,X).
anzahl1(X,Y):-anzahl2(X,0,Y).
Accu Approach */
test(exer13, 77, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, anzahl1, 2, anzahl1/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, anzahl1, 2, anzahl1/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, anzahl2, 3, anzahl1/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, anzahl2, 3, anzahl1/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, anzahl2, 3, anzahl1/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,anzahl1,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	      declaration(sp,anzahl2,anzahl1/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred ='anzahl2([], X,X).\n anzahl2([A|B], C,X):-D is C+1, anzahl2(B,D,X).\n anzahl1(X,Y):-anzahl2(X,0,Y).\n',
   ClauseTypes=[basecase, recursivecase, nonrecursive],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[post5a],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-77>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/**2.5 Punkte
anzahl(0, []).
anzahl(N, [_|R]):-anzahl(N-1, R).*/
test(exer13, 78, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, anzahl, 2, anzahl/2, main, 'A1', 1, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, anzahl, [d('A1','-','number','Summe'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'anzahl(0, []).\n anzahl(N, [_|R]):-anzahl(N-1, R).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-78>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
bestand([],0).
bestand([_|Rest], N):-bestand(Rest, N1), N is N1+1.*/
test(exer13, 79, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
		  predicatedec(sp, bestand, 2, bestand/2, main, 'A2', 2, -, number, 'Summe'))],	
  SPDecList=[declaration(sp, bestand, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Summe')])],
  SPPred = 'bestand([],0).\n bestand([_|Rest], N):-bestand(Rest, N1), N is N1+1.\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer13-79>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.


/**3 Punkte
wieviele1(Liste, Ausg):-wieviele(Liste, Ausg, Acc).
wieviele([], Acc, Acc).
wieviele([Kopf|Rest], Ausg, Acc):-Acc1 is Acc+1, wieviele(Rest, Ausg, Acc1).
Accu Approach*/
test(exer13, 80, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, wieviele1, 2, wieviele1/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, wieviele1, 2, wieviele1/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, wieviele, 3, wieviele1/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, wieviele, 3, wieviele1/2, accu, 'A2', 2, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, wieviele, 3, wieviele1/2, accu, 'A3', 3, +, number, 'accu'))],
   SPDecList=[declaration(sp,wieviele1,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	     declaration(sp,wieviele,wieviele1/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe'),d('A3','+','number','accu')])],
   SPPred ='wieviele1(Liste, Ausg):-wieviele(Liste, Ausg, Acc).\n wieviele([], Acc, Acc).\n wieviele([Kopf|Rest], Ausg, Acc):-Acc1 is Acc+1, wieviele(Rest, Ausg, Acc1).\n',	
   ClauseTypes=[nonrecursive, basecase, recursivecase],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[post5a, post5c],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-80>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/**2 Punkte
kf(Ls, E):-kf_rec(Ls,0,E).
kf_rec([H|T], A, E):-A1 is A+1, kf_rec(T,A1,E).
kf_rec([],E,E).
Accu Approach*/
test(exer13, 81, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
 DecMap=[map(dec,predicatedec(tp,tpbestand,2,tpbestand/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
	     predicatedec(sp, kf, 2, kf/2, main, 'A1', 1, +, list, 'Bestandsliste')), 
	 map(dec,predicatedec(tp, tpbestand, 2, tpbestand/2, main,'Arg2',2,-,number,['Bestand']),
	     predicatedec(sp, kf, 2, kf/2, main, 'A2', 2, -, number, 'Summe')),

	 map(dec,predicatedec(tp,tpbestandaccu,3,tpbestand/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, kf_rec, 3, kf/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpbestandaccu, 3,tpbestand/2, accu,'Arg2',2,-,number,['Bestand']), 
	     predicatedec(sp, kf_rec, 3, kf/2, accu, 'A3', 3, -, number, 'Summe')),
	 map(dec, predicatedec(tp, tpbestandaccu, 3, tpbestand/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, kf_rec, 3, kf/2, accu, 'A2', 2, +, number, 'accu'))],
   SPDecList=[declaration(sp,kf,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe')]),
	     declaration(sp,kf_rec,kf/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
   SPPred ='kf(Ls, E):-kf_rec(Ls,0,E).\n kf_rec([H|T], A, E):-A1 is A+1, kf_rec(T,A1,E).\n kf_rec([],E,E).\n',	
   ClauseTypes=[nonrecursive, recursivecase, basecase],
   diagnose_predicate(13, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
   Exp_EL=[post5a],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer13-81>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.


%--------------------------------------------------------------------%
% Exercise 5d, Klausur ws99/00a 18.02.2000 (108 Teilnehmer)
% 38 Solutions, 2 not understandable (Testcase2, 36); 2 not analysable (Testcase19, 35) using helper predicates 
/**Der Bestand an Kraftfahrzeugen einer Firma sei als Liste von zweielementigen Listen gegeben, wobei das erste Element einer Unterliste das polizeiliche Kennzeichen und das zweite Baujahr angibt, z.B. [[hh-gu_12-67, 1992], [hh-wa_34-25, 1987], [hh-ig_84-62, 1998], ...[hh-ba_39-29, 1983]]. Die Leitung des Unternehmens benötigt einen Überblick über die Alterstruktur der vorhandenen Fahrzeuge und bittet sie um verschiedene Informationen. Definieren Sie ein Prädikat, das das Baujahr des ältesten Fahrzeugs ermittelt.*/

/**1 Punkt
baujahr([],[]).
baujahr([[H|T]|T2], [X]):-X>T, baujahr([T2], X).*/
test(exer14, 1, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, baujahr, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'baujahr([],[]).\n baujahr([[H|T]|T2], [X]):-X>T, baujahr([T2], X).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre2e, pre2e],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-1>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**4 Punkte. Testcase2
TODO: Nicht diagnostizierbar
ch_bj(Ls, E):-ch_bj_rec(ls,1999,E).
ch_bj_rec([], [N,J|T3], J).
ch_bj_rec([[H|T]|T2], [N,J|T3], E):-
	T<J, ch_bj_rec(T2, [H,T,N,J|T3], E).
ch_bj_rec([[H|T]|T2], [N,J|T3], E):-
	T>=J, ch_bj_rec(T2, [N,J|T3], E).*/

/**1 Punkte
fahrzeug([],[]).
fahrzeug([_,K|R], [H|T]):-K>T, fahrzeug(R,[H|T]).
fahrzeug([_,K|R], [H|T]):-K<T, fahrzeug(R,[_|K]).*/
test(exer14, 3, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, fahrzeug, 2, fahrzeug/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, fahrzeug, 2, fahrzeug/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, fahrzeug, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred='fahrzeug([],[]).\n fahrzeug([_,K|R], [H|T]):-K>T, fahrzeug(R,[H|T]).\n fahrzeug([_,K|R], [H|T]):-K<T, fahrzeug(R,[_|K]).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre2e, pre2e, pre2e],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-3>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte. Wir ignorieren die letzte Klausel und zerlegt die durch ; kombinierte Subziele in 2 Klauseln
% aeltestes_fahrzeug(Bestandsliste, Baujahr)
aeltestes([], Aeltestes).
aeltestes([[_|Baujahr]|Restliste], Aeltestes):-Baujahr<Aeltestes, aeltestes(Restliste, Baujahr); aeltestes(Restliste, Aeltestes).
aeltestes_fahrzeug([[_|Baujahr]|Restliste], Baujahr):-aeltestes(Restliste, Baujahr).*/
test(exer14, 4, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, aeltestes, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'aeltestes([], Aeltestes).\n aeltestes([[_|Baujahr]|Restliste], Aeltestes):-Baujahr<Aeltestes, aeltestes(Restliste, Baujahr).\n aeltestes([[_|Baujahr]|Restliste], Aeltestes):-aeltestes(Restliste, Aeltestes).\n',
  ClauseTypes=[basecase,recursivecase,recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s3fa, s7e, s8i, s8i, s8j, s4a1, post5a, post5b, post7a],	
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-4>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
 

/** 1 Punkte
jahr([],[]).
jahr([K,Jahr|Rest], Erg):-jahr(Rest, [Jahr|Erg]).*/
test(exer14, 5, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-	
   SPDecList=[declaration(sp,jahr,[d('A1','+','list','Bestandsliste'), d('A2','-','list','Baujahr des ältesten Fahrzeugs')])],
   SPPred='jahr([],[]).\n jahr([K,Jahr|Rest], Erg):-jahr(Rest, [Jahr|Erg]).\n',
   diagnose_declaration(14, SPDecList, DecMap, ErrorList, RelCounter), 
   Exp_EL=[d4],
   getErrorIdList(ErrorList, EIDL),
   debug(test, '<exer14-dec5>EIDL=~w',[EIDL]),
   Exp_EL=EIDL.

/**2 Punkte
baujahr([],2000).
baujahr([[H,Bj,_]|T], Bj):-Bj<Bj2, baujahr(T,Bj2).*/
test(exer14, 6,	SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, baujahr, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'baujahr([],2000).\n baujahr([[H,Bj,_]|T], Bj):-Bj<Bj2, baujahr(T,Bj2).\n',
  ClauseTypes=[basecase,recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s3fa, s7e, s7k, s8n, s7h, post5a, post7a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-6>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
 
/**4 Punkte
aeltestes([], 2000).
aeltestes([[_|Jahr]|Rest], AltesJahr):- Jahr <AltesJahr, AltesJahr is Jahr, aeltestes(Rest, AltesJahr).
aeltestes([[_|Jahr]|Rest], A):- Jahr>=A, aeltestes(Rest,A).*/
test(exer14, 7, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, aeltestes, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'aeltestes([],2000).\n aeltestes([[_|Jahr]|Rest],AltesJahr):-Jahr<AltesJahr, AltesJahr is Jahr, aeltestes(Rest,AltesJahr).\n aeltestes([[_|Jahr]|Rest],A):-Jahr>=A, aeltestes(Rest,A).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s3fa, s3fa, s5b, s7e, s7k, s8j, s8n, s4a1, post7a, post7a],      
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-7>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).  

/**5 Punkte
das_aelteste(Bestand, Ausgabe):-hpdas_aelteste(Bestand, 9999, Ausgabe).
hpdas_aelteste([[_|BJ]|Rest], AEBJ, Ausg):- AEBS>BS, hpdas_aelteste(Rest, BJ, Ausg).
hpdas_aelteste([[_,BJ]|Rest], AEBJ, Ausg):-AEBJ=<BJ, hpdas_aelteste(Rest, AEBJ, Ausg).
Accu approach*/
test(exer14, 8, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, das_aelteste, 2, das_aelteste/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, das_aelteste, 2, das_aelteste/2, main, 'A2', 2, -, number, 'Ältesten')),

	  map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, hpdas_aelteste, 3, das_aelteste/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, hpdas_aelteste, 3, das_aelteste/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, hpdas_aelteste, 3, das_aelteste/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,das_aelteste,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
	     declaration(sp,hpdas_aelteste,das_aelteste/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'das_aelteste(Bestand,Ausgabe):-hpdas_aelteste(Bestand,9999,Ausgabe).\n hpdas_aelteste([[_|BJ]|Rest],AEBJ,Ausg):-AEBS>BS, hpdas_aelteste(Rest, BJ, Ausg).\n hpdas_aelteste([[_,BJ]|Rest], AEBJ, Ausg):-AEBJ=<BJ, hpdas_aelteste(Rest, AEBJ, Ausg).\n',
  ClauseTypes=[nonrecursive, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g6],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-8>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**5,5 Punkte. We added manually a clause which call the accu predicate.
amaeltesten([], Acc, Acc).
amaeltesten([[K,BS]|T], Acc, E):-BJ=<Acc, amaeltesten(T,BJ,E); BJ>Acc, amaeltesten(T,Acc,E).*/
test(exer14, 9, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, das_aelteste, 2, das_aelteste/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, das_aelteste, 2, das_aelteste/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, amaeltesten, 3, das_aelteste/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, amaeltesten, 3, das_aelteste/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, amaeltesten, 3, das_aelteste/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,das_aelteste,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,amaeltesten,das_aelteste/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'das_aelteste(Bestand,Ausgabe):-amaeltesten(Bestand,9999,Ausgabe).\n amaeltesten([],Acc,Acc).\n amaeltesten([[K,BS]|T],Acc,E):-BJ=<Acc, amaeltesten(T,BJ,E).\n amaeltesten([[K,BS]|T],Acc,E):-BJ>Acc, amaeltesten(T,Acc,E).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s8i, s8i, s8j, s8j, s1d2, s1d2, s1d2, post5a, post5a, post5a, post5a, post5c, post7a, post7a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-9>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).  

/**4 Punkte
aeltestes(Bj, []).
aeltestes(Bj1, [[_,Bj]|T]):- Bj1<Bj, aeltestes(Bj, T).
aeltestes(Bj1, [[_,Bj]|T]):- Bj1>=Bj, aeltestes(Bj1, T).*/
test(exer14, 10, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):- 
  SPDecList=[declaration(sp,aeltestes,[d('A1','+','list','Bestandsliste'), d('A2','-','list','Baujahr des ältesten Fahrzeugs')])],
  SPPred='aeltestes(Bj, []).\n aeltestes(Bj1, [[_,Bj]|T]):- Bj1<Bj, aeltestes(Bj, T).\n aeltestes(Bj1, [[_,Bj]|T]):- Bj1>=Bj, aeltestes(Bj1, T).\n',
  diagnose_declaration(14, SPDecList, DecMap, ErrorList, RelCounter), 
  Exp_EL=[d4], 
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-10>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**5 Punkte
oldes_h([], [Kkz, Jahr], [Fkz, Jahr]).
oldes_h([[Fkz,Jahr]|Rest], [OFkz, OJahr], Erg):-Jahr >OJahr, oldes_h(Rest, [OFkz, OJahr], Erg).
oldes_h([[Fkz,Jahr]|Rest], [OFkz, OJahr], Erg):-Jahr=<OJahr, oldes_h(Rest, [Fkz, Jahr], Erg).
Accu Approach */
test(exer14, 11, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):- 
  SPDecList=[declaration(sp,oldes_h,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,oldes_h,oldes_h/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','list','accu'),d('A3','-','list','Baujahr')])],
  SPPred='oldes_h([], [Kkz, Jahr], [Fkz, Jahr]).\n oldes_h([[Fkz,Jahr]|Rest], [OFkz, OJahr], Erg):-Jahr >OJahr, oldes_h(Rest, [OFkz, OJahr], Erg).\n oldes_h([[Fkz,Jahr]|Rest], [OFkz, OJahr], Erg):-Jahr=<OJahr, oldes_h(Rest, [Fkz, Jahr], Erg).\n',
  diagnose_declaration(14, SPDecList, DecMap, ErrorList, RelCounter),  
  Exp_EL=[d4, d4],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-dec11>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
aeltestes(Bauj, [[Nr, Bauj2]|Rest]):-Bauj2<Bauj, aeltestes(Bauj2, Rest).
aeltestes(Bauj, [[Nr,Bauj2]|Rest]):-Bauj2>=Bauj, aeltestes(Bauj, Rest).
aeltestes(Bauj, []).*/
test(exer14, 12, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A1', 1, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, aeltestes, [d('A1','-','number','Ältesten'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'aeltestes(Bauj, [[Nr, Bauj2]|Rest]):-Bauj2<Bauj, aeltestes(Bauj2, Rest).\n aeltestes(Bauj, [[Nr,Bauj2]|Rest]):-Bauj2>=Bauj, aeltestes(Bauj, Rest).\n aeltestes(Bauj, []).\n',
  ClauseTypes=[recursivecase, recursivecase, basecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s3fa, s3fa, s7e, s8j, s8n, s4a1, post5a, post5a, post5b, post7a, post7a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-12>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**5 Punkte. Erstaunlich: dies Prädikat funktioniert tatsächlich, solange das älteste Fahrzeug eindeutig ist.
oldest(Liste, J, Erg):- length(Erg, 1), older(List, J, Erg).
oldest(List, J, Erg):- J1 is J+1, oldest(List, J1, Erg).*/
test(exer14, 13, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):- 
  SPDecList=[declaration(sp,oldest,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten'), d('A3','-','list','List des ältesten Fahrzeugs')])],
  SPPred='oldest(Liste, J, Erg):- length(Erg, 1), older(List, J, Erg).\n oldest(List, J, Erg):- J1 is J+1, oldest(List, J1, Erg).\n',
  diagnose_declaration(14, SPDecList, DecMap, ErrorList, RelCounter),  
  Exp_EL=[d2b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-dec13>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
aeltestes([], []).
aeltestes([KZ, BJ, KZ1, BJ1|Rest], [KZ, BJ, RestX]):- NJ<BJ1,aeltestes([KZ1, BJ1|Rest], [RestX]).
aeltestes([KZ, BJ, KZ1,BJ1|Rest], [KZ1, BJ1,RestX]):- BJ>BJ1,aeltestes([KZ, BJ|Rest], [KZ,BJ|RestX]).*/
test(exer14, 14, SPDecList, _ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):- 
  SPDecList=[declaration(sp,aeltestes,[d('A1','+','list','Bestandsliste'),d('A2','-','list','Ältesten')])],
  SPPred='aeltestes([], []).\n aeltestes([KZ, BJ, KZ1, BJ1|Rest], [KZ, BJ, RestX]):- NJ<BJ1,aeltestes([KZ1, BJ1|Rest], [RestX]).\n aeltestes([KZ, BJ, KZ1,BJ1|Rest], [KZ1, BJ1,RestX]):- BJ>BJ1,aeltestes([KZ, BJ|Rest], [KZ,BJ|RestX]).\n',
  diagnose_declaration(14, SPDecList, DecMap, ErrorList, RelCounter),  
  Exp_EL=[d4],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-dec14>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/** % maxaltF(Liste, Kfz, Erg).
maxalt_f([[X|_]], X).
maxalt_f([[Kfz|Alter], [_|Alter2]|Rest], Erg):-	Alter>Alter2, maxalt_f([[Kfz|Alter]|Rest], Erg).
maxalt_f([_|Alter], [[Kfz|AlterZ]|Rest], Erg):- Alter=<Alter2, maxalt_f([[Kfz|Alter2]|Rest], Erg).*/
test(exer14, 15, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, maxalt_f, 2, maxalt_f/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, maxalt_f, 2, maxalt_f/2, main, 'A1', 1, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, maxalt_f, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'maxalt_f([[X|_]], X).\n maxalt_f([[Kfz|Alter], [_|Alter2]|Rest], Erg):-Alter>Alter2,maxalt_f([[Kfz|Alter]|Rest], Erg).\n 
maxalt_f([_|Alter], [[Kfz|AlterZ]|Rest], Erg):- Alter=<Alter2, maxalt_f([[Kfz|Alter2]|Rest], Erg).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre1, pre2e, pre2e, pre3b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-15>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**2 Punkte. We split the 2nd clause into 2 clauses manually because of using ;
kfz_sw([], Bj).
kfz_sw([[_|Jahr]|R], Bj):- kfz_sw(R,Bj), Bj<Jahr; kfz_sw(R, Bj), Bj is Jahr.*/
test(exer14, 16, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfz_sw, 2, maxalt_f/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, kfz_sw, 2, maxalt_f/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, kfz_sw, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'kfz_sw([],Bj).\n kfz_sw([[_|Jahr]|R],Bj):- kfz_sw(R,Bj), Bj<Jahr.\n kfz_sw([[_|Jahr]|R],Bj):-kfz_sw(R,Bj), Bj is Jahr.\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s5b, s7e, s8i, s8i, s4a1, post5b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-16>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**4 Punkte
oldie(Liste, BJ):-flatten(Liste, FlattList),firstout(Flattlist, BjListe),max(BjListe, BJ).

firstout([], []).
firstout([A], []).
firstout([A,B|T], [B|N]):-firstout(T,N).

max([A], A).
max([A,B], A):-A>B.
max([B,A], B):- B>A.
max([A|T], A):- max(T,A).*/
test(exer14, 17, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, oldie, 2, oldie/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, oldie, 2, oldie/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, oldie, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')]),
	     declaration(sp, firstout, oldie/2, helper, [d('A1','+','list','Bestandsliste'), d('A2','-','list','Älteren')]),
	     declaration(sp, max, oldie/2, helper, [d('A1','+','list','Liste'), d('A2','-','number','Maximum')])
	    ],
  SPPred = 'oldie(Liste, BJ):-flatten(Liste, FlattList),firstout(Flattlist, BjListe),max(BjListe, BJ).\n firstout([],[]).\n firstout([A],[]).\n firstout([A,B|T],[B|N]):-firstout(T,N).\n max([A],A).\n max([A,B],A):-A>B.\n max([B,A],B):-B>A.\n max([A|T],A):-max(T,A).\n',
  ClauseTypes=[nonrecursive, basecase, basecase, recursivecase, basecase, basecase, basecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g7],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-17>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**6 Punkte. Wir ignorieren die letzte Klausel und zerlegt die durch ; kombinierte Subziele in 2 Klauseln.
aeltestes_baujahr([[A,J]], J).
aeltestes_baujahr([[A,J1]|R], J):-aeltestes_baujahr(R, J2), (<(J1,J2), J=J1; not(<(J1,J2)), J=J2).*/
test(exer14, 18, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes_baujahr, 2, aeltestes_baujahr/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes_baujahr, 2, aeltestes_baujahr/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, aeltestes_baujahr, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'aeltestes_baujahr([[A,J]], J).\n aeltestes_baujahr([[A,J1]|R], J):-aeltestes_baujahr(R, J2), <(J1,J2), J=J1.\n aeltestes_baujahr([[A,J1]|R], J):-aeltestes_baujahr(R, J2), >=(J1,J2), J=J2.\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s8n, s8n, post5a, post5a, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-18>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).  

/**6 Punkte
Testcase 19: understandable, not analysable
aeltestes_auto([[_,Baujahr]], Baujahr).
aeltestes_auto(Autos, Baujahr):-Autos=[H|T],H=[Baujahr1,_],aeltestes_auto(T, Baujahr2),aeltestes(Baujahr1, Baujahr2, Baujahr).
aeltestes(B1, B2, E):- B1=<B2, E=B1.
aeltestes(B1, B2, E):-B1>B2, E=B2.
Helper Predicate Approach*/

/**5 Punkte
oldest([[_|CarYear]|T], X):-T=[], X=CarYear.
oldest([[_|CarYear]|T], X):-oldest(T, _X), CArYear<_X, X=CarYear.
oldest([[_,CArYear]|T], X):- oldest(T,_X), CArYear>=_X, X=_X.*/
test(exer14, 20, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, oldest, 2, oldest/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, oldest, 2, oldest/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, oldest, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'oldest([[_|CarYear]|T], X):-T=[], X=CarYear.\n oldest([[_|CarYear]|T], X):-oldest(T, _X), CarYear<_X, X=CarYear.\n 
oldest([[_,CArYear]|T], X):- oldest(T,_X), CArYear>=_X, X=_X.\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s8n, s8n, s4g],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-20>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).   

/**4 Punkte
Testcase21
aeltestes([K1, K2, K3, K4|Rest1], Baujahr, Auto):-aeltestes2(Rest1, K2, K1),K2 =<K4.
aeltestes([K1, K2, K3, K4|Rest1], Baujahr, Auto):-aeltestes2(Rest1, K4, K3),K2>K4.

aeltestes2([K1, K2, Rest1], Baujahr, Auto):-aeltestes2(Rest1, K2, K1),K2<Baujahr.
aeltestes2([K1,K2,Rest1], Baujahr, Auto):-aeltestes2(Rest1, Baujahr, Auto),K2>Baujahr.
aeltestes2([], Baujahr, Auto).
TODO: Helper Predicate Approach*/

/**2 Punkte
Testcase22
% very_old(Liste, Baujahr)
very_old(Liste, Baujahr):-baujahre(Liste, Baujahre),min(Baujahre, Baujahr).
baujahre([], []).
baujahre([[Kennz, Bauj],RL], [Bauj|RL2]):-baujahre(RL, RL2).
TODO: Helper Predicate Approach*/

/**5 Punkte
baujahr(Liste, Baujahr):-bau(Liste, 2000, Baujahr).
bau([], Acc, Acc).
bau([[_,Jahr]|Tail], Acc, Baujahr):-Jahr=<Acc, bau(Tail, Jahr, Baujahr).
bau([_|Tail], Acc, Baujahr):-bau(Tail, Acc, Baujahr).
Accu Approach*/
test(exer14, 23, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, baujahr, 2, baujahr/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, bau, 3, baujahr/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, bau, 3, baujahr/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, bau, 3, baujahr/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,baujahr,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,bau,baujahr/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'baujahr(Liste,Baujahr):-bau(Liste,2000,Baujahr).\n bau([],Acc,Acc).\n bau([[_,Jahr]|Tail],Acc,Baujahr):-Jahr=<Acc, bau(Tail, Jahr,Baujahr).\n bau([_|Tail],Acc,Baujahr):-bau(Tail,Acc,Baujahr).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[s1a2, s8i],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-23>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3,5 Punkte. Wir ignorieren die letzte Klausel und zerlegt die durch ; kombinierte Subziele in 2 Klauseln.
kfz_alt([_|[]], Fahrzeug).
kfz_alt([[Kopf|Rest1]|[Kopf1|Rest2]], Fahrzeug):-Rest1>Rest2, Fahrzeug is Rest1, kfz_alt([[Kopf1|Rest2]|[Kopf3|Rest3]], Fahrzeug);
Rest1 <Rest2, Fahrzeug is Rest2, kfz_alt([[Kopf1Rest2]|[Kopf3|Rest3]], Fahrzeug).*/
test(exer14, 24, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, kfz_alt, 2, kfz_alt/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, kfz_alt, 2, kfz_alt/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, kfz_alt, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'kfz_alt([_|[]], Fahrzeug).\n kfz_alt([[Kopf|Rest1]|[Kopf1|Rest2]], Fahrzeug):-Rest1>Rest2, Fahrzeug is Rest1, kfz_alt([[Kopf1|Rest2]|[Kopf3|Rest3]], Fahrzeug).\n kfz_alt([[Kopf|Rest1]|[Kopf1|Rest2]], Fahrzeug):-Rest1<Rest2, Fahrzeug is Rest2, kfz_alt([[Kopf1|Rest2]|[Kopf3|Rest3]], Fahrzeug).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s1f, s1f, s1f, s3a, s3a, s3fa, s3fa, s5b, s5b, s8i, s8i, s8j, s8j, s4a1, post5a, post5a, post5b, post5c, post5c, post5c, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-24>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).

/** We ignore the last clause
aeltestes([], Kfz).
aeltestes([[_,Baujahr],Tail], Kfz):-(>=(Baujahr, Kfz), aeltestes(Tail, Baujahr)); (>(Kfz, Baujahr)), aeltestes(Tail, Kfz).
alt(Liste):-aeltestes(Liste, Kfz), Kfz is 0.
*/
test(exer14, 25, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp, aeltestes, [d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'aeltestes([],Kfz).\n aeltestes([[_,Baujahr],Tail],Kfz):-(>=(Baujahr, Kfz), aeltestes(Tail, Baujahr)).\n aeltestes([[_,Baujahr],Tail],Kfz):-(>(Kfz, Baujahr)), aeltestes(Tail, Kfz).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s3fa, s3fa, s7e, s8j, s8n, s4a1, post5b, post7a, post7a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-25>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**5.5 Punkte. We ignore the typo error bj-baujahr
bj([], _).
bj([[_|Jahr]|Rest], Altjahr):-Jahr=<AltJahr, baujahr(Rest, Jahr).
bj([[_|Jahr]|Rest], Altjahr):- Jahr>AltJahr, baujahr(Rest, Altjahr).*/
test(exer14, 26, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp,bj,2,bj/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp,bj,2,bj/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp,bj,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'bj([],_).\n bj([[_|Jahr]|Rest],Altjahr):-Jahr=<Altjahr, bj(Rest,Jahr).\n bj([[_|Jahr]|Rest],Altjahr):-Jahr>Altjahr, bj(Rest, Altjahr).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s3fa, s3fa, s7e, s7k, s8j, s4a1, post7a, post7a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-26>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**5 Punkte
ganzalt(Liste, E):-ganzalt(Liste, 10000, E).
ganzalt([], A, A).
ganzalt([[Kenn|Alter]|T], Acc, E):-(Alter<Acc, ganzalt(T, Alter, E)); ganzalt(T, Acc, E).*/
test(exer14, 27, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, ganzalt, 2, ganzalt/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, ganzalt, 2, ganzalt/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, ganzalt, 3,ganzalt/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, ganzalt, 3, ganzalt/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, ganzalt, 3,ganzalt/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,ganzalt,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,ganzalt,ganzalt/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'ganzalt(Liste,E):-ganzalt(Liste,10000,E).\n ganzalt([],A,A).\n ganzalt([[Kenn|Alter]|T],Acc,E):-(Alter<Acc,ganzalt(T,Alter,E)).\n ganzalt([[Kenn|Alter]|T],Acc,E):-ganzalt(T,Acc,E).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred,  ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s1f, s8i, s8i, s8n, post5a, post5a, post5a],
  % EIDL=[post5a]
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-27>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 

/**3 Punkte. Wir tolerieren den Kopf der 1. Klausel mit einer weiteren Argumentstelle
old1([[H|T]|Rest]):- old(Rest,T,Jahr).
old([],J,J).
old([[H|T]|Rest],J,J1):- T<J, old(Rest,T,J1).
old([_|Rest],J,J1):-old(Rest,J,J1).
Accu Approach*/
test(exer14, 28, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, old1, 2, old1/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, old1, 2, old1/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, old, 3, old1/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, old, 3, old1/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, old, 3, old1/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,old1,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,old,old1/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'old1([[H|T]|Rest], Jahr):- old(Rest,T,Jahr).\n old([],J,J).\n old([[H|T]|Rest],J,J1):- T<J, old(Rest,T,J1).\n old([_|Rest],J,J1):-old(Rest,J,J1).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[pa2, s1a2, s1f, s7k, s8i, s8n, post5a, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-28>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 
  
/**5 Punkte
greis([[HI|[HG|[]]]|[]], HG).
greis([[HI|[HG|[]]]|T], HG):-greis(T,A), HG<A.
greis([H|T],A):-greis(T,A).*/
test(exer14, 29, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp,greis,2,greis/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp,greis,2,greis/2, main, 'A2', 2, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp,greis,[d('A1','+','list','Bestandsliste'), d('A2','-','number','Ältesten')])],
  SPPred = 'greis([[HI|[HG|[]]]|[]], HG).\n greis([[HI|[HG|[]]]|T], HG):-greis(T,A), HG<A.\n greis([H|T],A):-greis(T,A).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1a2, s8i, s8n, post5a, post5a, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-29>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP). 
 
/**4 Punkte
alt(Fahrzeuge,Baujahr):-a(Fahrzeuge,Akk,Baujahr).
a([],X,X).
a([[X|Y]|Z],Akk,Baujahr):-a(Z,Y,Baujahr), <(Y,Akk).
Accu Approach*/
test(exer14, 30, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, alt, 2, alt/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, alt, 2, alt/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, a, 3, alt/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, a, 3, alt/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, a, 3, alt/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,alt,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,a,alt/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'alt(Fahrzeuge,Baujahr):-a(Fahrzeuge,Akk,Baujahr).\n a([],X,X).\n a([[X|Y]|Z],Akk,Baujahr):-a(Z,Y,Baujahr), <(Y,Akk).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s1f, s8n, s7h, post5a, post5c],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-30>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).   

/**5 Punkte. Wir tolerieren, indem wir eine Hauptklausel hinzufügen.
alt([], [K|_], K).
alt([H|T], BA, E):- [_,BJ]=H, BJ<BA, alt(T, BJ, E).
alt([H|T], BA, E):-[_,BJ]=H, BJ>=BA, alt(T,BA,E).
Accu Approach */
test(exer14, 31, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, alt, 2, alt/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, alt, 2, alt/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, alt, 3, alt/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, alt, 3, alt/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, alt, 3, alt/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,alt,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,alt,alt/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'),d('A3','-','number','Summe')])],
  SPPred = 'alt(Fahrzeuge,Baujahr):-alt(Fahrzeuge,Akk,Baujahr).\n alt([],[K|_],K).\n alt([H|T],BA,E):-[_,BJ]=H, BJ<BA, alt(T,BJ,E).\n alt([H|T],BA,E):-[_,BJ]=H, BJ>=BA, alt(T,BA,E).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[pre2e],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-31>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**4,5 Punkte. Wir tolerieren die 3. Klausel mit einem zusätzlichem Argument.
aeltestes([], X, Jahr).
aeltestes([[_K|_R]|Rest], X, Jahr):-aeltestes(Rest, [[K|R]|X], Jahr), R>Jahr; aeltestes(Rest, [[K|R]|X], R), R=<Jahr.
aeltestes_kfz([[K|R]|Rest]):-aeltestes([[K|R]|Rest], [], R).
Accu Approach*/
test(exer14, 32, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes_kfz, 2, aeltestes_kfz/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes_kfz, 2, aeltestes_kfz/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, aeltestes, 3, aeltestes_kfz/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, aeltestes, 3, aeltestes_kfz/2, accu, 'A2', 2, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, aeltestes, 3, aeltestes_kfz/2, accu, 'A3', 3, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,aeltestes_kfz,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,aeltestes,aeltestes_kfz/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe'),d('A3','+','number','accu')])],
  SPPred = 'aeltestes([],X,Jahr).\n aeltestes([[K|R]|Rest],X,Jahr):-aeltestes(Rest,[[K|R]|X],Jahr), R>Jahr.\n aeltestes([[K|R]|Rest],X,Jahr):-aeltestes(Rest,[[K|R]|X],R), R=<Jahr.\n aeltestes_kfz([[K|R]|Rest], R):-aeltestes([[K|R]|Rest], [], R).\n',
  ClauseTypes=[basecase, recursivecase, recursivecase, nonrecursive],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[pa5, pa8, s1f, s1f, s3d, s3d, s7k, post5b, post5b],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-32>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).

/**2 Punkte
alt(Jahr, Liste):-Liste=[Kopf|Rest], Kopf=[Kz|Bj], Bj>Jahr, alt(Bj, Rest).*/
test(exer14, 33, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp,alt,2,alt/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp,alt,2,alt/2, main, 'A1', 1, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp,alt,[d('A1','-','number','Ältesten'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'alt(Jahr, Liste):-Liste=[Kopf|Rest], Kopf=[Kz|Bj], Bj>Jahr, alt(Bj, Rest).\n',
  ClauseTypes=[recursivecase], 
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g6],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-33>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**3 Punkte
aeltestes(Fahrzeug, Liste):-hilf(Liste, Fahrzeug, Min).
hilf([],_,_).
hilf([[[K,Bj]|_]]|T], Aeltes, Min):-Bj<Min, hilf(T, [K,Bj], Bj); hilf(T, Aeltes, Min).
Accu Approach*/
test(exer14, 34, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes_kfz/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes_kfz/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, hilf, 3, aeltestes/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, hilf, 3, aeltestes/2, accu, 'A2', 2, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, hilf, 3, aeltestes/2, accu, 'A3', 3, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,aeltestes,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,hilf,aeltestes/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Summe'),d('A3','+','number','accu')])],
  SPPred = 'aeltestes(Fahrzeug,Liste):-hilf(Liste,Fahrzeug,Min).\n hilf([],_,_).\n hilf([[[K,Bj]|_]|T],Aeltes,Min):-Bj<Min, hilf(T,[K,Bj],Bj).\n hilf([[[K,Bj]|_]|T],Aeltes,Min):-hilf(T,Aeltes,Min).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  Exp_EL=[g1],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-34>EIDL=~w',[EIDL]),
  Exp_EL=EIDL.

/**4 Punkte
Testcase35

% Ich erhalte eine Liste mit Baujahren
% baujahrliste(Listeeingabe, Baujahre)
baujahrliste([],[]).
baujahr([H|T], [B|RL]):-sortout(H,_,B), baujahrliste(T,RL).
aeltestes(Liste, B):-aelt_aus_bj(K,B), baujahrliste(Liste, K).

aelt_aus_bj([X],[X]).
aelt_aus_bj([K1,K2|R], E):-K1>K2, aelt_aus_bj([K2|R], E).
aelt_aus_bj([K1,K2|R], E):-K2>K1, aelt_aus_bj([K1|R],E).
TODO: Helper Predicate Approach*/

/**4 Punkte
Testcase36
older(Jahr, N):- <(Jahr, N), N is Jahr.
older(Jahr, N):- >=(Jahr, N).
max_old([], 2000).
max_old([H|T], N):-H=[_|J], older(J,N), max_old(T,R), older(R, N).
Das Baujahr des ältesten Fahrzeugs ist N für max_old(Fahrzeugliste, N).
TODO: Helper Predicate Approach*/

/**5 Punkte. Wir tolerieren die Verwechslung aeltestes und aeltestes2
aeltestes(Baujahr):-aeltestes2(Liste, 1999, Baujahr).
aeltestes([], Baujahr, Baujahr).
aeltestes2([[A,B]|C], X, Baujahr):-B<X, aeltestes(C,B,Baujahr).
aeltestes([[A,B]|C], X, Baujahr):-B>=X, aeltestes(C,X, Baujahr).
Accu Approach*/
test(exer14, 37, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A1',1, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp, aeltestes, 2, aeltestes/2, main, 'A2', 2, -, number, 'Ältesten')),

	 map(dec,predicatedec(tp,tpaltaccu,3,tpalt/2,accu,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']),
	     predicatedec(sp, aeltestes, 3, aeltestes/2, accu, 'A1', 1, +, list, 'Bestandsliste')),
	 map(dec, predicatedec(tp,tpaltaccu, 3,tpalt/2, accu,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']), 
	     predicatedec(sp, aeltestes, 3, aeltestes/2, accu, 'A3', 3, -, number, 'Baujahr')),
	 map(dec, predicatedec(tp, tpaltaccu, 3, tpalt/2, accu,'Arg3',3,+,number,['Akku, accu']), 
	     predicatedec(sp, aeltestes, 3, aeltestes/2, accu, 'A2', 2, +, number, 'accu'))
	 ],	 
  SPDecList=[declaration(sp,aeltestes,[d('A1','+','list','Bestandsliste'),d('A2','-','number','Ältesten')]),
      declaration(sp,aeltestes,aeltestes/2,accu,[d('A1','+','list','Bestandsliste'),d('A2','+','number','accu'), d('A3','-','number','Summe')])],
  SPPred = 'aeltestes(Liste, Baujahr):-aeltestes(Liste, 1999, Baujahr).\n aeltestes([], Baujahr, Baujahr).\n aeltestes([[A,B]|C], X, Baujahr):-B<X, aeltestes(C,B,Baujahr).\n aeltestes([[A,B]|C], X, Baujahr):-B>=X, aeltestes(C,X, Baujahr).\n',
  ClauseTypes=[nonrecursive, basecase, recursivecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s8n, s8n, post5a, post5a],
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-37>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).
 
/**3 Punkte. Wir ignorieren die ersten 2 Klauseln
baujahre([], []).
baujahre([[Kennzeichen,Baujahr]|R1], [Baujahr|R2]):-baujahre(R1, R2).
daf(Alter, []).
daf(Alter, [A1|R]):- Alter2 is A1, A1>Alter, daf(Alter2, R).
% daf(Alter, baujahre(Liste))*/
test(exer14, 38, SPDecList, ClauseTypes, DecMap, SPPred, ErrorList, RelCounter):-
  DecMap=[map(dec,predicatedec(tp,tpalt,2,tpalt/2,main,'Arg1',1,+,list,['Bestand an Kraftfahrzeugen','KFZ','Bestandsliste']), 
		  predicatedec(sp,daf,2,daf/2, main, 'A2',2, +, list, 'Bestandsliste')), 
	  map(dec,predicatedec(tp, tpalt, 2, tpalt/2, main,'Arg2',2,-,number,['Baujahr des ältesten Fahrzeugs']),
		  predicatedec(sp,daf,2,daf/2, main, 'A1', 1, -, number, 'Ältesten'))],	
  SPDecList=[declaration(sp,daf,[d('A1','-','number','Ältesten'), d('A2','+','list','Bestandsliste')])],
  SPPred = 'daf(Alter,[]).\n daf(Alter,[A1|R]):-Alter2 is A1, A1>Alter, daf(Alter2,R).\n',
  ClauseTypes=[basecase, recursivecase],
  diagnose_predicate(14, null, SPDecList, SPPred, ClauseTypes, DecMap, ErrorList, RelCounter),
  EXP=[s7e, s7h, s1a2, s3fa, s5b, s8i, s8j, s4a, post7a, post5b],  
  getErrorIdList(ErrorList, EIDL),
  debug(test, '<exer14-38>EIDL=~w',[EIDL]),
  sort(EXP, SortEXP),
  sort(EIDL, SortEXP).