Upload 1424 files

Algorithm-Writer-with-Lists/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2020, Lucian Green
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Algorithm-Writer-with-Lists/README.md

@@ -0,0 +1,195 @@
+<a href="https://github.com/luciangreen/Essay-Helper">Essay Helper</a> | <a href="https://github.com/luciangreen/Text-to-Breasonings">Text-to-Breasonings (Helps Earn High Distinctions)</a> | Grammar Logic (Helps Mind Map Details)
+
+# Algorithm Writer with Lists
+
+Generates random algorithms in List Prolog, which can be converted to a simple form similar to Prolog.
+
+* algwriter-lists-mr.pl - generates algorithms with combinations of other algorithms with vague mind reading
+* algwriter-lists-random.pl - generates algorithms with combinations of other algorithms at random
+* grammar_logic_to_alg.pl - takes text, randomly generates details and appropriate algorithms for A (agreement), B (disagreement) and solution to B based on approximate parts of speech and the Text to Breasonings dictionary.
+* grammar_logic_to_alg_random.pl - like the previous algorithm but randomly selects up to 10 sentences from the file to process.
+* random_dependencies.pl - generates random (meaningless) algorithm specifications.
+* combophil.pl - finds combinations of lines to write philosophies about.
+* combophil_grammar_logic_to_alg.pl - finds all combinations in lines to write philosophies and does what grammar_logic_to_alg.pl (above) does.
+* four_crosses.pl - finds 4 crosses to transition to PhD refinement.
+* combophil2qadb.pl - generates algorithms from dictionary.
+* mr_alg.pl and ya_phil_to_alg.pl - Yet Another Philosophy to Algorithm and Mind Read Algorithm (randomly produces 5 line algorithms with type checking, possibly about Lucian Academy philosophies).
+
+Please contact Lucian Green at <a href="mailto:luciangreen@lucianacademy.com">luciangreen@lucianacademy.com</a> with questions, comments and feedback about Algorithm Writer with Lists.
+
+# Getting Started
+
+Please read the following instructions on how to install the project on your computer for generating algorithms.
+
+# Prerequisites
+
+* Please download and install SWI-Prolog for your machine at `https://www.swi-prolog.org/build/`.
+
+# 1. Install manually
+
+Download <a href="http://github.com/luciangreen/Algorithm-Writer-with-Lists/">this repository</a>, the <a href="https://github.com/luciangreen/listprologinterpreter">List Prolog Interpreter Repository</a> and the <a href="https://github.com/luciangreen/Text-to-Breasonings">Text to Breasonings Repository</a>.
+
+# 2. Or Install from List Prolog Package Manager (LPPM)
+
+* Download the <a href="https://github.com/luciangreen/List-Prolog-Package-Manager">LPPM Repository</a>:
+
+```
+mkdir GitHub
+cd GitHub/
+git clone https://github.com/luciangreen/List-Prolog-Package-Manager.git
+cd List-Prolog-Package-Manager
+swipl
+['lppm'].
+lppm_install("luciangreen","Algorithm-Writer-with-Lists").
+halt
+```
+
+# Caution:
+
+follow instructions in <a href="https://github.com/luciangreen/Text-to-Breasonings/blob/master/Instructions_for_Using_texttobr(2).pl.txt">Instructions for Using texttobr(2)</a> when using texttobr, texttobr2 or mind reader to avoid medical problems.
+
+# Running Algorithm Writer with Lists with Mind Reader
+
+* In Shell:
+`cd Algorithm-Writer-with-Lists`
+`swipl`
+`['algwriter-lists-mr.pl'].`
+
+* Enter `algwriter(Algorithm),writeln1(Algorithm).`
+
+# Installing and Running Algorithm Writer with Lists at Random
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['algwriter-lists-random.pl'].
+```
+* Enter `algwriter(Algorithm),writeln1(Algorithm).`
+
+# Installing and Running Grammar and Logic to Algorithm
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['grammar_logic_to_alg.pl'].
+```
+* Enter sentences and lines to randomly process to give details and algorithms to into `"file.txt"` in the `"Text-to-Breasonings"` folder.  The output or the `gla.txt` file, depending on whether you run using (1) or (2) in the following will contain the sentences and algorithms with instructions about how to run them.
+
+* Enter `grammar_logic_to_alg1.` (1) or paste the contents of `grammar_logic_to_alg_sh.txt` into the Terminal window on Mac (2).
+
+# Installing and Running Grammar and Logic to Algorithm at Random
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['grammar_logic_to_alg_random.pl'].
+```
+* As stated above, rather than processing the whole file, this algorithm processes up to 10 random sentences.
+* Enter many sentences and lines to randomly process to give details and algorithms to into `"file.txt"` in the `"Algorithm-Writer-with-Lists"` folder.  The output or the `gla.txt` file, depending on whether you run using (1) or (2) in the following will contain the sentences and algorithms with instructions about how to run them.
+
+* Enter `grammar_logic_to_alg1.` (1) or paste the contents of `grammar_logic_to_alg_sh.txt` into the Terminal window on Mac (2).
+
+# Installing and Running Random Dependencies
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['random_dependencies.pl'].
+```
+* As stated above, the value of this algorithm's input is found by mentally inserting not and transformations.
+
+* Enter `random_dependencies(A),writeln1(A).`
+
+```
+[substring,[[duplicates,[[]]],[findall,[[add_number_to_list,[[split_into_sentences,[[sort,[[list_head,[[reverse,[[findall,[[string_to_list,[[or,[[and,[[delete,[[map,[[]]]]],[]]]]]]]]]]]]],[map,[[length,[[maximum,[[length,[[reverse,[[split_into_sentences,[[member,[[map,[[]]]]]]],[]]]]]]],[delete,[[get_item_n,[[],[and,[[]]]]],[reverse,[[]]]]]]],[]]]]]]]]]]]]]
+```
+
+# Installing and Running Combinations of Lines of Philosophy
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['combophil.pl'].
+```
+* Finds combinations of lines to write philosophies about with e.g. a combination of 2 lines:
+
+* Enter `combophil(2).`
+
+# Installing and Running Combinations of Lines of Philosophy with Grammar and Logic to Algorithm
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['combophil_grammar_logic_to_alg.pl'].
+```
+* Enter sentences and lines to intermix (warning: takes all combinations of verbs and non verbs in file) and randomly process to give details and algorithms to into `"file.txt"` in the `"Text-to-Breasonings"` folder.  The output in the following will contain the sentences and algorithms with instructions about how to run them.
+
+* Enter `combophil_grammar_logic_to_alg1.`
+
+# Installing and Running Four Crosses
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['four_crosses.pl'].
+```
+* Enter four levels of crosses of ideas to make a PhD-level connection.
+
+* Enter `four_crosses.`
+
+# grammar_logic_to_alg2.pl
+* Converts files from e.g. grammar_logic_to_alg.pl to simplified algorithms with more specific command names.  Breason out file.txt using <a href="https://github.com/luciangreen/Text-to-Breasonings">Text-to-Breasonings</a>, run grammar_logic_to_alg.pl, run
+grammar_logic_to_alg2.pl, then run <a href="https://github.com/luciangreen/Text-to-Breasonings">Text-to-Breasonings Reading Algorithm</a> on the grammar_logic_to_alg2.pl output.
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['grammar_logic_to_alg2.pl'].
+```
+* Enter the number of words in file.txt to replace with computational language (it learns as it goes).
+
+* Enter `grammar_logic_to_alg2(200).`
+
+# combophil2qadb.pl
+* Generates algorithms in qadb format from word dictionary.
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['combophil2qadb.pl'].
+```
+* Enter `.` or `\n` delimited algorithm ideas in `Text-to-Breasonings/file.txt` and enter:
+`combophil2qadb.`
+* Produces algorithms in `file-o.txt`.
+
+# Installing and Running Yet Another Philosophy to Algorithm and Mind Read Algorithm
+
+* Download this repository.
+* In SWI-Prolog, in the `"Algorithm-Writer-with-Lists"` folder, enter:
+```
+['ya_phil_to_alg.pl.pl'].
+
+```
+* As stated above, Yet Another Philosophy to Algorithm randomly produces 5 line algorithms with type checking about all sentences in `Lucian-Academy/`.
+
+
+* Enter `ya_phil_to_alg.`
+
+* Produces the file `yet_more_phil_algs.txt`, containing, for example:
+```
+...n,length,list,number,n,round,number,number,n,sqrt,number,number,n,sqrt,number,number,n,round,number,number,n,sqrt,number,number...
+```
+
+* To produce one five-line algorithm, enter `mr_alg(Commands).`, producing:
+
+* `Commands = [[[n,member],[[list],[_3386]]],[[n,member],[[list],[list]]],[[n,intersection],[[list],[list]]],[[n,member],[[list],[_5928]]],[[n,atom_string],[[atom],[string]]],[[n,string_length],[[string],[number]]]]`,
+
+* where this algorithm means, "Take a member (the second item, the first output of member) of a list, take a member list of this list, etc.".
+
+* Note: member(List,Item) is now member(Item,List) in List Prolog, which is different from the above.
+
+# Authors
+
+Lucian Green - Initial programmer - <a href="https://www.lucianacademy.com/">Lucian Academy</a>
+
+# License
+
+I licensed this project under the BSD3 License - see the <a href="LICENSE">LICENSE.md</a> file for details
+

Algorithm-Writer-with-Lists/algwriter-lists-mr.pl

@@ -0,0 +1,283 @@
+%% algwriter(A),write1(A).
+%% write data,fns in exec format
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+
+multiply(A,B,C) :- 
+C is A*B. 
+
+subtract(A,B,C) :- 
+C is A-B. 
+
+head(A,B) :- A=[B|_].
+
+tail(A,B) :- A=[_|B].
+
+wrap(A,B) :- B=[A].
+
+algwriter(Na) :- 
+notrace,
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	%%SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	splitfurther(BrDict0,BrDict01),
+	%%trace,
+	sort(BrDict01,BrDict02),
+makerandomlist(BrDict02,5,[],R0),makerandomlist(R0,3,[],R1),makerandomlist(R0,3,[],R2),wrap(R1,Nb1),wrap(R2,Nb2),append(Nb1,Nb2,Nb3),trialy2A([3,4,5,6,7,8],NFns),randomfns(NFns,Nb3,Na),!.
+makerandomlist(_,0,A,A).
+makerandomlist(List,A,C1,C) :- 
+not((=(A,0))),trialy2A(List,N1),%%random(R),multiply(R,L,R1),ceiling(R1,N1),
+wrap(N1,N2),append(C1,N2,Nb3),subtract(A,1,D),makerandomlist(List,D,Nb3,C).
+randomfns(1,B,Nb3):-randomlist(B,Na1),randomlist(B,Na2),randomfn(Na1,Na2,Nb),wrap(Nb,Nb2),append(B,Nb2,Nb3).%%write1(".").
+randomfns(A,B,C) :- not((=(A,1))),randomlist(B,Na1),randomlist(B,Na2),randomfn(Na1,Na2,Nb),wrap(Nb,Nb2),append(B,Nb2,Nb3),%%tail(B,T),
+	subtract(A,1,D),write(,),
+	randomfns(D,Nb3,C).
+randomlist(B,Na) :- %%List1=[1,2,3,4,5,6,7,9,10],
+length(B,L),length(C,L),append(C,_,B),trialy2A(C,Na).%%,random(R),length(B,Bl),multiply(R,Bl,N),ceiling(N,N1),getitemn(N1,B,Na).
+getitemn(0,_A,[]).
+getitemn(1,B,C) :- head(B,C).
+getitemn(A,B,C) :- not((=(A,1))),tail(B,T),subtract(A,1,D),getitemn(D,T,C).
+randomfn(A1,A2,B) :- repeat,trialy2A([1,3,4,5,7],N1),%%random(R),multiply(R,8,N),ceiling(N,N1),
+fna(N1,A1,A2,B).
+fna(1,A1,_A2,B) :- reverse(A1,[],B),write1([[n,reverse],[A1,[],B]]).
+%%fna(2,A1,_A2,B) :- sort0(A1,B),write1(sort0(A1,B)).
+fna(3,A1,A2,B) :- append1(A1,A2,B),write1([[n,append1],[A1,A2,B]]).
+fna(4,A1,A2,B) :- minus1(A1,A2,B),write1([[n,minus1],[A1,A2,B]]).
+fna(5,A1,A2,B) :- intersection1(A1,A2,[],B),write1([[n,intersection1],[A1,A2,[],B]]).
+%%fna(6,A1,A2,A2) :- mutually_exclusive(A1,A2),write1([[n,mutually_exclusive],[A1,A2]]).
+fna(7,A1,A2,B) :- duplicates(A1,A2,[],B),write1([[n,duplicates],[A1,A2,[],B]]).
+%%fna(8,A1,A2,A1) :- substring(A1,A2),write1([[n,substring],[A1,A2]]).
+reverse([],L,L).
+reverse(L,M,N) :- head(L,H),tail(L,T),wrap(H,H1),append(H1,M,O),reverse(T,O,N).
+sort0(L,N) :- sort1(L,[],N).
+sort1([],L,L).
+sort1(L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),maximum(T,H,M2,[],R),wrap(M2,M3),append(M1,M3,M4),sort1(R,M4,N).
+maximum([],L,L,R,R).
+maximum(L,M1,N,R1,R2) :- not((=(L,[]))),head(L,H),tail(L,T),(>=(M1,H)->(=(M2,M1),wrap(H,H2),append(R1,H2,R3));(=(M2,H),wrap(M1,M12),append(R1,M12,R3))),maximum(T,M2,N,R3,R2).
+map(_F,[],L,L).
+map(F,L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),functor(A,F,3),arg(1,A,M1),arg(2,A,H),arg(3,A,M2),A,map(F,T,M2,N).
+findall(_F,[],L,L).
+findall(F,L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),functor(A,F,2),arg(1,A,H),arg(2,A,M2),(A->((wrap(M2,M3),append(M1,M3,M4)));(=(M1,M4))),findall(F,T,M4,N).
+intersection1([],_A,L,L).
+intersection1(L1,L2,L3a,L3) :- head(L1,I1),tail(L1,L4),intersection2(I1,L2,[],L5),append(L3a,L5,L6),intersection1(L4,L2,L6,L3).
+intersection2(_A,[],L,L).
+intersection2(I1,L1,L2,L3) :- head(L1,I1),tail(L1,L4),wrap(I1,I11),append(L2,I11,L5),intersection2(I1,L4,L5,L3).
+intersection2(I1,L1,L2,L3) :- head(L1,I2),tail(L1,L4),not((=(I1,I2))),intersection2(I1,L4,L2,L3).
+append1(B,C,A) :- append(B,C,A).
+minus1(L,[],L).
+minus1(L1,L2,L3) :- head(L2,I1),tail(L2,L5),delete2(L1,I1,[],L6),minus1(L6,L5,L3).
+delete2([],_A,L,L).
+delete2(L1,I1,L2,L3) :- head(L1,I1),tail(L1,L5),delete2(L5,I1,L2,L3).
+delete2(L1,I1,L2,L3) :- head(L1,I2),tail(L1,L5),not((=(I1,I2))),wrap(I2,I21),append(L2,I21,L6),delete2(L5,I1,L6,L3).
+
+mutually_exclusive([],_L):-!.
+mutually_exclusive(L,M):-head(L,H),tail(L,T),membera3(M,H),mutually_exclusive(T,M),!.
+membera3([],_L):-!.
+membera3(L,M):-head(L,H),tail(L,T),not((=(M,H))),membera3(T,M),!.
+
+duplicates([],_L,S,S).
+duplicates(L,M,S1,S2):-head(L,H),tail(L,T),member(H,M),(deletea2(M,H,M1)->(true);(=(M,M1))),wrap(H,H1),append(S1,H1,S3),duplicates(T,M1,S3,S2),!.
+duplicates(L,M,S1,S2):-head(L,H),tail(L,T),not((membera4(M,H))),duplicates(T,M,S1,S2).
+deletea2([],_L,_M1):-fail.
+deletea2(L,M,T):-head(L,H),tail(L,T),=(M,H).
+deletea2(L,M,M1):-head(L,H),tail(L,T),not((=(M,H))),deletea2(T,M,M1).
+membera4([],_L):-fail.
+membera4(L,H):-head(L,H).
+membera4(L,M):-head(L,H),tail(L,T),not(M=H),membera4(T,M).
+
+substring([],[]).
+substring([],B):-not((=(B,[]))),fail.
+substring(A,B):-tail(A,At),(listhead(A,B)->(true);(substring(At,B))).
+listhead(_L,[]).
+listhead(A,B):-head(A,Ah),tail(A,At),head(B,Ah),tail(B,Bt),listhead(At,Bt).
+
+
+%%%%%%%%%%%%
+
+%%findbest(R,R) :-!.
+findbest2(R,Item):-
+	sort(R,RA),
+	reverse(RA,RB),
+	RB=[[_,Item]|_Rest].
+
+trialy2A([],R) :-
+	R=[[_,'A']].
+trialy2A(List,R) :-
+	notrace,trialy2B(List,R).%%,trace.
+trialy2B(List,R) :-
+	length(List,Length),
+	((Length=<9->
+		findr4(R4),
+		number_string(R4,R4A),
+		formr5([R4A],9,Length,R5),
+		findr(R5,List,R));
+	(Length=<99->
+		findr4(R41),
+		findr4(R42),
+		formr5([R41,R42],99,Length,R5),
+		findr(R5,List,R));
+	(Length=<999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		formr5([R41,R42,R43],999,Length,R5),
+		findr(R5,List,R));
+	(Length=<9999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		findr4(R44),
+		formr5([R41,R42,R43,R44],9999,Length,R5),
+		findr(R5,List,R));
+	(Length=<99999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		findr4(R44),
+		findr4(R45),
+		formr5([R41,R42,R43,R44,R45],99999,Length,R5),
+		findr(R5,List,R));
+	fail),
+	%%write1([r,R]),trace.
+	true.
+
+findr4(R4) :-
+		List1=[0,1,2,3,4,5,6,7,8,9],
+		Trials is 30,
+		trialy22(List1,Trials,[],R1),
+		findbest2(R1,R4).
+		%%number_string(R3,R2),
+formr5(RList,Upper,Length,R5) :-
+		%%findall(D,(member(C,RList),floor(C,D)),RList2),
+		concat_list2A(RList,R5A),
+		number_string(R5B,R5A),
+		R51 is floor((R5B/Upper)*Length),
+		(R5B=Upper->R5 is R51-1;R5=R51).
+findr(R4,List,R) :-
+		%%floor(R4,R4A),		
+		length(A,R4),
+		append(A,[R|_],List).
+
+	%%random_member(A,List),
+	%%R=[[_,A]].
+	
+	/**
+	length(List,L),
+	Trials is L*3,
+	trialy22(List,Trials,[],R).**/
+
+trialy22([],_,R,R) :- !.
+trialy22(List,Trials,RA,RB) :-
+	List=[Item|Items],
+	trialy21(Item,Trials,R1),
+	append(RA,[R1],RC),
+	trialy22(Items,Trials,RC,RB),!.
+
+trialy21(Label,Trials,RA) :-
+	trialy3(Trials,[],R),
+	aggregate_all(count, member(true,R), Count),
+	RA=[Count,Label].
+
+trialy3(0,R,R) :-!.
+trialy3(Trials1,RA,RB) :-
+	trialy1(R1),
+	append(RA,[R1],RC),
+	Trials2 is Trials1-1,
+	trialy3(Trials2,RC,RB),!.
+	
+%% try other nouns
+trialy1(R1) :-
+	%%control11(A1),
+	%%repeat,
+	trial0(A22), %% Control
+	sum(A22,0,S22),
+	mean(S22,A1),
+	%%repeat,
+	trial0(A21), %% Test 1
+	sum(A21,0,S02),
+	mean(S02,A2),
+	(A1>A2->R1=true;R1=fail).
+
+trial0(S3) :- N is 10, trial1(N,[],S),trial01(S,S3).
+trial01(S1,S3) :-
+	sort(S1,S),
+	%%midpoint(S,MP),
+	halves(S,H1,H2),
+	midpoint(H1,Q1),
+	midpoint(H2,Q3),
+	IQR is Q3-Q1,
+	sum(S,0,S02),
+	mean(S02,Mean),
+	furthestfrommean(S,Mean,V),
+	D1 is 1.5*IQR,
+	D2 is V-Mean,
+	(D2>D1->(delete(S,V,S2),trial01(S2,S3));S=S3).
+	
+%%trial1(0,[],_A) :- fail,!.
+trial1(0,A,A) :- !.
+trial1(N,A,B) :- mindreadtest(S), append(A,[S],A2),
+	N1 is N-1,trial1(N1,A2,B).
+	
+%%midpoint([],0) :- !.
+
+midpoint(S,MP) :-
+%%	not(S=[]),
+	length(S,L),
+	A is mod(L,2),
+	(A is 0->
+		(M1 is L/2, M2 is M1+1,N1 is M1-1,N2 is M2-1,length(N11,N1),length(N21,N2),append(N11,[N12|_Rest1],S),append(N21,[N22|_Rest2],S),MP is (N12+N22)/2)
+	;
+		(L2 is L+1, M1 is L2/2, N1 is M1-1,length(N11,N1),append(N11,[MP|_Rest],S))).
+
+halves(S,H1,H2) :-
+	length(S,L),
+	A is mod(L,2),
+	(A is 0->
+		(M1 is L/2,length(H1,M1),append(H1,H2,S))
+	;
+		(L2 is L-1,M1 is L2/2,length(H1,M1),append(H1,[_|H2],S))).
+
+sum([],S,S):-!.
+sum(S0,S1,S2) :-
+	S0=[S3|S4],
+	S5 is S1+S3,
+	sum(S4,S5,S2).
+	
+mean(Sum,Mean) :-
+	Mean is Sum/2.
+
+furthestfrommean(S,Mean,V) :-
+	absdiffmean(S,Mean,[],D),
+	sort(D,D1),
+	reverse(D1,[[_,V]|_Rest]).
+
+absdiffmean([],_M,D,D) :- !.
+absdiffmean(S,M,D1,D2) :-
+	S=[S1|S2],
+	S3 is abs(S1-M),
+	append(D1,[[S3,S1]],D3),
+	absdiffmean(S2,M,D3,D2).
+
+mindreadtest(Sec) :-
+	%% 250 br for characters to be br out with 10 br each from person to me - do when initial 250 br test done and doing 10 br test
+	%%comment(fiftyastest),
+	%%random(X),X1 is 10*X, X2 is floor(X1), (X2=<2 -> (
+	%%texttobr,write1(['true test']), %%); %% use breasonings breasoned out by computer for not by me, for job medicine for "me", at last time point
+	%%true), %% leave last time point blank
+	%%**texttobr2(640);true),%% make an A to detect reaction to gracious giving or blame of in following
+	get_time(TimeStamp1),
+	%%phrase_from_file(string(_String), 'file.txt'),
+	texttobr2(2), %% 100 As for answer (must be br before this on same day)
+	%% is gracious giving or blame
+	get_time(TimeStamp2),
+	%%comment(turnoffas),
+   Sec is TimeStamp2 - TimeStamp1.
+   
+concat_list2A(A1,B):-
+	A1=[A|List],
+	concat_list2A(A,List,B),!.
+
+concat_list2A(A,[],A):-!.
+concat_list2A(A,List,B) :-
+	List=[Item|Items],
+	string_concat(A,Item,C),
+	concat_list2A(C,Items,B).

Algorithm-Writer-with-Lists/algwriter-lists-random.pl

@@ -0,0 +1,295 @@
+%% algwriter(A),write1(A).
+%% write data,fns in exec format
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+
+multiply(A,B,C) :- 
+C is A*B. 
+
+subtract(A,B,C) :- 
+C is A-B. 
+
+head(A,B) :- A=[B|_].
+
+tail(A,B) :- A=[_|B].
+
+wrap(A,B) :- B=[A].
+
+algwriter(Na) :- 
+%%notrace,
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	%%SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	splitfurther(BrDict0,BrDict01),
+	%%trace,
+	sort(BrDict01,BrDict02),
+makerandomlist(BrDict02,5,[],R0),makerandomlist(R0,3,[],R1),makerandomlist(R0,3,[],R2),wrap(R1,Nb1),wrap(R2,Nb2),append(Nb1,Nb2,Nb3),trialy2A([3,4,5,6,7,8],NFns),randomfns(NFns,Nb3,Na),!.
+makerandomlist(_,0,A,A).
+makerandomlist(List,A,C1,C) :- 
+not((=(A,0))),trialy2A(List,N1),%%random(R),multiply(R,L,R1),ceiling(R1,N1),
+wrap(N1,N2),append(C1,N2,Nb3),subtract(A,1,D),makerandomlist(List,D,Nb3,C).
+randomfns(1,B,Nb3):-randomlist(B,Na1),randomlist(B,Na2),randomfn(Na1,Na2,Nb),wrap(Nb,Nb2),append(B,Nb2,Nb3).%%write1(".").
+randomfns(A,B,C) :- not((=(A,1))),randomlist(B,Na1),randomlist(B,Na2),randomfn(Na1,Na2,Nb),wrap(Nb,Nb2),append(B,Nb2,Nb3),%%tail(B,T),
+	subtract(A,1,D),write(,),
+	randomfns(D,Nb3,C).
+randomlist(B,Na) :- %%List1=[1,2,3,4,5,6,7,9,10],
+length(B,L),length(C,L),append(C,_,B),trialy2A(C,Na).%%,random(R),length(B,Bl),multiply(R,Bl,N),ceiling(N,N1),getitemn(N1,B,Na).
+getitemn(0,_A,[]).
+getitemn(1,B,C) :- head(B,C).
+getitemn(A,B,C) :- not((=(A,1))),tail(B,T),subtract(A,1,D),getitemn(D,T,C).
+randomfn(A1,A2,B) :- %%repeat,
+trialy2A([1,3,4,5,7],N1),%%random(R),multiply(R,8,N),ceiling(N,N1),
+fna(N1,A1,A2,B).
+fna(1,A1,_A2,B) :- reverse(A1,[],B),writeln1([[n,reverse],[A1,[],B]]),term_to_atom(A1,A11),term_to_atom(B,B1),concat_list(["I reversed ",A11,", giving ",B1,"."],C),writeln1(C).
+%%fna(2,A1,_A2,B) :- sort0(A1,B),write1(sort0(A1,B)).
+fna(3,A1,A2,B) :- append1(A1,A2,B),writeln1([[n,append1],[A1,A2,B]]),term_to_atom(A1,A11),term_to_atom(A2,A21),term_to_atom(B,B1),concat_list(["I appended ",A11," to ",A21,", giving ",B1,"."],C),writeln1(C).
+fna(4,A1,A2,B) :- minus1(A1,A2,B),writeln1([[n,minus1],[A1,A2,B]]),term_to_atom(A1,A11),term_to_atom(A2,A21),term_to_atom(B,B1),concat_list(["I subtracted ",A21," from ",A11,", giving ",B1,"."],C),writeln1(C).
+fna(5,A1,A2,B) :- intersection1(A1,A2,[],B),writeln1([[n,intersection1],[A1,A2,[],B]]),term_to_atom(A1,A11),term_to_atom(A2,A21),term_to_atom(B,B1),concat_list(["I found the intersection of ",A11," and ",A21,", ",B1,"."],C),writeln1(C).
+%%fna(6,A1,A2,A2) :- mutually_exclusive(A1,A2),write1([[n,mutually_exclusive],[A1,A2]]).
+fna(7,A1,A2,B) :- duplicates(A1,A2,[],B),writeln1([[n,duplicates],[A1,A2,[],B]]),term_to_atom(A1,A11),term_to_atom(A2,A21),term_to_atom(B,B1),concat_list(["I found the duplicates in ",A11," and ",A21,", ",B1,"."],C),writeln1(C).
+%%fna(8,A1,A2,A1) :- substring(A1,A2),write1([[n,substring],[A1,A2]]).
+reverse([],L,L).
+reverse(L,M,N) :- head(L,H),tail(L,T),wrap(H,H1),append(H1,M,O),reverse(T,O,N).
+sort0(L,N) :- sort1(L,[],N).
+sort1([],L,L).
+sort1(L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),maximum(T,H,M2,[],R),wrap(M2,M3),append(M1,M3,M4),sort1(R,M4,N).
+maximum([],L,L,R,R).
+maximum(L,M1,N,R1,R2) :- not((=(L,[]))),head(L,H),tail(L,T),(>=(M1,H)->(=(M2,M1),wrap(H,H2),append(R1,H2,R3));(=(M2,H),wrap(M1,M12),append(R1,M12,R3))),maximum(T,M2,N,R3,R2).
+map(_F,[],L,L).
+map(F,L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),functor(A,F,3),arg(1,A,M1),arg(2,A,H),arg(3,A,M2),A,map(F,T,M2,N).
+findall(_F,[],L,L).
+findall(F,L,M1,N) :- not((=(L,[]))),head(L,H),tail(L,T),functor(A,F,2),arg(1,A,H),arg(2,A,M2),(A->((wrap(M2,M3),append(M1,M3,M4)));(=(M1,M4))),findall(F,T,M4,N).
+intersection1([],_A,L,L).
+intersection1(L1,L2,L3a,L3) :- head(L1,I1),tail(L1,L4),intersection2(I1,L2,[],L5),append(L3a,L5,L6),intersection1(L4,L2,L6,L3).
+intersection2(_A,[],L,L).
+intersection2(I1,L1,L2,L3) :- head(L1,I1),tail(L1,L4),wrap(I1,I11),append(L2,I11,L5),intersection2(I1,L4,L5,L3).
+intersection2(I1,L1,L2,L3) :- head(L1,I2),tail(L1,L4),not((=(I1,I2))),intersection2(I1,L4,L2,L3).
+append1(B,C,A) :- append(B,C,A).
+minus1(L,[],L).
+minus1(L1,L2,L3) :- head(L2,I1),tail(L2,L5),delete2(L1,I1,[],L6),minus1(L6,L5,L3).
+delete2([],_A,L,L).
+delete2(L1,I1,L2,L3) :- head(L1,I1),tail(L1,L5),delete2(L5,I1,L2,L3).
+delete2(L1,I1,L2,L3) :- head(L1,I2),tail(L1,L5),not((=(I1,I2))),wrap(I2,I21),append(L2,I21,L6),delete2(L5,I1,L6,L3).
+
+mutually_exclusive([],_L):-!.
+mutually_exclusive(L,M):-head(L,H),tail(L,T),membera3(M,H),mutually_exclusive(T,M),!.
+membera3([],_L):-!.
+membera3(L,M):-head(L,H),tail(L,T),not((=(M,H))),membera3(T,M),!.
+
+duplicates([],_L,S,S).
+duplicates(L,M,S1,S2):-head(L,H),tail(L,T),member(H,M),(deletea2(M,H,M1)->(true);(=(M,M1))),wrap(H,H1),append(S1,H1,S3),duplicates(T,M1,S3,S2),!.
+duplicates(L,M,S1,S2):-head(L,H),tail(L,T),not((membera4(M,H))),duplicates(T,M,S1,S2).
+deletea2([],_L,_M1):-fail.
+deletea2(L,M,T):-head(L,H),tail(L,T),=(M,H).
+deletea2(L,M,M1):-head(L,H),tail(L,T),not((=(M,H))),deletea2(T,M,M1).
+membera4([],_L):-fail.
+membera4(L,H):-head(L,H).
+membera4(L,M):-head(L,H),tail(L,T),not(M=H),membera4(T,M).
+
+substring([],[]).
+substring([],B):-not((=(B,[]))),fail.
+substring(A,B):-tail(A,At),(listhead(A,B)->(true);(substring(At,B))).
+listhead(_L,[]).
+listhead(A,B):-head(A,Ah),tail(A,At),head(B,Ah),tail(B,Bt),listhead(At,Bt).
+
+
+%%%%%%%%%%%%
+
+%%findbest(R,R) :-!.
+findbest2(R,Item):-
+	sort(R,RA),
+	reverse(RA,RB),
+	RB=[[_,Item]|_Rest].
+
+
+%%trialy2A([],R) :-
+%%	R=[[_,'A']].
+%%trialy2A(List,R) :-
+%%	random_member(A,List),
+%%	R=[[_,A]].
+
+trialy2A([],R) :-
+	R=[].
+trialy2A(List,R) :-
+	random_member(R,List).
+	%%R=[[_,A]].
+
+%%trialy2A(List,R) :-
+%%	notrace,trialy2B(List,R).%%,trace.
+trialy2B(List,R) :-
+	length(List,Length),
+	((Length=<9->
+		findr4(R4),
+		number_string(R4,R4A),
+		formr5([R4A],9,Length,R5),
+		findr(R5,List,R));
+	(Length=<99->
+		findr4(R41),
+		findr4(R42),
+		formr5([R41,R42],99,Length,R5),
+		findr(R5,List,R));
+	(Length=<999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		formr5([R41,R42,R43],999,Length,R5),
+		findr(R5,List,R));
+	(Length=<9999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		findr4(R44),
+		formr5([R41,R42,R43,R44],9999,Length,R5),
+		findr(R5,List,R));
+	(Length=<99999->
+		findr4(R41),
+		findr4(R42),
+		findr4(R43),
+		findr4(R44),
+		findr4(R45),
+		formr5([R41,R42,R43,R44,R45],99999,Length,R5),
+		findr(R5,List,R));
+	fail),
+	%%write1([r,R]),trace.
+	true.
+
+findr4(R4) :-
+		List1=[0,1,2,3,4,5,6,7,8,9],
+		Trials is 30,
+		trialy22(List1,Trials,[],R1),
+		findbest2(R1,R4).
+		%%number_string(R3,R2),
+formr5(RList,Upper,Length,R5) :-
+		%%findall(D,(member(C,RList),floor(C,D)),RList2),
+		concat_list2A(RList,R5A),
+		number_string(R5B,R5A),
+		R51 is floor((R5B/Upper)*Length),
+		(R5B=Upper->R5 is R51-1;R5=R51).
+findr(R4,List,R) :-
+		%%floor(R4,R4A),		
+		length(A,R4),
+		append(A,[R|_],List).
+
+	%%random_member(A,List),
+	%%R=[[_,A]].
+	
+	/**
+	length(List,L),
+	Trials is L*3,
+	trialy22(List,Trials,[],R).**/
+
+trialy22([],_,R,R) :- !.
+trialy22(List,Trials,RA,RB) :-
+	List=[Item|Items],
+	trialy21(Item,Trials,R1),
+	append(RA,[R1],RC),
+	trialy22(Items,Trials,RC,RB),!.
+
+trialy21(Label,Trials,RA) :-
+	trialy3(Trials,[],R),
+	aggregate_all(count, member(true,R), Count),
+	RA=[Count,Label].
+
+trialy3(0,R,R) :-!.
+trialy3(Trials1,RA,RB) :-
+	trialy1(R1),
+	append(RA,[R1],RC),
+	Trials2 is Trials1-1,
+	trialy3(Trials2,RC,RB),!.
+	
+%% try other nouns
+trialy1(R1) :-
+	%%control11(A1),
+	%%repeat,
+	trial0(A22), %% Control
+	sum(A22,0,S22),
+	mean(S22,A1),
+	%%repeat,
+	trial0(A21), %% Test 1
+	sum(A21,0,S02),
+	mean(S02,A2),
+	(A1>A2->R1=true;R1=fail).
+
+trial0(S3) :- N is 10, trial1(N,[],S),trial01(S,S3).
+trial01(S1,S3) :-
+	sort(S1,S),
+	%%midpoint(S,MP),
+	halves(S,H1,H2),
+	midpoint(H1,Q1),
+	midpoint(H2,Q3),
+	IQR is Q3-Q1,
+	sum(S,0,S02),
+	mean(S02,Mean),
+	furthestfrommean(S,Mean,V),
+	D1 is 1.5*IQR,
+	D2 is V-Mean,
+	(D2>D1->(delete(S,V,S2),trial01(S2,S3));S=S3).
+	
+%%trial1(0,[],_A) :- fail,!.
+trial1(0,A,A) :- !.
+trial1(N,A,B) :- mindreadtest(S), append(A,[S],A2),
+	N1 is N-1,trial1(N1,A2,B).
+	
+%%midpoint([],0) :- !.
+
+midpoint(S,MP) :-
+%%	not(S=[]),
+	length(S,L),
+	A is mod(L,2),
+	(A is 0->
+		(M1 is L/2, M2 is M1+1,N1 is M1-1,N2 is M2-1,length(N11,N1),length(N21,N2),append(N11,[N12|_Rest1],S),append(N21,[N22|_Rest2],S),MP is (N12+N22)/2)
+	;
+		(L2 is L+1, M1 is L2/2, N1 is M1-1,length(N11,N1),append(N11,[MP|_Rest],S))).
+
+halves(S,H1,H2) :-
+	length(S,L),
+	A is mod(L,2),
+	(A is 0->
+		(M1 is L/2,length(H1,M1),append(H1,H2,S))
+	;
+		(L2 is L-1,M1 is L2/2,length(H1,M1),append(H1,[_|H2],S))).
+
+sum([],S,S):-!.
+sum(S0,S1,S2) :-
+	S0=[S3|S4],
+	S5 is S1+S3,
+	sum(S4,S5,S2).
+	
+mean(Sum,Mean) :-
+	Mean is Sum/2.
+
+furthestfrommean(S,Mean,V) :-
+	absdiffmean(S,Mean,[],D),
+	sort(D,D1),
+	reverse(D1,[[_,V]|_Rest]).
+
+absdiffmean([],_M,D,D) :- !.
+absdiffmean(S,M,D1,D2) :-
+	S=[S1|S2],
+	S3 is abs(S1-M),
+	append(D1,[[S3,S1]],D3),
+	absdiffmean(S2,M,D3,D2).
+
+mindreadtest(Sec) :-
+	%% 250 br for characters to be br out with 10 br each from person to me - do when initial 250 br test done and doing 10 br test
+	%%comment(fiftyastest),
+	%%random(X),X1 is 10*X, X2 is floor(X1), (X2=<2 -> (
+	%%texttobr,write1(['true test']), %%); %% use breasonings breasoned out by computer for not by me, for job medicine for "me", at last time point
+	%%true), %% leave last time point blank
+	%%**texttobr2(640);true),%% make an A to detect reaction to gracious giving or blame of in following
+	get_time(TimeStamp1),
+	%%phrase_from_file(string(_String), 'file.txt'),
+	texttobr2(2), %% 100 As for answer (must be br before this on same day)
+	%% is gracious giving or blame
+	get_time(TimeStamp2),
+	%%comment(turnoffas),
+   Sec is TimeStamp2 - TimeStamp1.
+   
+concat_list2A(A1,B):-
+	A1=[A|List],
+	concat_list2A(A,List,B),!.
+
+concat_list2A(A,[],A):-!.
+concat_list2A(A,List,B) :-
+	List=[Item|Items],
+	string_concat(A,Item,C),
+	concat_list2A(C,Items,B).

Algorithm-Writer-with-Lists/brdict3.txt

@@ -0,0 +1 @@
+[["a","a"],["person","subject"],["pear","pear"],["banana","banana"],["apple","apple"],["right","check"],["city","origin"],["paper","command"],["up","check"],["and","interpreter"],["box","minimise"],["twobox","compiler"],["variable","satisfy"],["software","generator"],["leash","all"],["square","end"],["xcorrection","xcorrection"],["one","true"],["dash","twodimensional"],["tick","secure"],["book","business"],["plus","useful"],["equals","compute"],["ball","sphere"],["ship","ship"],["down","current"],["zero","empty"],["brain","calculate"],["log","log"],["n","value"],["testtube","test"],["building","building"],["minus","false"],["dollarsymbol","money"],["happy","happy"],["lowera","word"],["filename","filename"],["gl","gl"],["txt","txt"],["notrace","notrace"],["mtrue","mtrue"],["m","m"],["grammar","grammar"],["logic","logic"],["to","to"],["alg","alg"],["sentences","sentences"],["medicine","medicine"],["by","by"],["lucian","lucian"],["note","music"],["pencilsharpener","object"],["hand","hand"]]

Algorithm-Writer-with-Lists/combophil.pl

@@ -0,0 +1,33 @@
+%% combophil.pl
+
+%% Finds combinations of lines of philosophy
+
+%% *** Deprecated by Repository Lucian-Academy/combophil_alg_log.pl
+
+:-include('../listprologinterpreter/la_strings').
+
+string(String) --> list(String).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+%% e.g. combophil(2). to write on a combination of philosophies
+
+combophil(NumberOfPhils) :-
+	phrase_from_file_s(string(Phil1), "../Text-to-Breasonings/file.txt"),
+	SepandPad="\n\r",
+	split_string(Phil1,SepandPad,SepandPad,Phil2),
+	delete(Phil2,"",Phil3),
+	sort(Phil3,Phil4),
+	length(Phil4,LengthPhil4),write("Number of philosophies in file.txt: "),
+	writeln(LengthPhil4),
+	length(PhilsLengthList,NumberOfPhils),
+	repeat,
+	findall(Phils1,(member(_,PhilsLengthList),random_member(Phils1,Phil4)),Phils2),
+	reverse(Phils2,Phils3),Phils3=[Phil6|Phils4],reverse(Phils4,Phils5),
+	findall(_,(member(Phil5,Phils5),writeln1(Phil5),nl,writeln1("because"),nl),_),
+	writeln1(Phil6),nl,
+	write("1-Continue or 2-End: "),
+	read_string(user_input, "\n", "\r", _End, Input),
+	(Input="2"->abort;fail).
+

Algorithm-Writer-with-Lists/combophil2qadb.pl

@@ -0,0 +1,165 @@
+%% combophil.pl x combophil2qadb.pl
+
+% don;t change to mrtree because mr is working.  Without seeing and thinking about options, it is meaningless.
+
+%% Finds combinations of lines of philosophy
+
+%% *** Deprecated by Repository Lucian-Academy/combophil_alg_log.pl
+
+:-include('../listprologinterpreter/la_strings').
+
+string(String) --> list(String).
+
+list([]) --> [].
+list([L|Ls]) --> [L], list(Ls).
+
+%% e.g. combophil(2). to write on a combination of philosophies
+
+combophil2qadb :- %(NumberOfPhils) :-
+
+% get box, right, box words from brdict1
+phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+%phrase_from_file_s(string(BrDict0), "../../brdict1.txt"),
+%string_codes(String02b,BrDict0),
+%atom_to_term(String02b,String02a,[]),
+splitfurther(BrDict0,BrDict01),
+sort(BrDict01,String02a),
+findall(A2,(member(A,String02a),A=[A2,"box"]),A1),
+findall(B2,(member(B,String02a),B=[B2,"right"]),B1),
+
+
+	phrase_from_file_s(string(Phil1), "../Text-to-Breasonings/file.txt"),
+	SepandPad="\n\r.",
+	split_string(Phil1,SepandPad,SepandPad,Phil2),
+	delete(Phil2,"",Phil3),
+	sort(Phil3,Phil4),
+	length(Phil4,LengthPhil4),write("Number of philosophies in file.txt: "),
+	writeln(LengthPhil4),
+	%length(PhilsLengthList,NumberOfPhils),
+	
+	findall([C,Algorithm],(member(C,Phil4),
+	qa_db_finder(A1,B1,Algorithm)),D),
+	
+	term_to_atom(D,K),
+	(open_s("file-o.txt",write,Stream1),
+	write(Stream1,K),
+	close(Stream1)),!.
+	/** 
+	repeat,
+	findall(Phils1,(member(_,PhilsLengthList),random_member(Phils1,Phil4)),Phils2),
+	reverse(Phils2,Phils3),Phils3=[Phil6|Phils4],reverse(Phils4,Phils5),
+	findall(_,(member(Phil5,Phils5),writeln1(Phil5),nl,writeln1("because"),nl),_),
+	writeln1(Phil6),nl,
+	write("1-Continue or 2-End: "),
+	read_string(user_input, "\n", "\r", _End, Input),
+	(Input="2"->abort;fail).
+**/
+
+
+splitfurther(BrDict01,N) :-
+   phrase(file0(N),BrDict01).
+   
+   file0(N) --> "[", file(N), "]", !.
+   file0([]) --> [].
+
+   file([L|Ls]) --> entry(L),",",
+   %%{writeln(L)}, %%***
+   file(Ls), !.
+   file([L]) --> entry(L), 
+   %%{writeln(L)},
+   !.
+
+   entry([Word2,Word4]) -->
+   "[", word(Word), {string_codes(Word2,Word),string(Word2)},
+",",
+           word(Word3), {string_codes(Word4,Word3),string(Word4)},
+              "]".
+                 
+      word([X|Xs]) --> [X], {char_type(X,csymf)->true;(X=27->true;X=8217)}, word(Xs), !.
+      %%word([X]) --> [X], {char_type(X,csymf);(X=27;X=8217)}, !.
+      word([]) --> [].
+
+qa_db_finder(A1,B1,Algorithm) :-
+% name of algorithm
+	random_member(Verb,B1),
+
+	%writeln("What is the input variable?"),
+	random_member(I1,A1),
+	upper_first_letter(I1,I),
+	%read_string(user_input, "\n", "\r", _End, I),
+	
+	%writeln("What variable is this last variable linked to?"),
+	random_member(N1,A1),
+	upper_first_letter(N1,N),
+	%read_string(user_input, "\n", "\r", _End2, N),
+
+	concat_list(["member(A1,",I,N,"),A1=[",I,",",N,"],"],Algorithm1),
+	Vars1=[I,N],
+	
+	repeat1(A1,2,N,Algorithm1,Algorithm2,Vars1,Vars2),
+	
+	string_concat(Algorithm3,",",Algorithm2),
+	
+	%writeln("What is the final output variable?"),
+	random_member(O1,A1),
+	upper_first_letter(O1,O2),
+	append(Vars2,[O2],O3),
+	random_member(O,O3),
+	%read_string(user_input, "\n", "\r", _End3, O),
+	%%trace,
+	
+	find_header_args1(Vars2,"",HA1),
+	%%string_concat(HA2,",",HA1),
+	
+	concat_list(["a(",HA1,I,",",O,"):-"],Algorithm4),
+	concat_list([Algorithm4,Algorithm3,"."],Algorithm).
+
+upper_first_letter(A,B) :-
+	string_concat(C,F,A),
+	string_length(C,1),
+	to_upper(C,D),
+	string_codes(E,[D]),
+	string_concat(E,F,B),!.
+	
+repeat1(A1,M1,N,Algorithm1,Algorithm2,Vars1,Vars2) :-
+	%writeln("Is this the final variable? (y/n)"),
+	random_member(Q,["y","n"]),
+	%read_string(user_input, "\n", "\r", _End, Q),
+
+	(Q="y"->(Algorithm2=Algorithm1,Vars2=Vars1);
+	%writeln("What variable is this last variable linked to?"),
+	%(random(X_A),X_B is ceiling(2*X_A),
+	%(X_B=1->
+	random_member(V1,A1),
+	upper_first_letter(V1,V2),
+	append(Vars1,[V2],V3),
+	random_member(V,V3),
+	%read_string(user_input, "\n", "\r", _End2, V),
+	
+	concat_list(["member(A",M1,",",N,V,"),A",M1,"=[",N,",",V,"],"],Algorithm1a),
+	append(Vars1,[V],Vars3),
+	M2 is M1+1,
+	string_concat(Algorithm1,Algorithm1a,Algorithm1b),
+	repeat1(A1,M2,V,Algorithm1b,Algorithm2,Vars3,Vars2)
+
+	).
+
+
+find_header_args1([_],HA,HA) :- !.
+find_header_args1(Vars,HA1,HA2) :-
+	Vars=[_|F],
+	Vars=[A,B|_],
+	concat_list([A,B,","],D),
+	string_concat(HA1,D,E),
+	find_header_args1(F,E,HA2).
+
+	
+concat_list(A1,B):-
+	A1=[A|List],
+	concat_list(A,List,B),!.
+
+concat_list(A,[],A):-!.
+concat_list(A,List,B) :-
+	List=[Item|Items],
+	string_concat(A,Item,C),
+	concat_list(C,Items,B).

Algorithm-Writer-with-Lists/combophil_grammar_logic_to_alg.pl

@@ -0,0 +1,208 @@
+/**
+
+grammar_logic_to_alg.pl
+
+
+e.g. I liked God with you
+[liked,God],[God,you] with extra data
+- connect liked to you with member, return words on path
+
+POS
+
+goes backwards x forwards
+- I v n by v n x ignore
+
+n,v
+- single type
+
+adjective
+- ignored x (ignore names in alg)
+- like v,n
+
+joining words - ignore, just pairs v, n
+- on
+- joins v to n
+- separates vns
+
+negative terms
+- switch to positive or ignore
+
+disappearing words
+- my
+- no list of these, because they are ignored
+
+vv is v1, v2 x v1
+nn is n1
+
+*
+
+later: can randomly generate details like given sentence
+
+**/
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+
+:- dynamic brdict/1.
+
+combophil_grammar_logic_to_alg1 :-
+	phrase_from_file_s(string(Text1), "../Text-to-Breasonings/file.txt"),
+
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,BrDict01),
+	sort(BrDict01,BrDict012),
+	retractall(brdict(_)),
+	assertz(brdict(BrDict012)),
+
+	%%SepandPad=".\n",
+	%%split_string(Text1,SepandPad,SepandPad,Text2a),
+	%%delete(Text2a,"",Text2),
+	
+
+	%%findall(B2,(member(B1,Text2),
+	string_codes(Text11,Text1),
+	downcase_atom(%%B1
+	Text11,B11),atom_string(B11,B12),
+	SepandPad1=" .\n",
+	split_string(B12,SepandPad1,SepandPad1,A),
+	%%trace,
+	findall(D,(member(C3,A),
+		member([C3,"right"],BrDict012),member(C1,A),
+		not(member([C1,"right"],BrDict012)),
+		concat_list([C3," ",C1],C2),grammar_logic_to_alg(C2,D)),C),
+	%%writeln(C),trace,
+	
+	%%grammar_logic_to_alg(D,B2)),C),
+	length(C,CLength),
+	writeln([CLength,sentences]),
+	
+	C=[[[_,Sentence1,a_alg(List_a),_,bb_alg(List_bb)]|Cs1]|Cs2],
+		%%get_time(TS),stamp_date_time(TS,date(Year,Month,Day,Hour1,Minute1,Seconda,_A,_TZ,_False),local),
+	concat_list(["gla_del"],%%[Year,Month,Day,Hour1,Minute1,Seconda],
+	File1),
+	concat_list(["\"",File1,".txt\""],File2),
+
+	term_to_atom(List_a,List_a2),
+	string_atom(List_a3,List_a2),
+	
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_a1),
+	writeln1([*,Sentence1,a_alg(List_a)]),
+	writeln(List_a1),
+
+	concat_list(["\n\nswipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,",[v,b]]],[[[n,function],[[v,a],[v,b]],\":-\",[[[n,tail],[[v,a],[v,b]]]]]],_),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_b1),
+	writeln1([*,Sentence1,b_alg(List_a)]),
+	writeln(List_b1),
+
+	term_to_atom(List_bb,List_bb2),
+	string_atom(List_bb3,List_bb2),
+
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_bb3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_bb1),
+	writeln1([*,Sentence1,bb_alg(List_bb)]),
+	writeln(List_bb1),
+
+	writeln1(Cs1),
+	writeln1(Cs2).
+
+grammar_logic_to_alg(Sentence1,B) :- %% Not by multi-sentence algorithms, just by sentence
+	atom_string(Sentence0,Sentence1),
+	downcase_atom(Sentence0,Sentence01),
+	atom_string(Sentence01,Sentence02),
+	SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	Connectors=
+		["the","a","i","on","with","of","an","for","to",
+		"was","were","and","in","my","from","out","by"],
+	split_string(Sentence02,SepandPad,SepandPad,Sentence2),
+	subtract(Sentence2,Connectors,Sentence3),
+	%%length(Sentence3,Length),
+	
+	%% () add generated data
+	%%write_commands(Length,[],Commands), %% sentence alg
+	
+	generate_sentences(Sentence3,[],Sentence_a,30), %% detail 	sentences
+	append(Sentence3,Sentence_a,Sentence4),
+	findall([*,Sentence1,a_alg(Sentence5),b_alg(Sentence5,a),bb_alg(Sentence6)],(member(Sentence4a,Sentence4),make_lists(Sentence4a,[],Sentence5),Sentence5=[_|Sentence6]),B),!.
+	  %% detail algs
+	
+generate_sentences(_Sentence3,Sentence_a,Sentence_a,0) :- !.
+generate_sentences(Sentence3,Sentence_a1,Sentence_a2,N1) :-
+	random_member(Item,Sentence3),
+	generate_sentence(Item,Sentence_a3),
+	append(Sentence_a1,[Sentence_a3],Sentence_a4),
+	N2 is N1-1,
+	generate_sentences(Sentence3,Sentence_a4,Sentence_a2,N2).
+
+%%write_commands(0,Commands,Commands) :- !.
+%%write_commands(Length1,Commands1,Commands2) :-
+%%	Length2 is Length1-1.
+%%	append(Commands1,[[[n,member2],[[v,Length1],[v,Length2]]]).
+	%%[[n,equals1],[[v,Length2],[[v,a***],[v,b]]]]].
+
+%%[a,b]
+%%[c,d]
+
+generate_sentence(Item,Sentence) :-
+	random_member(Grammar1,[[n,v,n],[n,v,a,n],[v,n],[v,a,n]]),
+	brdict(BrDict012),
+	find_pos(Item,POS,BrDict012),
+	substitute1(Item,POS,Grammar1,[],Grammar2),
+	substitute2(Grammar2,BrDict012,[],Sentence).
+
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="right",
+	POS2=v,!.
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="plus",
+	POS2=a,!.
+find_pos(_Item,POS2,_BrDict012) :-
+	POS2=n.
+
+substitute1(_Item,_POS,[],Grammar,Grammar) :- !.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	Grammar4=POS,
+	append_list([Grammar2,Item],Grammar6),
+	append(Grammar6,Grammar5,Grammar3),!.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	not(Grammar4=POS),
+	append_list([Grammar2,Grammar4],Grammar6),
+	substitute1(Item,POS,Grammar5,Grammar6,Grammar3),!.
+
+substitute2([],_BrDict012,Sentence,Sentence) :- !.
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=n,
+	findall(A,(member([A,"box"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=v,
+	findall(A,(member([A,"right"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=a,
+	findall(A,(member([A,"plus"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	append(Sentence1,[Grammar2],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+
+make_lists(Sentence1,Sentence,Sentence) :-
+	Sentence1=[_Sentence2],
+	!.	
+make_lists(Sentence1,Sentence2,Sentence3) :-
+	Sentence1=[Sentence4|Sentence5],
+	Sentence5=[Sentence6|_Sentence7],
+	append(Sentence2,[[Sentence4,Sentence6]],Sentence8),
+	make_lists(Sentence5,Sentence8,Sentence3).
+	
+	

Algorithm-Writer-with-Lists/combophil_grammar_logic_to_alg_vps.pl

@@ -0,0 +1,241 @@
+/**
+
+grammar_logic_to_alg.pl
+
+
+e.g. I liked God with you
+[liked,God],[God,you] with extra data
+- connect liked to you with member, return words on path
+
+POS
+
+goes backwards x forwards
+- I v n by v n x ignore
+
+n,v
+- single type
+
+adjective
+- ignored x (ignore names in alg)
+- like v,n
+
+joining words - ignore, just pairs v, n
+- on
+- joins v to n
+- separates vns
+
+negative terms
+- switch to positive or ignore
+
+disappearing words
+- my
+- no list of these, because they are ignored
+
+vv is v1, v2 x v1
+nn is n1
+
+*
+
+later: can randomly generate details like given sentence
+
+**/
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+
+:- dynamic brdict/1.
+
+truncate(List1,M,String0) :-
+	((number(M),length(String0,M),
+	append(String0,_,List1))->true;
+	String0=List1),!.
+
+combophil_grammar_logic_to_alg1(P,String000) :-%%(String000) :-
+	phrase_from_file_s(string(Text1), "../Lucian-Academy/luciansphilosophy.txt"),
+	combophil_grammar_logic_to_alg2(String000,Text1).
+	
+combophil_grammar_logic_to_alg1(File) :-%%(String000) :-
+	phrase_from_file_s(string(Text1), "../Text-to-Breasonings/file.txt"),
+	string_codes(Text11,Text1),
+	downcase_atom(%%B1
+	Text11,B11),atom_string(B11,B12),
+	SepandPad1=".\n",
+	split_string(B12,SepandPad1,SepandPad1,A0),
+	findall(_,(member(A00,A0),
+	combophil_grammar_logic_to_alg2(String000,A00),
+	%%String000="a b c",
+	time((N = u, M = u,texttobr2(N,u,String000,M),texttobr(N,u,String000,M))),
+%% Give the meditators, etc. the As.
+	texttobr2(3)),_).
+
+combophil_grammar_logic_to_alg2(String000,Text1) :-
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,BrDict01),
+	sort(BrDict01,BrDict012),
+	retractall(brdict(_)),
+	assertz(brdict(BrDict012)),
+
+	%%SepandPad=".\n",
+	%%split_string(Text1,SepandPad,SepandPad,Text2a),
+	%%delete(Text2a,"",Text2),
+	
+
+	%%findall(B2,(member(B1,Text2),
+	string_codes(Text11,Text1),
+	downcase_atom(%%B1
+	Text11,B11),atom_string(B11,B12),
+	SepandPad1=" .\n",
+	split_string(B12,SepandPad1,SepandPad1,A01),
+	append(["go"],A01,A0),
+	truncate(A0,20,A),
+
+	findall(D,(member(C3,A),
+		member([C3,"right"],BrDict012),member(C1,A),
+		not(member([C1,"right"],BrDict012)),
+		concat_list([C3," ",C1],C2),grammar_logic_to_alg(C2,D)),C),
+	%%writeln(C),trace,
+	
+	%%grammar_logic_to_alg(D,B2)),C),
+	length(C,CLength),
+	writeln([CLength,sentences]),
+	
+	C=[[[_,Sentence1,a_alg(List_a),_,bb_alg(List_bb)]|Cs1]|Cs2],
+		%%get_time(TS),stamp_date_time(TS,date(Year,Month,Day,Hour1,Minute1,Seconda,_A,_TZ,_False),local),
+	concat_list(["gla_del"],%%[Year,Month,Day,Hour1,Minute1,Seconda],
+	File1),
+	concat_list(["\"",File1,".txt\""],File2),
+
+	term_to_atom(List_a,List_a2),
+	string_atom(List_a3,List_a2),
+	
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_a1),
+	writeln1([*,Sentence1,a_alg(List_a)]),
+	writeln(List_a1),
+
+	concat_list(["\n\nswipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,",[v,b]]],[[[n,function],[[v,a],[v,b]],\":-\",[[[n,tail],[[v,a],[v,b]]]]]],_),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_b1),
+	writeln1([*,Sentence1,b_alg(List_a)]),
+	writeln(List_b1),
+
+	term_to_atom(List_bb,List_bb2),
+	string_atom(List_bb3,List_bb2),
+
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_bb3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_bb1),
+	writeln1([*,Sentence1,bb_alg(List_bb)]),
+	writeln(List_bb1),
+
+	writeln1(Cs1),
+	writeln1(Cs2),
+	
+	term_to_atom([[CLength,sentences],[*,Sentence1,a_alg(List_a)],List_a1,[*,Sentence1,b_alg(List_a)],List_b1,[*,Sentence1,bb_alg(List_bb)],List_bb1,Cs1,Cs2],String0001),
+atom_string(String0001,String000)
+
+	%%a(P,String000):-	
+	
+		
+		%%CLength=a,Sentence1=a,List_a=a,List_a1=a,List_b1=a,List_bb=a,List_bb1=a,Cs1=a,Cs2=a,
+
+.
+
+grammar_logic_to_alg(Sentence1,B) :- %% Not by multi-sentence algorithms, just by sentence
+	atom_string(Sentence0,Sentence1),
+	downcase_atom(Sentence0,Sentence01),
+	atom_string(Sentence01,Sentence02),
+	SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	Connectors=
+		["the","a","i","on","with","of","an","for","to",
+		"was","were","and","in","my","from","out","by"],
+	split_string(Sentence02,SepandPad,SepandPad,Sentence2),
+	subtract(Sentence2,Connectors,Sentence3),
+	%%length(Sentence3,Length),
+	
+	%% () add generated data
+	%%write_commands(Length,[],Commands), %% sentence alg
+	
+	generate_sentences(Sentence3,[],Sentence_a,30), %% detail 	sentences
+	append(Sentence3,Sentence_a,Sentence4),
+	findall([*,Sentence1,a_alg(Sentence5),b_alg(Sentence5,a),bb_alg(Sentence6)],(member(Sentence4a,Sentence4),make_lists(Sentence4a,[],Sentence5),Sentence5=[_|Sentence6]),B),!.
+	  %% detail algs
+	
+generate_sentences(_Sentence3,Sentence_a,Sentence_a,0) :- !.
+generate_sentences(Sentence3,Sentence_a1,Sentence_a2,N1) :-
+	random_member(Item,Sentence3),
+	generate_sentence(Item,Sentence_a3),
+	append(Sentence_a1,[Sentence_a3],Sentence_a4),
+	N2 is N1-1,
+	generate_sentences(Sentence3,Sentence_a4,Sentence_a2,N2).
+
+%%write_commands(0,Commands,Commands) :- !.
+%%write_commands(Length1,Commands1,Commands2) :-
+%%	Length2 is Length1-1.
+%%	append(Commands1,[[[n,member2],[[v,Length1],[v,Length2]]]).
+	%%[[n,equals1],[[v,Length2],[[v,a***],[v,b]]]]].
+
+%%[a,b]
+%%[c,d]
+
+generate_sentence(Item,Sentence) :-
+	random_member(Grammar1,[[n,v,n],[n,v,a,n],[v,n],[v,a,n]]),
+	brdict(BrDict012),
+	find_pos(Item,POS,BrDict012),
+	substitute1(Item,POS,Grammar1,[],Grammar2),
+	substitute2(Grammar2,BrDict012,[],Sentence).
+
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="right",
+	POS2=v,!.
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="plus",
+	POS2=a,!.
+find_pos(_Item,POS2,_BrDict012) :-
+	POS2=n.
+
+substitute1(_Item,_POS,[],Grammar,Grammar) :- !.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	Grammar4=POS,
+	append_list([Grammar2,Item],Grammar6),
+	append(Grammar6,Grammar5,Grammar3),!.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	not(Grammar4=POS),
+	append_list([Grammar2,Grammar4],Grammar6),
+	substitute1(Item,POS,Grammar5,Grammar6,Grammar3),!.
+
+substitute2([],_BrDict012,Sentence,Sentence) :- !.
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=n,
+	findall(A,(member([A,"box"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=v,
+	findall(A,(member([A,"right"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=a,
+	findall(A,(member([A,"plus"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	append(Sentence1,[Grammar2],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+
+make_lists(Sentence1,Sentence,Sentence) :-
+	Sentence1=[_Sentence2],
+	!.	
+make_lists(Sentence1,Sentence2,Sentence3) :-
+	Sentence1=[Sentence4|Sentence5],
+	Sentence5=[Sentence6|_Sentence7],
+	append(Sentence2,[[Sentence4,Sentence6]],Sentence8),
+	make_lists(Sentence5,Sentence8,Sentence3).
+	
+	

Algorithm-Writer-with-Lists/four_crosses.pl

@@ -0,0 +1,12 @@
+four_crosses :-
+	prompt("What are the two items to cross?",_Two_items),
+	cross,cross,cross,
+	prompt("What is their cross?",_Cross11).
+
+cross :-
+	prompt("What is their cross?",_Cross11),
+	prompt("What is at the same level as this?",_Cross12).
+
+prompt(Prompt,String) :-
+	writeln(Prompt),
+	read_string(user_input, "\n", "\r", _End, String).

Algorithm-Writer-with-Lists/gl-api.pl

@@ -0,0 +1,63 @@
+:- use_module(library(http/thread_httpd)).
+:- use_module(library(http/http_dispatch)).
+:- use_module(library(http/http_error)).
+:- use_module(library(http/html_write)).
+
+% we need this module from the HTTP client library for http_read_data
+:- use_module(library(http/http_client)).
+:- http_handler('/', web_form, []).
+
+% GitHub
+:- include('grammar_logic_to_alg.pl').
+
+server(Port) :-
+        http_server(http_dispatch, [port(Port)]).
+
+	/*
+	browse http://127.0.0.1:8000/
+	This demonstrates handling POST requests
+	   */
+
+	   web_form(_Request) :-
+	   	reply_html_page(
+			    title('Grammar Logic'),
+			    	    [
+				    	     form([action='/landing', method='POST'], [
+				    	     /**
+					     		p([], [
+									  label([for=debug],'Debug (on/off):'),
+									  		  input([name=debug, type=textarea])
+											  		      ]),
+											  		      **/
+													      		p([], [
+																	  label([for=query],'Grammar Logic Input:'),
+																	  		  input([name=query, type=textarea])
+																			  		      ]),
+													  
+																					      		p([], input([name=submit, type=submit, value='Submit'], []))
+																								      ])]).
+
+																								      :- http_handler('/landing', landing_pad, []).
+
+																								      landing_pad(Request) :-
+
+%	working_directory(_, 'GitHub/Algorithm-Writer-with-Lists/'),
+																								              member(method(post), Request), !,
+																									              http_read_data(Request, Data, []),
+																										              format('Content-type: text/html~n~n', []),
+																											      	format('<p>', []),
+																												        %%portray_clause(Data),
+																												        
+																												        %%term_to_atom(Term,Data),
+																												        
+Data=[%%debug='off',%%Debug1,
+query=Query1,submit=_],
+
+
+	grammar_logic_to_alg1(Query1,4000,Result),
+																														%%format('</p><p>========~n', []),
+																															%%portray_clause
+																															portray_clause(Result),
+																																																															%%writeln1(Data),
+
+format('</p>').

Algorithm-Writer-with-Lists/grammar_logic_to_alg.pl

@@ -0,0 +1,277 @@
+/**
+
+grammar_logic_to_alg.pl
+
+
+e.g. I liked God with you
+[liked,God],[God,you] with extra data
+- connect liked to you with member, return words on path
+
+POS
+
+goes backwards x forwards
+- I v n by v n x ignore
+
+n,v
+- single type
+
+adjective
+- ignored x (ignore names in alg)
+- like v,n
+
+joining words - ignore, just pairs v, n
+- on
+- joins v to n
+- separates vns
+
+negative terms
+- switch to positive or ignore
+
+disappearing words
+- my
+- no list of these, because they are ignored
+
+vv is v1, v2 x v1
+nn is n1
+
+*
+
+later: can randomly generate details like given sentence
+
+**/
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+:-include('../Text-to-Breasonings/truncate.pl').
+%:- include('../Philosophy/14 10 23.pl').
+
+:- dynamic brdict/1.
+
+
+
+mt_t2b2:-
+%Thread=
+	%[
+	phrase_from_file_s(string(Essay_0), %"lacom5million.txt"
+	"../../private/lacom0.5million.txt"
+	),
+
+	%Br is 5,
+	%Br is 5000000,
+	W is 0,
+	
+	%grammar_logic_to_alg1(Essay_0,Br,GL_out1),
+	grammar_logic_to_alg113(Essay_0,GL_out1),
+
+	term_to_atom(GL_out1,GL_out2),
+	string_atom(GL_out,GL_out2),
+
+	texttobr2(u,u,GL_out,Br,false,false,false,false,false,false,W),
+	texttobr(u,u,GL_out,Br).%],
+
+mt_t2b3:-mt_t2b2.
+	
+mt_t2b4:-mt_t2b2.	
+
+mt_t2b5:-mt_t2b2.	
+
+mt_t2b6:-mt_t2b2.	
+
+mt_t2b7:-mt_t2b2.	
+
+mt_t2b8:-mt_t2b2.	
+
+mt_t2b9:-mt_t2b2.	
+	%trace,Thread.
+	
+
+mt_t2b :-	
+
+Goals=[mt_t2b2,mt_t2b3,mt_t2b4,mt_t2b5,mt_t2b6,mt_t2b7,mt_t2b8,mt_t2b9
+],
+
+length(Goals,L),
+
+%time(mt_t2b2).
+time(concurrent(L,Goals,[])).
+	
+grammar_logic_to_alg1(String1,N,Result) :-
+
+	%term_to_atom(String,Essay_01),
+	%string_atom(Essay_02,Essay_01),
+
+	%working_directory(_, '../'),
+	
+	%(open_s("../Text-to-Breasonings/file.txt",write,Stream1),
+	%write(Stream1,String),
+	%close(Stream1)),!,
+
+	truncate1(string,String1,N,String),
+
+	%working_directory(_, 'algwriter/'),
+	grammar_logic_to_alg114(String,Result).
+	
+grammar_logic_to_alg1 :-
+	grammar_logic_to_alg11([Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]),
+	writeln1([*,Sentence1,a_alg(List_a)]),
+	writeln(List_a1),
+	writeln1([*,Sentence1,b_alg(List_a)]),
+	writeln(List_b1),
+	writeln1([*,Sentence1,bb_alg(List_bb)]),
+	writeln(List_bb1),
+
+	writeln1(Cs1),
+	writeln1(Cs2).
+
+grammar_logic_to_alg112(Result) :-
+	grammar_logic_to_alg11(Result1),term_to_atom(Result1,Result).
+
+grammar_logic_to_alg114(Text,Result) :-
+	grammar_logic_to_alg113(Text,Result1),term_to_atom(Result1,Result).
+
+
+grammar_logic_to_alg11([Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]) :-
+	phrase_from_file_s(string(Text1), "../Text-to-Breasonings/file.txt"),
+
+grammar_logic_to_alg113(Text1,[Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]).
+
+
+grammar_logic_to_alg113(Text1,[Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]) :-
+
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,BrDict01),
+	sort(BrDict01,BrDict012),
+	retractall(brdict(_)),
+	assertz(brdict(BrDict012)),
+
+	SepandPad=".\n",
+	split_string(Text1,SepandPad,SepandPad,Text2a),
+	delete(Text2a,"",Text2),
+	
+	findall(B2,(member(B1,Text2),grammar_logic_to_alg(B1,B2)),C),
+	length(C,CLength),
+	writeln([CLength,sentences]),
+	
+	C=[[[_,Sentence1,a_alg(List_a),_,bb_alg(List_bb)]|Cs1]|Cs2],
+		%%get_time(TS),stamp_date_time(TS,date(Year,Month,Day,Hour1,Minute1,Seconda,_A,_TZ,_False),local),
+	concat_list(["gla_del"],%%[Year,Month,Day,Hour1,Minute1,Seconda],
+	File1),
+	concat_list(["\"",File1,".txt\""],File2),
+
+	term_to_atom(List_a,List_a2),
+	string_atom(List_a3,List_a2),
+	
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_a1),
+
+	concat_list(["\n\nswipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,",[v,b]]],[[[n,function],[[v,a],[v,b]],\":-\",[[[n,tail],[[v,a],[v,b]]]]]],_),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_b1),
+
+	term_to_atom(List_bb,List_bb2),
+	string_atom(List_bb3,List_bb2),
+
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_bb3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_bb1).
+
+grammar_logic_to_alg(Sentence1,B) :- %% Not by multi-sentence algorithms, just by sentence
+	atom_string(Sentence0,Sentence1),
+	downcase_atom(Sentence0,Sentence01),
+	atom_string(Sentence01,Sentence02),
+	SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	
+	Connectors=
+		["the","a","i","on","with","of","an","for","to",
+		"was","were","and","in","my","from","out","by"],
+	split_string(Sentence02,SepandPad,SepandPad,Sentence2),
+	subtract(Sentence2,Connectors,Sentence3),
+	%%length(Sentence3,Length),
+	
+	%% () add generated data
+	%%write_commands(Length,[],Commands), %% sentence alg
+	
+	generate_sentences(Sentence3,[],Sentence_a,30), %% detail 	sentences
+	append(Sentence3,Sentence_a,Sentence4),
+	findall([*,Sentence1,a_alg(Sentence5),b_alg(Sentence5,a),bb_alg(Sentence6)],(member(Sentence4a,Sentence4),make_lists(Sentence4a,[],Sentence5),Sentence5=[_|Sentence6]),B),!.
+	  %% detail algs
+	
+generate_sentences(_Sentence3,Sentence_a,Sentence_a,0) :- !.
+generate_sentences(Sentence3,Sentence_a1,Sentence_a2,N1) :-
+	random_member(Item,Sentence3),
+	generate_sentence(Item,Sentence_a3),
+	append(Sentence_a1,[Sentence_a3],Sentence_a4),
+	N2 is N1-1,
+	generate_sentences(Sentence3,Sentence_a4,Sentence_a2,N2).
+
+%%write_commands(0,Commands,Commands) :- !.
+%%write_commands(Length1,Commands1,Commands2) :-
+%%	Length2 is Length1-1.
+%%	append(Commands1,[[[n,member2],[[v,Length1],[v,Length2]]]).
+	%%[[n,equals1],[[v,Length2],[[v,a***],[v,b]]]]].
+
+%%[a,b]
+%%[c,d]
+
+generate_sentence(Item,Sentence) :-
+	random_member(Grammar1,[[n,v,n],[n,v,a,n],[v,n],[v,a,n]]),
+	brdict(BrDict012),
+	find_pos(Item,POS,BrDict012),
+	substitute1(Item,POS,Grammar1,[],Grammar2),
+	substitute2(Grammar2,BrDict012,[],Sentence).
+
+find_pos("right",v,_) :- !.
+find_pos("plus",a,_) :- !.
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="right",
+	POS2=v,!.
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="plus",
+	POS2=a,!.
+find_pos(_Item,POS2,_BrDict012) :-
+	POS2=n.
+
+substitute1(_Item,_POS,[],Grammar,Grammar) :- !.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	Grammar4=POS,
+	append_list([Grammar2,Item],Grammar6),
+	append(Grammar6,Grammar5,Grammar3),!.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	not(Grammar4=POS),
+	append_list([Grammar2,Grammar4],Grammar6),
+	substitute1(Item,POS,Grammar5,Grammar6,Grammar3),!.
+
+substitute2([],_BrDict012,Sentence,Sentence) :- !.
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=n,
+	findall(A,(member([A,"box"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=v,
+	findall(A,(member([A,"right"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=a,
+	findall(A,(member([A,"plus"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	append(Sentence1,[Grammar2],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+
+make_lists(Sentence1,Sentence,Sentence) :-
+	Sentence1=[_Sentence2],
+	!.	
+make_lists(Sentence1,Sentence2,Sentence3) :-
+	Sentence1=[Sentence4|Sentence5],
+	Sentence5=[Sentence6|_Sentence7],
+	append(Sentence2,[[Sentence4,Sentence6]],Sentence8),
+	make_lists(Sentence5,Sentence8,Sentence3).
+

Algorithm-Writer-with-Lists/grammar_logic_to_alg2.pl

@@ -0,0 +1,265 @@
+/**
+
+?- grammar_logic_to_alg2(24).                                                       ["Simplify algorithm","pia","pear"]
+["What is the word for","person"]
+1	harry
+2	june
+3	person
+4	pia
+
+"Please choose from menu items 1-4, or enter a new word:"
+|: subject
+["Simplify algorithm","harry","banana"]
+["Simplify algorithm","apple","june"]
+[["subject","pia","pear","pear"],["subject","harry","banana","banana"],["subject","june","apple","apple"]]
+true.
+
+?- grammar_logic_to_alg.                                                        ["Simplify algorithm","pia","pear"]
+[["subject","pia","pear","pear"]]
+true.
+
+**/
+
+%:-include('../listprologinterpreter/la_strings.pl').
+:-include('../listprologinterpreter/la_strings.pl').
+:-include('../listprologinterpreter/la_strings_string.pl').
+:-include('../listprologinterpreter/la_maths.pl').
+
+grammar_logic_to_alg2(First_n_words) :-
+
+	% get file
+	phrase_from_file_s(string(String1),"../Text-to-Breasonings/file.txt"),
+	
+	% split into lines and sentences
+	%SepandPad2="\n\r",
+		SepandPad1="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	string_codes(String1b,String1),
+	downcase_atom(String1b,String1c),
+	string_codes(String1c,String1a),
+	split_string(String1a,SepandPad1,SepandPad1,String21),
+	length(String21,L),
+	(L<First_n_words->First_n_words1=L;First_n_words1=First_n_words),
+	length(String2,First_n_words1),
+	append(String2,_,String21),
+	
+
+%	phrase_from_file_s(string(BrDict0), "../../Text-to-Breasonings/brdict1.txt"),
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,Term),
+
+%trace,	
+	phrase_from_file_s(string(BrDict3), "../Algorithm-Writer-with-Lists/brdict3.txt"),
+		string_codes(String02ba,BrDict3),
+		atom_to_term(String02ba,Term1,[]),
+
+	/**
+	phrase_from_file_s(string(BrDict4), "first-words.txt"),
+		string_codes(String02b,BrDict4),
+		atom_to_term(String02b,String02a,[]),
+	**/
+	%trace,
+	% Finds additions to brdict3.txt (box,values)
+	process_file(String2,Term,Term1,%String02a,%[],
+	Additions_to_brdict3,[],Pseudo_algorithms%,%[],
+	%First_words
+	),
+	
+	%***append(Term1,Additions_to_brdict3,Additions_to_brdict3_2),
+	
+	term_to_atom(Additions_to_brdict3,String02a_b),
+	string_atom(String02a_c,String02a_b),
+
+	(open_s("../Algorithm-Writer-with-Lists/brdict3.txt",write,Stream1),
+	write(Stream1,String02a_c),
+	close(Stream1)),!,
+
+	%***append(String02a,First_words,First_words_2),
+	
+	/**
+	term_to_atom(First_words,First_words_2_b),
+	string_atom(First_words_2_c,First_words_2_b),
+
+	(open_s("first-words.txt",write,Stream2),
+	write(Stream2,First_words_2_c),
+	close(Stream2)),!,
+	**/
+	
+	writeln1(Pseudo_algorithms),!,
+	
+	random_member(Summary_algorithm,Pseudo_algorithms),
+	writeln1("Summary algorithm:"),
+	writeln1(Summary_algorithm).
+
+	process_file(String2,Term,Term1,%_String02a,%Additions_to_brdict31,
+	Additions_to_brdict3,Pseudo_algorithms1,Pseudo_algorithms%,First_words1,
+	%First_words
+	) :-
+	%trace,
+	String2=[Word1,Word2|Words],
+	writeln1(["Simplify algorithm",Word1,Word2]),
+	found(Word1,Term,Term1,Item1,%Term1,
+	Additions_to_brdict31_4),
+	found(Word2,Term,Additions_to_brdict31_4,Item2,%Additions_to_brdict31_4,
+	Additions_to_brdict31_5),	
+	stronger_word([Item1,Word1],[Item2,Word2],Term,_Word3,%String02a,First_words3,
+	Item_a),
+	append(Pseudo_algorithms1,[Item_a],Pseudo_algorithms2),
+		%trace,
+		process_file(Words,Term,Additions_to_brdict31_5,%First_words3,%Additions_to_brdict31_5,
+		Additions_to_brdict3,Pseudo_algorithms2,Pseudo_algorithms%,First_words3,
+		%First_words
+		).
+
+	process_file(_,_Term,Term1,%String02a,%Additions_to_brdict3,
+	Term1,Pseudo_algorithms,Pseudo_algorithms%,First_words,
+	%String02a
+	) :- !.
+
+
+
+% bd3 - person, subject and
+found(Word1,Term,Additions_to_brdict1,Word2,%Additions_to_brdict1,
+Additions_to_brdict2) :-
+%(Word1="bot"->trace;true),
+	%trace,
+	%(Word1="june"->trace;true),
+	
+	(member([Word1,Word21],Term)->true;(writeln(["Error:",Word1,"not in brdict1.txt."]),abort)),
+	(Word21=""->Word2=Word1;Word2=Word21),
+	
+append(Additions_to_brdict1,[[Word2,Word1]],Additions_to_brdict2)
+
+/**	(member([Word2,Item1],Additions_to_brdict1)->Additions_to_brdict1=Additions_to_brdict2;
+	(%trace,
+	
+	
+	findall(Word3,(member([Word3,Word2],Term)),Word22),
+	append([Word2],Word22,Word23),
+	%trace,
+	sort(Word23,Word241),
+	delete(Word241,"",Word24),
+	
+	length(Word24,Menu_items_length),
+	(Menu_items_length=1->([Item1]=Word24,
+	append(Additions_to_brdict1,[[Word2,Item1]],Additions_to_brdict2));
+	(writeln1(["What is the word for",Word1]),
+	numbers(Menu_items_length,1,[],N),
+	findall([N1,"\t",Menu_item,"\n"],(member(N1,N),
+	get_item_n(Word24,N1,Menu_item)),Menu1),
+	maplist(append,[Menu1],[Menu3]),
+	concat_list(Menu3,Menu2),
+	writeln(Menu2),
+
+	repeat,%trace,
+	concat_list(["Please choose from menu items 1-",Menu_items_length,", or enter a new word (letters only, no spaces):"],Prompt),
+	writeln1(Prompt),
+	read_string(user_input,"\n","\r",_,Input),
+	((%trace,
+	number_string(Input_num,Input),
+	Input_num>=1,Input_num=<Menu_items_length,
+	%trace,
+	get_item_n(Menu1,Input_num,[_,_,Item1,_]),
+	%trace,
+	append(Additions_to_brdict1,[[Word2,Item1]],Additions_to_brdict2))->true;
+		(string(Input)->(Input=Item1,append(Additions_to_brdict1,[[Word2,Item1]],Additions_to_brdict2))
+)))))).
+**/
+.
+	
+stronger_word([Word1,Word1a],[Word2aa,Word2a],Term,Word3%,First_words1,First_words
+,Item) :-
+	%trace,
+	(member([Word1,Word21],Term)->true;(writeln(["Error:",Word1,"not in brdict1.txt."]),abort)),
+	(Word21=""->Word2=Word1;Word2=Word21),
+	%(member([Word2,Item1],Additions_to_brdict1)->Additions_to_brdict1=Additions_to_brdict2;
+	(%trace,
+	
+	
+	findall(Word3,(member([Word3,Word2],Term)),Word22),
+	append([Word2],Word22,Word23),
+	%trace,
+	sort(Word23,Word241),
+	delete(Word241,"",Word24),
+	
+	length(Word24,Menu_items_length)),
+
+	
+	(member([Word2aa,Word21a],Term)->true;(writeln(["Error:",Word2aa,"not in brdict1.txt."]),abort)),
+	(Word21a=""->Word2ab=Word2aa;Word2ab=Word21a),
+	%(member([Word2aa,Item1a],Additions_to_brdict1)->Additions_to_brdict1=Additions_to_brdict2;
+	(%trace,
+	
+	
+	findall(Word3,(member([Word3,Word2ab],Term)),Word22a),
+	append([Word2ab],Word22a,Word23a),
+	%trace,
+	sort(Word23a,Word241a),
+	delete(Word241a,"",Word24a),
+	
+	length(Word24a,Menu_items_length_a)),
+
+/**(member(Word1,String02a)->(First_words1=First_words,Item=[Word1,Word1a,Word2,Word2a]);
+	(member(Word2,String02a)->(First_words1=First_words,Item=[Word2,Word2a,Word1,Word1a]);
+	(%trace,
+	writeln(["Which of 1-",Word1,"or 2-",Word2,"is stronger?"]),
+	read_string(user_input,"\n","\r",_,Input),
+	**/
+	%trace,
+	(Menu_items_length>=Menu_items_length_a->(Word3=Word1,Item=[Word1,Word1a,Word2aa,Word2a]);
+	(Word3=Word2,Item=[Word2aa,Word2a,Word1,Word1a])).
+	%append(First_words1,[Word3],First_words)))).
+	
+	
+	% Append punctuation point to end if necessary.
+	% find last character in file
+	%	string_concat(_,".",String1),
+
+/**
+split_string_onnonletter(String00,Chars,List1) :-
+	string_codes(String00,String1),
+	split_string_onnonletter(String1,[],Chars,List0),
+	string_codes(List0,List2),
+	split_string(List2,"@","@",List1),!.
+split_string_onnonletter([],Input,_Chars,Input) :- !.
+split_string_onnonletter(Input1,Input2,Chars,Input3) :-
+	Input1=[Input4|Input5],
+	%not(char_type(Input4,alpha)),
+	string_codes(Chars,Codes),
+	member(Code,Codes),
+	Input4=Code,
+	append(Input2,[Code],Input7),
+	append(Input7,`@`,Input6),
+	split_string_onnonletter(Input5,Input6,Chars,Input3), !.
+split_string_onnonletter(Input1,Input2,Chars,Input3) :-
+	Input1=[Input4|Input5],
+	%char_type(Input4,alpha),
+	append(Input2,[Input4],Input6),
+	split_string_onnonletter(Input5,Input6,Chars,Input3), !.
+**/
+
+splitfurther(BrDict01,N) :-
+	   phrase(file0(N),BrDict01).
+	
+file0(N) --> "[", file(N), "]", !.
+file0([]) --> [].
+
+%%file([]) --> [].
+file([L|Ls]) --> entry(L),",",
+%{writeln(L)}, %%***
+file(Ls), !. %% file(Ls),{M=[Ls]})), !. %%, {writeln(["l",L])},",", file(Ls), {writeln(["ls",Ls])},!. %%, {append(L,Ls,M)}, !.	
+file([L]) --> entry(L), 
+%%{writeln(L)},
+!. %%(entry(L),{M=L});{M=[],(writeln("Warning - Entry in incorrect format.")
+%%,abort
+%%)}, !.
+
+entry([Word2,Word4]) -->
+		"[", word(Word), {string_codes(Word2,Word),string(Word2)},
+		",",
+           word(Word3), {string_codes(Word4,Word3),string(Word4)},
+           "]".
+           
+word([X|Xs]) --> [X], {char_type(X,csymf)->true;(X=27->true;X=8217)}, word(Xs), !.
+%%word([X]) --> [X], {char_type(X,csymf);(X=27;X=8217)}, !.
+word([]) --> [].
+           

Algorithm-Writer-with-Lists/grammar_logic_to_alg_mr.pl

@@ -0,0 +1,275 @@
+/**
+
+grammar_logic_to_alg.pl
+
+
+e.g. I liked God with you
+[liked,God],[God,you] with extra data
+- connect liked to you with member, return words on path
+
+POS
+
+goes backwards x forwards
+- I v n by v n x ignore
+
+n,v
+- single type
+
+adjective
+- ignored x (ignore names in alg)
+- like v,n
+
+joining words - ignore, just pairs v, n
+- on
+- joins v to n
+- separates vns
+
+negative terms
+- switch to positive or ignore
+
+disappearing words
+- my
+- no list of these, because they are ignored
+
+vv is v1, v2 x v1
+nn is n1
+
+*
+
+later: can randomly generate details like given sentence
+
+**/
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+:-include('../Text-to-Breasonings/truncate.pl').
+:-include('../Music-Composer/mindreadtestmusiccomposer-unusual-mr-tree.pl').
+
+
+:- dynamic brdict/1.
+
+
+
+mt_t2b2:-
+%Thread=
+	%[
+	phrase_from_file_s(string(Essay_0), %"lacom5million.txt"
+	"../../private/lacom0.5million.txt"
+	),
+
+	%Br is 5,
+	%Br is 5000000,
+	W is 0,
+	
+	%grammar_logic_to_alg1(Essay_0,Br,GL_out1),
+	grammar_logic_to_alg113(Essay_0,GL_out1),
+
+	term_to_atom(GL_out1,GL_out2),
+	string_atom(GL_out,GL_out2),
+
+	texttobr2(u,u,GL_out,Br,false,false,false,false,false,false,W),
+	texttobr(u,u,GL_out,Br).%],
+
+mt_t2b3:-mt_t2b2.
+	
+mt_t2b4:-mt_t2b2.	
+
+mt_t2b5:-mt_t2b2.	
+
+mt_t2b6:-mt_t2b2.	
+
+mt_t2b7:-mt_t2b2.	
+
+mt_t2b8:-mt_t2b2.	
+
+mt_t2b9:-mt_t2b2.	
+	%trace,Thread.
+	
+
+mt_t2b :-	
+
+Goals=[mt_t2b2,mt_t2b3,mt_t2b4,mt_t2b5,mt_t2b6,mt_t2b7,mt_t2b8,mt_t2b9
+],
+
+length(Goals,L),
+
+%time(mt_t2b2).
+time(concurrent(L,Goals,[])).
+	
+grammar_logic_to_alg1(String1,N,Result) :-
+
+	%term_to_atom(String,Essay_01),
+	%string_atom(Essay_02,Essay_01),
+
+	%working_directory(_, '../'),
+	
+	%(open_s("../Text-to-Breasonings/file.txt",write,Stream1),
+	%write(Stream1,String),
+	%close(Stream1)),!,
+
+	truncate1(string,String1,N,String),
+
+	%working_directory(_, 'algwriter/'),
+	grammar_logic_to_alg114(String,Result).
+	
+grammar_logic_to_alg1 :-
+	grammar_logic_to_alg11([Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]),
+	writeln1([*,Sentence1,a_alg(List_a)]),
+	writeln(List_a1),
+	writeln1([*,Sentence1,b_alg(List_a)]),
+	writeln(List_b1),
+	writeln1([*,Sentence1,bb_alg(List_bb)]),
+	writeln(List_bb1),
+
+	writeln1(Cs1),
+	writeln1(Cs2).
+
+grammar_logic_to_alg112(Result) :-
+	grammar_logic_to_alg11(Result1),term_to_atom(Result1,Result).
+
+grammar_logic_to_alg114(Text,Result) :-
+	grammar_logic_to_alg113(Text,Result1),term_to_atom(Result1,Result).
+
+
+grammar_logic_to_alg11([Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]) :-
+	phrase_from_file_s(string(Text1), "../Text-to-Breasonings/file.txt"),
+
+grammar_logic_to_alg113(Text1,[Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]).
+
+
+grammar_logic_to_alg113(Text1,[Sentence1,List_a,List_a1,List_b1,List_bb,List_bb1,Cs1,Cs2]) :-
+
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,BrDict01),
+	sort(BrDict01,BrDict012),
+	retractall(brdict(_)),
+	assertz(brdict(BrDict012)),
+
+	SepandPad=".\n",
+	split_string(Text1,SepandPad,SepandPad,Text2a),
+	delete(Text2a,"",Text2),
+	
+	findall(B2,(member(B1,Text2),grammar_logic_to_alg(B1,B2)),C),
+	length(C,CLength),
+	writeln([CLength,sentences]),
+	
+	C=[[[_,Sentence1,a_alg(List_a),_,bb_alg(List_bb)]|Cs1]|Cs2],
+		%%get_time(TS),stamp_date_time(TS,date(Year,Month,Day,Hour1,Minute1,Seconda,_A,_TZ,_False),local),
+	concat_list(["gla_del"],%%[Year,Month,Day,Hour1,Minute1,Seconda],
+	File1),
+	concat_list(["\"",File1,".txt\""],File2),
+
+	term_to_atom(List_a,List_a2),
+	string_atom(List_a3,List_a2),
+	
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_a1),
+
+	concat_list(["\n\nswipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,",[v,b]]],[[[n,function],[[v,a],[v,b]],\":-\",[[[n,tail],[[v,a],[v,b]]]]]],_),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_b1),
+
+	term_to_atom(List_bb,List_bb2),
+	string_atom(List_bb3,List_bb2),
+
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_bb3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_bb1).
+
+grammar_logic_to_alg(Sentence1,B) :- %% Not by multi-sentence algorithms, just by sentence
+	atom_string(Sentence0,Sentence1),
+	downcase_atom(Sentence0,Sentence01),
+	atom_string(Sentence01,Sentence02),
+	SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	Connectors=
+		["the","a","i","on","with","of","an","for","to",
+		"was","were","and","in","my","from","out","by"],
+	split_string(Sentence02,SepandPad,SepandPad,Sentence2),
+	subtract(Sentence2,Connectors,Sentence3),
+	%%length(Sentence3,Length),
+	
+	%% () add generated data
+	%%write_commands(Length,[],Commands), %% sentence alg
+	
+	generate_sentences(Sentence3,[],Sentence_a,1), %% detail 	sentences
+	append(Sentence3,Sentence_a,Sentence4),
+	findall([*,Sentence1,a_alg(Sentence5),b_alg(Sentence5,a),bb_alg(Sentence6)],(member(Sentence4a,Sentence4),make_lists(Sentence4a,[],Sentence5),Sentence5=[_|Sentence6]),B),!.
+	  %% detail algs
+	
+generate_sentences(_Sentence3,Sentence_a,Sentence_a,0) :- !.
+generate_sentences(Sentence3,Sentence_a1,Sentence_a2,N1) :-
+	random_member(Item,Sentence3),
+	generate_sentence(Item,Sentence_a3),
+	append(Sentence_a1,[Sentence_a3],Sentence_a4),
+	N2 is N1-1,
+	generate_sentences(Sentence3,Sentence_a4,Sentence_a2,N2).
+
+%%write_commands(0,Commands,Commands) :- !.
+%%write_commands(Length1,Commands1,Commands2) :-
+%%	Length2 is Length1-1.
+%%	append(Commands1,[[[n,member2],[[v,Length1],[v,Length2]]]).
+	%%[[n,equals1],[[v,Length2],[[v,a***],[v,b]]]]].
+
+%%[a,b]
+%%[c,d]
+
+generate_sentence(Item,Sentence) :-
+	random_member(Grammar1,[[n,v,n],[n,v,a,n],[v,n],[v,a,n]]),
+	brdict(BrDict012),
+	find_pos(Item,POS,BrDict012),
+	substitute1(Item,POS,Grammar1,[],Grammar2),
+	substitute2(Grammar2,BrDict012,[],Sentence).
+
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="right",
+	POS2=v,!.
+find_pos(Item,POS2,BrDict012) :-
+	member([Item,POS1],BrDict012),
+	POS1="plus",
+	POS2=a,!.
+find_pos(_Item,POS2,_BrDict012) :-
+	POS2=n.
+
+substitute1(_Item,_POS,[],Grammar,Grammar) :- !.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	Grammar4=POS,
+	append_list([Grammar2,Item],Grammar6),
+	append(Grammar6,Grammar5,Grammar3),!.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	not(Grammar4=POS),
+	append_list([Grammar2,Grammar4],Grammar6),
+	substitute1(Item,POS,Grammar5,Grammar6,Grammar3),!.
+
+substitute2([],_BrDict012,Sentence,Sentence) :- !.
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=n,
+	findall(A,(member([A,"box"],BrDict012)),B),
+	mind_read(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=v,
+	findall(A,(member([A,"right"],BrDict012)),B),
+	mind_read(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=a,
+	findall(A,(member([A,"plus"],BrDict012)),B),
+	mind_read(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	append(Sentence1,[Grammar2],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+
+make_lists(Sentence1,Sentence,Sentence) :-
+	Sentence1=[_Sentence2],
+	!.	
+make_lists(Sentence1,Sentence2,Sentence3) :-
+	Sentence1=[Sentence4|Sentence5],
+	Sentence5=[Sentence6|_Sentence7],
+	append(Sentence2,[[Sentence4,Sentence6]],Sentence8),
+	make_lists(Sentence5,Sentence8,Sentence3).
+

Algorithm-Writer-with-Lists/grammar_logic_to_alg_random.pl

@@ -0,0 +1,197 @@
+/**
+
+grammar_logic_to_alg_without_brdict.pl
+
+**/
+
+:-include('../Text-to-Breasonings/text_to_breasonings.pl').
+
+:- dynamic brdict/1.
+:- dynamic brdict_pos/1.
+
+%% given N sentences to generate, takes a sentence and M sentences to find substitution words from
+
+grammar_logic_to_alg1 :-
+	phrase_from_file_s(string(Text1), "../Text-to-Breasonings/luciansphilosophy.txt"),
+
+
+	phrase_from_file_s(string(BrDict0), "../Text-to-Breasonings/brdict1.txt"),
+	splitfurther(BrDict0,BrDict01),
+	sort(BrDict01,BrDict012),
+	retractall(brdict_pos(_)),
+	assertz(brdict_pos(BrDict012)),
+
+	SepandPad=".\n",
+	split_string(Text1,SepandPad,SepandPad,Text2a),
+	delete(Text2a,"",Text222),
+
+%%	random(N1),N2 is round(9*N1)+1,length(N2L,N2),
+	N2L=[_],
+	findall(N3,(member(_,N2L),random_member(N3,Text222)),N4),
+	
+	%%writeln([n4,N4]),
+	
+%%	append_list(N4,Text2),
+	
+
+	
+	findall(B2,(	%%random(M1),M2 is round(9*M1)+1,length(M2L,M2),
+	
+
+	%%SepandPad2=" .\n",
+	%%split_string(Text1,SepandPad2,SepandPad2,Text2aa),
+	%%delete(Text2aa,"",M3),
+
+	%%findall(M33,(member(_,M2L),random_member(M33,M3)),M4),
+	M4 = Text222,
+	%%writeln([m4,M4]),
+	
+	%%append_list(Text2aaa,M5),
+	retractall(brdict(_)),
+	assertz(brdict(M4)),
+
+	member(B1,N4),
+	
+	%%trace,
+	
+	grammar_logic_to_alg(B1,B2)),C),
+	length(C,CLength),
+	writeln1([CLength,sentences]),
+	
+	C=[[[_,Sentence1,a_alg(List_a),_,bb_alg(List_bb)]|Cs1]|Cs2],
+		%%get_time(TS),stamp_date_time(TS,date(Year,Month,Day,Hour1,Minute1,Seconda,_A,_TZ,_False),local),
+	concat_list(["gla_del"],%%[Year,Month,Day,Hour1,Minute1,Seconda],
+	File1),
+	concat_list(["\"",File1,".txt\""],File2),
+
+	term_to_atom(List_a,List_a2),
+	string_atom(List_a3,List_a2),
+	
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_a1),
+	writeln1([*,Sentence1,a_alg(List_a)]),
+	writeln1(List_a1),
+
+	concat_list(["\n\nswipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_a3,",[v,b]]],[[[n,function],[[v,a],[v,b]],\":-\",[[[n,tail],[[v,a],[v,b]]]]]],_),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_b1),
+	writeln1([*,Sentence1,b_alg(List_a)]),
+	writeln1(List_b1),
+
+	term_to_atom(List_bb,List_bb2),
+	string_atom(List_bb3,List_bb2),
+
+	concat_list(["swipl -G100g -T20g -L2g\n['../listprolog'].\nleash(-all),visible(+all),protocol(",File2,"),trace,interpret(off,[[n,function],[",List_bb3,"]],[[[n,function],[[v,a]],\":-\",[[[n,length],[[v,a],0,1]]]],[[n,function],[[v,a]],\":-\",[[[n,head],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,e],[v,f]]]],[[n,reverse],[[v,a],[],[v,a1]]],[[n,head],[[v,a1],[v,d1]]],[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],[[n,function2],[[v,a],[v,f],[v,f1]]]]],[[n,reverse],[[],[v,l],[v,l]]],[[n,reverse],[[v,l],[v,m],[v,n]],\":-\",[[[n,head],[[v,l],[v,h]]],[[n,tail],[[v,l],[v,t]]],[[n,wrap],[[v,h],[v,h1]]],[[n,append],[[v,h1],[v,m],[v,o]]],[[n,reverse],[[v,t],[v,o],[v,n]]]]],[[n,function2],[[v,a],[v,b],[v,f]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],[[n,function2],[[v,a],[v,b],[v,c]],\":-\",[[[n,member2],[[v,a],[v,d]]],[[n,equals1],[[v,d],[[v,b],[v,f]]]],[[n,function2],[[v,d],[v,f],[v,c]]]]],[[n,length],[[],[v,l],[v,l]]],[[n,length],[[v,l],[v,m1],[v,n]],\":-\",[[[n,not],[[[n,=],[[v,l],[]]]]],[[n,tail],[[v,l],[v,t]]],[[n,+],[[v,m1],1,[v,m2]]],[[n,length],[[v,t],[v,m2],[v,n]]]]]],[[]]),notrace,noprotocol.\nhalt.\nswipl -G100g -T20g -L2g\n['../Text-to-Breasonings/text_to_breasonings.pl'].\ntime((N is 3,\nM is 16000,\ntexttobr2(N,",File2,",u,M),texttobr(N,",File2,",u,M))).\n['../texttobr2qb'].\ntexttobr2(3).\nhalt."],List_bb1),
+	writeln1([*,Sentence1,bb_alg(List_bb)]),
+	writeln1(List_bb1),
+
+	writeln1(Cs1),
+	writeln1(Cs2).
+
+grammar_logic_to_alg(Sentence1,B) :- %% Not by multi-sentence algorithms, just by sentence
+	atom_string(Sentence0,Sentence1),
+	downcase_atom(Sentence0,Sentence01),
+	atom_string(Sentence01,Sentence02),
+	SepandPad="&#@~%`$?-+*^,()|.:;=_/[]<>{}\n\r\s\t\\\"!'0123456789",
+	Connectors=
+		["the","a","i","on","with","of","an","for","to",
+		"was","were","and","in","my","from","out","by"],
+	split_string(Sentence02,SepandPad,SepandPad,Sentence2),
+	subtract(Sentence2,Connectors,Sentence3),
+	%%length(Sentence3,Length),
+	
+	%% () add generated data
+	%%write_commands(Length,[],Commands), %% sentence alg
+	
+	generate_sentences(Sentence3,[],Sentence_a,30), %% detail 	sentences
+	append([Sentence3],Sentence_a,Sentence4),
+	findall([*,Sentence1,a_alg(Sentence5),b_alg(Sentence5,a),bb_alg(Sentence6)],(member(Sentence4a,Sentence4),make_lists(Sentence4a,[],Sentence5),Sentence5=[_|Sentence6]),B),!.
+	  %% detail algs
+	
+generate_sentences(_Sentence3,Sentence_a,Sentence_a,0) :- !.
+generate_sentences(Sentence3,Sentence_a1,Sentence_a2,N1) :-
+	random_member(Item,Sentence3),
+	%%trace,
+	generate_sentence(Item,Sentence_a3),
+	append(Sentence_a1,[Sentence_a3],Sentence_a4),
+	N2 is N1-1,
+	generate_sentences(Sentence3,Sentence_a4,Sentence_a2,N2).
+
+%%write_commands(0,Commands,Commands) :- !.
+%%write_commands(Length1,Commands1,Commands2) :-
+%%	Length2 is Length1-1.
+%%	append(Commands1,[[[n,member2],[[v,Length1],[v,Length2]]]).
+	%%[[n,equals1],[[v,Length2],[[v,a***],[v,b]]]]].
+
+%%[a,b]
+%%[c,d]
+
+generate_sentence(Item,Sentence) :-
+	random_member(Grammar1,[[n,v,n,n,v,a,n,v,n,v,a,n],[n,v,n],[n,v,a,n],[v,n],[v,a,n]]),
+	brdict_pos(BrDict012),
+	find_pos(Item,POS,BrDict012),
+	substitute1(Item,POS,Grammar1,[],Grammar2),
+	substitute2(Grammar2,BrDict012,[],Sentence).
+
+find_pos(Item,POS2,BrDict012) :-
+	POS1="right",
+	member([Item,POS1],BrDict012),
+	POS2=v,!.
+find_pos(Item,POS2,BrDict012) :-
+	POS1="plus",
+	member([Item,POS1],BrDict012),
+	POS2=a,!.
+find_pos(_Item,POS2,_BrDict012) :-
+	POS2=n.
+
+substitute1(_Item,_POS,[],Grammar,Grammar) :- !.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	Grammar4=POS,
+	append_list([Grammar2,Item],Grammar6),
+	append(Grammar6,Grammar5,Grammar3),!.
+substitute1(Item,POS,Grammar1,Grammar2,Grammar3) :-
+	Grammar1=[Grammar4|Grammar5],
+	not(Grammar4=POS),
+	append_list([Grammar2,Grammar4],Grammar6),
+	substitute1(Item,POS,Grammar5,Grammar6,Grammar3),!.
+
+substitute2([],_BrDict012,Sentence,Sentence) :- !.
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=n,
+	findall(A,(%%brdict(BD),member(A,BD),!,
+	member([A,"box"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=v,
+	findall(A,(%%brdict(BD),member(A,BD),!,
+	member([A,"right"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	Grammar2=a,
+	findall(A,(%%brdict(BD),member(A,BD),!,
+	member([A,"plus"],BrDict012)),B),
+	random_member(Word,B),
+	append(Sentence1,[Word],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+substitute2(Grammar1,BrDict012,Sentence1,Sentence2) :-
+	Grammar1=[Grammar2|Grammar3],
+	append(Sentence1,[Grammar2],Sentence3),
+	substitute2(Grammar3,BrDict012,Sentence3,Sentence2).
+
+make_lists(Sentence1,Sentence,Sentence) :-
+	Sentence1=[_Sentence2],
+	!.	
+make_lists(Sentence1,Sentence2,Sentence3) :-
+	Sentence1=[Sentence4|Sentence5],
+	Sentence5=[Sentence6|_Sentence7],
+	append(Sentence2,[[Sentence4,Sentence6]],Sentence8),
+	make_lists(Sentence5,Sentence8,Sentence3).
+
+writeln1(Term) :-
+	term_to_atom(Term,Atom),
+	writeln(Atom),!.

Algorithm-Writer-with-Lists/grammar_logic_to_alg_sh.txt

@@ -0,0 +1,9 @@
+%% grammar_logic_to_alg.sh
+
+swipl -G100g -T20g -L2g
+[grammar_logic_to_alg].
+leash(-all),visible(+all),protocol("./gla.txt").
+grammar_logic_to_alg1.
+noprotocol.
+halt.
+

Algorithm-Writer-with-Lists/midnight_algorithm_input_list.pl

@@ -0,0 +1,68 @@
+:-include('../listprologinterpreter/la_strings').
+
+
+midnight_algorithm_input_list :-
+writeln("Algorithm name?"),
+	read_string(user_input, "\n", "\r", _End2, Alg_name),
+writeln("List item 1?"),
+	read_string(user_input, "\n", "\r", _End21, List_item1),
+writeln("List item 2?"),
+	read_string(user_input, "\n", "\r", _End22, List_item2),
+writeln("List item 3?"),
+	read_string(user_input, "\n", "\r", _End23, List_item3),
+writeln("List item 4?"),
+	read_string(user_input, "\n", "\r", _End24, List_item4),
+	Algorithm=
+	
+	[[[n,Alg_name],[[[List_item1,List_item2],[List_item2,List_item3],[List_item3,List_item4]]]],
+        [[[n,Alg_name],[[[t,list],[[t,list2]]]]],
+        [[t,list2],[[t,string],[t,string]]],
+        [[n,reverse],[[[t,list],[[t,list2]]],[[t,list],[[t,list2]]],[[t,list],[[t,list2]]]]],
+        [[n,function2],[[[t,list],[[t,list2]]],[t,string],[t,string]]],
+        [[n,length],[[[t,list],[[t,list2]]],[t,number],[t,number]]]],
+        
+        [[[n,Alg_name],[input]],
+        [[n,reverse],[input,input,output]],
+        [[n,function2],[input,input,input]],
+        [[n,length],[input,input,output]]],
+
+[[[n,Alg_name],[[v,a]],":-",
+[[[n,length],[[v,a],0,[v,b]]],
+[[n,=],[[v,b],1]]]],
+
+[[n,Alg_name],[[v,a]],":-",
+[[[n,head],[[v,a],[v,d]]],
+[[n,equals1],[[v,d],[[v,e],[v,f]]]],
+[[n,reverse],[[v,a],[],[v,a1]]],
+[[n,head],[[v,a1],[v,d1]]],
+[[n,equals1],[[v,d1],[[v,e1],[v,f1]]]],
+[[n,function2],[[v,a],[v,f],[v,f1]]]]],
+
+[[n,reverse],[[],[v,l],[v,l]]],
+
+[[n,reverse],[[v,l],[v,m],[v,n]],":-",
+[[[n,head],[[v,l],[v,h]]],
+[[n,tail],[[v,l],[v,t]]],
+[[n,wrap],[[v,h],[v,h1]]],
+[[n,append],[[v,h1],[v,m],[v,o]]],
+[[n,reverse],[[v,t],[v,o],[v,n]]]]],
+
+[[n,function2],[[v,a],[v,b],[v,f]],":-",
+[[[n,member],[[v,d],[v,a]]],
+[[n,equals1],[[v,d],[[v,b],[v,f]]]]]],
+
+[[n,function2],[[v,a],[v,b],[v,c]],":-",
+[[[n,member],[[v,d],[v,a]]],
+[[n,equals1],[[v,d],[[v,b],[v,f]]]],
+[[n,function2],[[v,d],[v,f],[v,c]]]]],
+
+[[n,length],[[],[v,l],[v,l]]],
+
+[[n,length],[[v,l],[v,m1],[v,n]],":-",
+[[[n,not],[[[n,=],[[v,l],[]]]]],
+[[n,tail],[[v,l],[v,t]]],
+[[n,+],[[v,m1],1,[v,m2]]],
+[[n,length],[[v,t],[v,m2],[v,n]]]]]],
+[[]]],
+
+writeln1([algorithm,Algorithm]).

Algorithm-Writer-with-Lists/mr_alg.pl

@@ -0,0 +1,57 @@
+% [[[n,member],[[list],[_3386]]],[[n,member],[[list],[list]]],[[n,intersection],[[list],[list]]],[[n,member],[[list],[_5928]]],[[n,atom_string],[[atom],[string]]],[[n,string_length],[[string],[number]]]]
+
+mr_alg(Commands3) :-
+ commands(Commands),
+ algorithm_length(Algorithm_length),
+ random_member(Command1,Commands),
+ Command1=[_Name1,[_Input1,Output1]],
+ mr_alg(Algorithm_length,Commands,Output1,[],Commands2),
+ append([Command1],Commands2,Commands3).
+ 
+mr_alg(1,_,_,Commands,Commands) :- !.
+mr_alg(Algorithm_length1,Commands,Output1,Commands1,Commands2) :-
+ findall(Command2,(member(Command2,Commands),
+ Command2=[_Name2,[Output1,_Output2]]),Commands3),
+ random_member(Command4,Commands3),
+ Command4=[_Name3,[_Input3,Output3]],
+ append(Commands1,[Command4],Commands5),
+ Algorithm_length2 is Algorithm_length1 - 1,
+ mr_alg(Algorithm_length2,Commands,Output3,Commands5,Commands2).
+ 
+algorithm_length(5).
+
+%& check if any of these have 3 args - x
+commands([
+[[n,+],[[number,number],[number]]],
+[[n,-],[[number,number],[number]]],
+[[n,*],[[number,number],[number]]],
+[[n,/],[[number,number],[number]]],
+[[n,/],[[number,number],[]]],
+[[n,>],[[number,number],[]]],
+[[n,>=],[[number,number],[]]],
+[[n,<],[[number,number],[]]],
+[[n,=<],[[number,number],[]]],
+[[n,=],[[number,number],[]]],
+[[n,=\=],[[number,number],[]]],
+[[n,head],[[list],[_]]],
+[[n,tail],[[list],[_]]],
+[[n,member],[[list],[_]]], % swapped for this exercise
+[[n,delete],[[list,_],[list]]],
+[[n,append123],[[list,list],[list]]], % append([1],[2],A).
+[[n,append132],[[list,list],[list]]], % append([1],A,[1,2]).
+[[n,append231],[[list,list],[list]]], % append(A,[2],[1,2]).
+ % append(A,B,[1,2]). x
+[[n,stringconcat123],[[string,string],[string]]], % string("1","2",A).
+[[n,stringconcat132],[[string,string],[string]]], % string("1",A,"12").
+[[n,stringconcat231],[[string,string],[string]]], % string(A,"2","12").
+[[n,stringtonumber],[[string],[number]]],
+[[n,random],[[number]]],
+[[n,length],[[list],[number]]],
+[[n,ceiling],[[number],[number]]],
+[[n,sqrt],[[number],[number]]],
+[[n,round],[[number],[number]]],
+[[n,string_length],[[string],[number]]],
+[[n,sort],[[list],[_]]],
+[[n,intersection],[[list,list],[list]]],
+[[n,atom_string],[[atom],[string]]]
+]).

Algorithm-Writer-with-Lists/random_dependencies.pl

@@ -0,0 +1,17 @@
+random_dependencies(A) :-
+	random(N1),N2 is round(2*N1),
+	random_dependencies1(N2,A).
+random_dependencies1(0,[]) :- !.
+random_dependencies1(1,A) :-
+	random_member(B,[and,or,reverse,string_to_list,
+split_into_sentences,is_positive_language,agrees,member,delete,minus,get_item_n,length,intersection,
+substring,sum,sort,maximum,map,findall,duplicates,mutually_exclusive,list_head,add_number_to_list]),
+random_dependencies(C),
+A=[B,[C]].
+
+random_dependencies1(2,A) :-
+	random_member(B,[and,or,reverse,string_to_list,
+split_into_sentences,is_positive_language,agrees,member,delete,minus,get_item_n,length,intersection,
+substring,sum,sort,maximum,map,findall,duplicates,mutually_exclusive,list_head,add_number_to_list]),
+random_dependencies(C),random_dependencies(D),
+A=[B,[C,D]].

Algorithm-Writer-with-Lists/ya_phil_to_alg.pl

@@ -0,0 +1,45 @@
+:-include('../Lucian-Academy/folders.pl').
+:-include('mr_alg.pl').
+:-include('../listprologinterpreter/la_strings.pl').
+:-include('../listprologinterpreter/la_strings_string.pl').
+:-include('../listprologinterpreter/la_files.pl').
+
+% start with 1g memory
+
+ya_phil_to_alg :-
+
+folders(Courses1),
+%random_member(Course,Courses1),
+		%get_texts(Dept,Texts) :-
+
+findall(Texts1,(member(Dept,Courses1),	concat_list(["../Lucian-Academy/",Dept,"/"],Dept1),
+	directory_files(Dept1,F),
+	delete_invisibles_etc(F,G),
+	findall(String02b,(member(Filex1,G),
+	string_concat(Dept1,Filex1,Filex),
+		phrase_from_file_s(string(String00a), Filex),
+		string_codes(String02b,String00a)),Texts1)
+		),Texts2),
+
+flatten(Texts2,Texts3),
+
+term_to_atom(Texts3,Texts4),
+
+split_string(Texts4,"\n\r","\n\r",Texts5),
+
+findall([Text6,Alg],(member(Text6,Texts5),
+mr_alg(Alg)),Algs1),
+
+flatten(Algs1,Algs2),
+
+term_to_atom(Algs2,Algs3),
+
+%string_atom(Algs,Algs),
+
+	(open_s("yet_more_phil_algs.txt",write,Stream3),
+	write(Stream3,Algs3),
+	close(Stream3)),!.
+
+
+
+		

Combination-Algorithm-Writer-Multiple-Predicates/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Lucian Green
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Combination-Algorithm-Writer-Multiple-Predicates/LPCAWMP_docs.md

@@ -0,0 +1,20 @@
+# Documentation of List Prolog Interpreter CAWMP Commands
+
+* `[[n,[not,Operator]],[Variable1,Variable2]]` where `Operator=is` or `Operator="="` e.g. `[[n,[not,is]],[[v,a],1]]` returns true where `[v,a]` must be instantiated (not empty) and can equal 2.
+
+* `[[n,[not,Operator]],[Variable1,Variable2]]` where `Operator=">"`, `Operator=">="`, `Operator="<"`, `Operator="=<"` or `Operator="=\="` e.g. `[[n,[not,>]],[3,2]]` returns false.
+
+* `[[n,[not,member]],[Variable1,Variable2]]` e.g. `[[n,[not,member]],[["a","b","c"],"d"]]` returns true.
+
+* `[[n,[not,head]],[Variable1,Variable2]]` e.g. `[[n,[not,head]],[["a","b","c"],"a"]]` returns false.
+
+* `[[n,[not,tail]],[Variable1,Variable2]]` e.g. `[[n,[not,tail]],[["a","b","c"],["b","c"]]]` returns false.
+
+* `[[n,[not,append]],[Variable1,Variable2,Variable3]]` e.g. `[[n,[not,append]],[["a"],["b","c"],["a","b","c"]]]` returns false.
+
+* `[[n,[]],[Variable1]]` e.g. `[[n,[]],[[v,a]]]` returns `[v,a]=[]`.
+
+* `[[n,""],[Variable1]]` e.g. `[[n,""],[[v,a]]]` returns `[v,a]=""`.
+
+* `[[n,"_"],[Variable1]]` behaves similarly to _A in Prolog e.g. `[[n,"_"],[[v,a]]]` returns true.
+

Combination-Algorithm-Writer-Multiple-Predicates/README.md

@@ -0,0 +1,135 @@
+# Combination Algorithm Writer with Multiple Predicates
+
+* NB. This repository has been deprecated by <a href="https://github.com/luciangreen/Combination-Algorithm-Writer-Stable">Combination Algorithm Writer with Predicates Stable (CAWPS)</a>, which may return more commands per predicate, but this repository, CAWMP, has more features.
+
+Combination Algorithm Writer with Multiple Predicates (CAWMP) is a SWI-Prolog algorithm that finds algorithms from given rules,  algorithm parts (from algdict.pl) and writes algorithms with multiple predicates that satisfy the given input and output.
+
+Please contact Lucian Green at <a href="mailto:luciangreen@lucianacademy.com">luciangreen@lucianacademy.com</a> with questions, comments and feedback about CAWMP.  Please use <a href="https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates/blob/master/cawmp.bib">this citation</a> for research.
+
+# Getting Started
+
+Please read the following instructions on how to install the project on your computer for writing code.
+
+# Prerequisites
+
+Install List Prolog Interpreter Repository (https://github.com/luciangreen/listprologinterpreter) first.
+
+
+# Installation from List Prolog Package Manager (LPPM)
+
+* Optionally, you can install from LPPM by installing <a href="https://www.swi-prolog.org/build/">SWI-Prolog</a> for your machine, downloading the <a href="https://github.com/luciangreen/List-Prolog-Package-Manager">LPPM Repository</a>,
+```
+mkdir GitHub
+cd GitHub/
+git clone https://github.com/luciangreen/List-Prolog-Package-Manager.git
+cd List-Prolog-Package-Manager
+swipl
+```
+loading LPPM with `['lppm'].` then installing the package by running `lppm_install("luciangreen","Combination-Algorithm-Writer-Multiple-Predicates").`.
+
+# Installing
+
+* Download this repository.
+* In SWI-Prolog, enter:
+```
+['cawplistprolog'].
+```
+* Running
+
+* Try CAWP regression tests (in <a href="https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates/blob/master/cawpverify.pl">cawpverify.pl</a>):
+Example
+`cawptest1(off,N,S).` where N is the test number 1-8.
+Example Output
+```
+[cawptest,passed,[[[n,add0],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]]]
+```
+* Try CAWP regression tests (in <a href="https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates/blob/master/cawpverifya.pl">cawpverifya.pl</a>):
+
+Example
+`cawptest1a(off,7,S).`
+Example Output
+```
+[cawptest,7,passed]
+S = passed.
+```
+
+# Running Random Combination Algorithm Writer (RCAW)
+
+* RCAW generates random algorithms.
+
+* To load and install, follow the instructions above.
+
+# Notes on CAWMP:
+
+* Variables should be named a, b, c, and so on, without any gaps.
+* In inputted data, i.e. specifications, the above applies.
+
+
+CAWMP is called with the command:	`caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,NumInputs,NumOutputs,Specifications,AlgDict,Program1,Program2).`
+e.g. 
+```
+caw00(off,add0,[],2,1,3,[1,2],[0,1],
+%% Specs
+[[[[[[v,a],1],[[v,b],2]],[],true],
+[[[[v,a],2],[[v,b],1]],[],true]]],
+[ %% Algorithm dictionary
+        [[[n,1],1,1],[[v,a],[v,b]],":-",
+        [       [[n,+],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[[n,1],1,1],[[v,a],[v,b]],":-",
+        [       [[n,-],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]]
+],
+
+[],Program2).
+```
+It has the output:
+```
+Program2=
+[
+	[[n,1],[[v,a],[v,b]],":-",
+		[[[n,+],[[v,a],1,[v,c]]],
+		[[n,=],[[v,c],[v,b]]]]],
+	[[n,1],[[v,a],[v,b]],":-",
+		[[[n,-],[[v,a],1,[v,c]]],
+		[[n,=],[[v,c],[v,b]]]]],
+	[[n,add0],[[v,a],[v,b]],":-",
+		[[[n,1],[[v,b],[v,c]]],
+		[[n,=],[[v,a],[v,c]]]]]
+].
+```
+
+* Debug is true for trace, false for no trace.
+* Function is the inputted name of the algorithm.
+* Rules are the commands to build the code from, e.g. `[[[n,+],2,1],[[n,[]],1,0]]`, which mean the `"+"` function has 2 inputs and one output and the `[]` function has one input and verifies an empty list.  See the <a href="https://github.com/luciangreen/listprologinterpreter/blob/master/LPI_docs.md">List Prolog Interpreter Documentation</a> for more commands.
+* MaxLength is the maximum number of commands per predicate.
+* MaxPredicates is the maximum number of predicates per algorithm.
+* TotalVars is the number of different variables per predicate.
+* Specifications have the form `A=[Input_variable_list, Output_variable_list, True (if this specification in true, or false if trying to eliminate possibilities)]`, where a variable list is `[B]` where `B` is e.g. `[[v,c],[1,2]]`.  There is a list of specifications, e.g. `[A1,A2]` for a predicate (i.e. not the whole algorithm), and `[[A1,A2],[B1,B2]]` for the specifications for the algorithm, e.g. 
+```
+[[[[[[v,a],1],[[v,b],2]],[],true],
+[[[[v,a],2],[[v,b],1]],[],true]]]
+```
+* Program1 is the initial program (usually `[]`).  Planned: partial multiple predicate algorithms may be given to the algorithm to complete.
+* Program2 is the final outputted algorithm.
+* CAWMP allows shorter and shorter lists of specifications to specify algorithms as its dictionary grows.
+
+# Not tested updates
+
+Neither Prolog nor List Prolog can return non-deterministic results after point of execution passes from a clause to a child clause, so the result of testing the repository is that multiple clauses cannot be generated in this case.
+
+See the CAWPS Repository because it is all that is needed to build an algorithm bottom-up.  Without generating base cases first, neither CAWMP nor CAWPS can work, and CAWPS can generate more commands per predicate than CAWMP.
+
+# Documentation of List Prolog Interpreter CAWMP Commands
+
+See <a href="https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates/blob/master/LPCAWMP_docs.md">Documentation of List Prolog Interpreter CAWMP Commands</a>.
+
+# Authors
+
+Lucian Green - Initial programmer - <a href="https://www.lucianacademy.com/">Lucian Academy</a>
+
+# License
+
+I licensed this project under the BSD3 License - see the <a href="LICENSE">LICENSE.md</a> file for details
+

Combination-Algorithm-Writer-Multiple-Predicates/caw5 copy 12.pl

@@ -0,0 +1,1252 @@
+/**cawptest2(3,add,[[[n,[]],1,0],[[n,"_"],1,0]],4,1,4,[1,2,3],[0,1],
+[
+[[[[[v,a],[]],[[v,b],3],[[v,c],[4,5,6]]],
+	[[[v,d],[4,5,6]]],true]]
+],
+[ %% Algorithm dictionary
+],
+%% Result
+
+	[[[n,add],[[v,a],[v,b],[v,c],[v,d]],":-",[[[n,[]],[[v,a]]],[[n,"_"],[[v,a]]],[[n,"_"],[[v,b]]],[[n,=],[[v,c],[v,d]]]]]]
+
+).
+**/
+
+:- dynamic debug/1.
+:- dynamic totalvars/1.
+:- dynamic outputvars/1.
+:- dynamic newrulenumber/1.
+:- dynamic maxlength/1.
+:- dynamic lastrule/1.
+:- dynamic furthest_rule/1.
+%%:- dynamic a/1.
+
+/**
+
+caw00(off,function3,[],5,7,[[[[a,1],[b,1]],[[c,2]],true],[[[a,1],[b,1]],[[c,2]],true],[[[a,1],[b,1]],[[c,1]],fail],[[[a,1],[b,1]],[[c,1]],fail]],[],Program),writeln(Program).
+
+VarLists is in format list of [InputVarList,OutputVarList,Positivity], where these are specification lines that are either Positivity=true or fail
+
+Notes:
+- true specification line in first position of varlists, otherwise will try all except the specification line
+- manually write a,a in algdict in a,b :- a,a,b because cawp would take too long finding all combinations including a,a
+- give argument values in order 3 2 1 not 1 2 3 when adding, or will try 1+1+1 instead of 3 at first
+
+**/
+
+%%:- include('algdict.pl').
+%%:- include('remove_duplicate_predicates.pl').
+
+/**caw00a(Debug,PredicateName,Rules1,MaxLength,MaxPredicates,TotalVars,VarLists,Program1,Program2B) :-
+	(caw00(Debug,PredicateName,Rules1,MaxLength,MaxPredicates,TotalVars,VarLists,Program1,Program2B),%%writeln("If error, returned true");(furthest_rule([Number,Rules]),
+	writeln(["Error: No specification for predicate.  Programs so far:",Rules,"\n\nPredicate number:",Number]).
+**/
+
+caw000(Debug,PredicateName,Rules,MaxLength,MaxPredicates,TotalVars,NumInputs,NumOutputs,VarLists,AlgDict,Program1,Program2A) :-
+	PredicateName=[PredicateName1],
+	MaxLength=[MaxLength1],
+	MaxPredicates=[MaxPredicates1],
+	TotalVars=[TotalVars1],
+	VarLists=[VarLists1],
+	%%AlgDict=[AlgDict1],
+	Program2A=[Program2A1],
+	
+caw00(Debug,PredicateName1,Rules,MaxLength1,MaxPredicates1,TotalVars1,NumInputs,NumOutputs,VarLists1,AlgDict,Program1,Program2A1),!.
+
+caw000(Debug,PredicateName,Rules,MaxLength,MaxPredicates,TotalVars,NumInputs,NumOutputs,VarLists,AlgDict,Program1,Program2A) :-
+	PredicateName=[PredicateName1|PredicateName2],
+	MaxLength=[MaxLength1|MaxLength2],
+	MaxPredicates=[MaxPredicates1|MaxPredicates2],
+	TotalVars=[TotalVars1|TotalVars2],
+	VarLists=[VarLists1|VarLists2],
+	%%AlgDict=[AlgDict1|AlgDict2],
+	Program2A=[Program2A1|Program2A2],
+	
+caw00(Debug,PredicateName1,Rules,MaxLength1,MaxPredicates1,TotalVars1,NumInputs,NumOutputs,VarLists1,AlgDict,Program1,Program2A1),
+%%trace,
+
+findall(A,(member(B,Program2A1),findall(K,(member(F,NumInputs),member(G,NumOutputs),B=[[n,C],Q,D,E],K=[[[n,C],F,G],Q,D,E]),L),member(A,L)),J),
+append(AlgDict,J,Program2AA4),
+%%Program2AA3=[Program2AA4],
+remvdup(Program2AA4,[],Program2A3),
+%%trace,
+caw000(Debug,PredicateName2,Rules,MaxLength2,MaxPredicates2,TotalVars2,NumInputs,NumOutputs,VarLists2,Program2A3,[],Program2A2).
+
+caw00(Debug,PredicateName,Rules1,MaxLength,MaxPredicates,TotalVars,NumInputs,NumOutputs,VarLists,AlgDict,Program1,Program2B) :-
+	PredicatesA=AlgDict,
+	%% remove duplicate predicates
+	%%remvdup(PredicatesA0,[],PredicatesA),
+	split3(PredicatesA,[],Rules2),
+	split2(PredicatesA,[],Predicates),
+	%%writeln([Rules2,Predicates]),
+	append(Rules1,Rules2,Rules3),
+
+	%%retractall(a(_)),
+
+	retractall(debug(_)),
+	assertz(debug(Debug)),
+	retractall(totalvars(_)),
+   assertz(totalvars(TotalVars)),
+	retractall(maxlength(_)),
+   assertz(maxlength(MaxLength)),
+	retractall(lastrule(_)),
+   assertz(lastrule([])),
+	retractall(furthest_rule(_)),
+   assertz(furthest_rule([0,[]])),
+	%%retractall(newrulenumber(_)),
+	%%assertz(newrulenumber(0)),
+	retractall(numInputs(_)),
+   assertz(numInputs(NumInputs)),
+	retractall(numOutputs(_)),
+   assertz(numOutputs(NumOutputs)),
+
+	/**catch(call_with_time_limit(10, 
+		**/caw01(VarLists,_,Predicates,PredicateName,Rules3,MaxLength,MaxPredicates,0,_,Program1,Program2B,_)
+		
+		%%writeln1(Program2B)
+		/**),
+      time_limit_exceeded,
+      fail)
+      **/
+      .%%,not(length(Program2B,1)).
+
+%%caw01([],_,_Predicates,_PredicateName,_Rules3,_MaxLength,_MaxPredicates,_New_rule_number1,_New_rule_number2,Program,Program) :- !. %% Recently added *****	
+
+caw01([],[],_Predicates,_PredicateName,_Rules3,_MaxLength,_MaxPredicates,_New_rule_number1,_New_rule_number2,_Program1,_Program2,_) :- 
+%%writeln(here1),
+%%writeln1(["Error: No specification for predicate.  Program so far:",Program1,"\n\nPredicate number:",New_rule_number]),abort,!.
+	fail,!.
+caw01([[]],[[]],_Predicates,_PredicateName,_Rules3,_MaxLength,_MaxPredicates,_New_rule_number1,_New_rule_number2,Program,Program,_V3) :- %%writeln(here2),
+fail.	
+%%caw01(_VarLists,_Predicates,_PredicateName,_Rules3,_MaxLength,MaxPredicates,New_rule_number,Program,Program) :- New_rule_number=<MaxPredicates,!.	
+caw01(VarLists,VarLists03,Predicates,PredicateName,Rules3,MaxLength,MaxPredicates,New_rule_number1,New_rule_number2,Program1,Program2B,_V) :-
+%%writeln1(caw01(VarLists,_,Predicates,PredicateName,Rules3,MaxLength,MaxPredicates,New_rule_number1,New_rule_number2,Program1,Program2B)),
+%%(Predicates=[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add3],[[v,a],[v,b]],":-",[[[n,tail],[[v,a],[v,b]]]]]]->trace;true),
+	VarLists=[VarLists0|VarLists02],
+	VarLists0=[VarLists1|VarLists2],
+	
+	%%retractall(varlists(_)),
+	%%assertz(varlists(VarLists02)),
+
+%%trace,
+	%%writeln1(	findall(Program2A,caw0(Predicates,PredicateName,
+	%%Rules3,MaxLength,MaxPredicates,
+	%%VarLists1,VarLists02,New_rule_number1,New_rule_number2,Program1,Program2A),Program2)),
+%%notrace,
+
+	findall([Program2A,VarLists041,New_rule_number2A],caw0(Predicates,PredicateName,
+	Rules3,MaxLength,MaxPredicates,
+	VarLists1,VarLists02,VarLists041,New_rule_number1,New_rule_number2A,Program1,Program2A,_V),Program2VarLists04),
+
+findall(Program21,(member(MemberProgram2VarLists04,Program2VarLists04),MemberProgram2VarLists04=[Program21,_,_]),Program2),
+
+findall(VarLists041,(member(MemberProgram2VarLists041,Program2VarLists04),MemberProgram2VarLists041=[_,VarLists041,_]),VarLists04),
+
+findall(New_rule_number2A1,(member(MemberProgram2VarLists041New_rule_number2A1,Program2VarLists04),MemberProgram2VarLists041New_rule_number2A1=[_,_,New_rule_number2A1]),New_rule_number2A2),
+
+%%trace,
+
+	%%writeln1(	findall(Program2A,caw0(Predicates,PredicateName,
+	%%Rules3,MaxLength,MaxPredicates,
+	%%VarLists1,VarLists02,New_rule_number1,New_rule_number2,Program1,Program2A),Program2)),
+	%%notrace,
+	length(Program2,Program2L),
+	length(Program2LList,Program2L),
+	append(Program2LList,_,[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100]),
+	
+	member(Program2LListItem,Program2LList),
+	get_item_n(Program2,Program2LListItem,Program2B),
+	get_item_n(VarLists04,Program2LListItem,VarLists03),
+	get_item_n(New_rule_number2A2,Program2LListItem,New_rule_number2),
+	%%member(Program2B,Program2), %e->1
+	%%member(VarLists03,VarLists04), %e->1
+%%writeln1(Program2B1),
+%%writeln1(Program2B),
+	%%Program2B1=[Program2B],
+	
+	%%trace,
+
+	%%writeln1(member(Program2B,Program2)),
+	%%notrace,
+
+	
+	aggregate_all(count,(member(Item,VarLists2),
+	caw0(Predicates,PredicateName,Rules3,MaxLength,MaxPredicates,
+	Item,VarLists03,_VarLists031,New_rule_number1,_New_rule_number2A3,Program1,Program2B,_V2)),Count1),
+	
+	%%trace,
+
+	%%writeln1(	aggregate_all(count,(member(Item,VarLists2),
+	%%caw0(Predicates,PredicateName,Rules3,MaxLength,MaxPredicates,
+	%%Item,VarLists02,New_rule_number,Program1,Program2B)),Count)),
+%%notrace,
+%%writeln1(Program2),
+%%trace,
+
+%%writeln1(length(VarLists2,Count)),
+%%notrace,
+
+   %%(findall(EVM1,(everyvarmentioned(Vars2,Program5),
+
+length(VarLists2,Count2),
+Count1>=Count2,
+
+%%(Program2B=[[[n,1],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]]->true%%trace
+%%;true),
+!.%%!.%%!. %%Predicates->PredicatesA x
+
+get_item_n(List1,N1,Item) :-
+	N2 is N1-1,
+	length(List3,N2),
+	append(List3,List4,List1),
+	List4=[Item|_].
+ caw0(Algorithms,PredicateName,Rules,MaxLength,MaxPredicates,VarLists,VarLists02,VarLists03,New_rule_number1,New_rule_number2,Program1,Program2,_V3) :-
+	VarLists=[InputVarList,OutputVarList,Positivity],
+	varnames(InputVarList,[],InputVars,[],InputValues),
+	varnames(OutputVarList,[],OutputVars,[],_OutputValues),
+	%%retractall(outputvars(_)),
+   %%assertz(outputvars(OutputVars)),
+	append(InputVars,OutputVars,Vars11),
+%%Vars11=InputVars,
+%%Vars12=InputVars,
+	append(InputValues,OutputVars,Vars2),
+	%%append(InputValues,OutputValues,Values),
+	Query=[[n,PredicateName],Vars2],
+	%%writeln(	caw(Algorithms,Query,PredicateName,Rules,MaxLength,MaxPredicates,Vars11,InputVars,InputVars,_,OutputVarList,OutputVars,Positivity,VarLists02,New_rule_number1,New_rule_number2,Program1,Program2)),
+	caw(Algorithms,Query,PredicateName,Rules,MaxLength,MaxPredicates,Vars11,InputVars,InputVars,_,OutputVarList,OutputVars,Positivity,VarLists02,VarLists03,New_rule_number1,New_rule_number2,Program1,Program2,_V).
+%%caw(_,_,_,_,_,N,_,_,_,_,_,_,_,_,_,_,N,P,P) :- fail,!. %% Turn off fail,! to have all solutions
+	/**caw(_Algorithms,_Query,_PredicateName,_Rules,_MaxLength,MaxPredicates,_Vars11,_InputVars,_InputVarsa,_InputVars2,_OutputVarList,_OutputVars,_Positivity,_VarLists02,New_rule_number1,New_rule_number2,_Program1,_Program11):-
+	%%writeln(caw_here(Algorithms,Query,PredicateName,Rules,MaxLength,MaxPredicates,Vars11,InputVars,InputVars,InputVars2,OutputVarList,OutputVars,Positivity,VarLists02,New_rule_number1,New_rule_number2,Program1,Program1)),
+	%%MaxPredicates1 is MaxPredicates-1,
+	writeln(["New_rule_number>MaxPredicates1",New_rule_number,">",MaxPredicates]),
+	New_rule_number>MaxPredicates,
+	fail,!.
+**/
+%%caw(_,_,_,_,_,_N,_,_,_,_,_,_,_,_,[],_,_N2?,P,P) :- !.
+caw(_,_,_,_,0,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_F) :- fail, !. %% Turn off fail,! to have all solutions
+caw(Algorithms1,Query,PredicateName,_Rules,_MaxLength,MaxPredicates,_VarList,InputVars1,InputVars2,_InputVarsa,VarLists,OutputVars,Positivity,VarLists02,VarLists02,New_rule_number1,New_rule_number1,Program1,Program2,_V) :-
+%%writeln1(V),
+
+	%%MaxLength>0, ***
+	
+%%MaxPredicates1 is MaxPredicates,
+New_rule_number1=<MaxPredicates,
+	
+	%%trace,
+	addrules(InputVars2,OutputVars,OutputVars,[],_PenultimateVars,[],Program3),%%notrace,
+	
+%%writeln([addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3)]),	
+	%%optimise(Program1,InputVars1,_InputVars3,PenultimateVars,Program4), %% IV2->3
+%%writeln([optimise(Program1,InputVars1,InputVars3,PenultimateVars,Program4)]),
+	append(Program1,Program3,Program5),
+	not(Program5=[]),
+	
+	append(InputVars1,OutputVars,Vars2),
+	Program22=[
+        [[n,PredicateName],Vars2,":-",
+                Program5
+        ]
+        ],
+	%%writeln1(interpret-short(Program22)),
+   
+   %%everyvarmentioned(Vars2,Program5),
+   %%((PredicateName=1;PredicateName=2)->trace;true),
+   /**
+   not(Program22=[
+        [[n,add],_,_,
+                [[[n,+],_]|_]
+        ]
+        ]),
+	**/
+	%%(Program22=[[[n,1],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]],trace),
+        
+	eliminate_unused_predicates(Program22,Algorithms1,Algorithms2),
+	%%writeln(eliminate_unused_predicates(Program22,Algorithms1,Algorithms2)),
+	
+	%%Algorithms2=[[[n,_],_,_,Body]|_],length(Body,1),
+	%%(Program22=[[[n,function0],[[v,a],[v,b],[v,c]],":-",[[[n,function2],[[v,a],[v,b],[v,d]]],[[n,=],[[v,c],[v,d]]]]]]->writeln(eliminate_unused_predicates(Program22,Algorithms1,Algorithms2));true),
+	
+	%%trace,
+	%%writeln(["1*",append(Algorithms2,Program22,Program2)]), %% ***** swapped a2,p22
+	%%[Program23]=Program22,
+	%%not(member(Program23,Algorithms2)),
+	append(Algorithms2,Program22,Program2), %% ***** swapped a2,p22
+	%%remvdup(Program2a,[],Program2),
+	%%Algorithms2=Program2,
+	
+	
+	%%not(Program2=[[[n,add0],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]]),
+%%(Program2=[[[n,1],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]]->trace;true),
+
+	%%length(Program2,Program2L),not(Program2L=1),
+	%%not(New_rule_number=1),
+	%%=<MaxPredicates,
+%%([off,[[n,add0],[[1,2,3],[v,b]]],[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,add2],[[v,a],[v,d]]],[[n,=],[[v,d],[v,b]]]]]],[[[[v,b],[]]]]]=[Debug,Query,Program2,[VarLists]]->trace;true),
+
+	%%append_last_rule(Program2),
+
+	/**
+	length(Program2,Program2L),(Program2L>=2->(%%writeln(here2),trace
+	true);true),
+	**/
+	debug(Debug),
+	
+	%%([off,[[n,add0],[[1,2,3],[v,b]]],[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,add0],[[v,a],[v,d]]],[[n,=],[[v,d],[v,b]]]]]],[[[[v,b],[]]]]]=[Debug,Query,Program2,[VarLists]]->%%true
+	%%trace
+	%%;true),
+
+%%([off,[[n,function3],[1,1,[v,c]]],[[[n,function1],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,c]]]]],[[n,function3],[[v,a],[v,b],[v,c]],":-",[[[n,function1],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]],[[[[v,c],2]]]]=[Debug,Query,Program2,[VarLists]]->true
+	%%trace
+	%%;true),
+
+%%writeln1([V,"\n",Program2]),
+%%writeln1(V),
+%%writeln1([program2,Program2]),
+%%writeln1([v,V]),
+
+%% add 0s
+%%(var(V)->true;(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add3],[[v,a],[v,c]]],[[n,add0],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]],V)->writeln1("v yes");true)),
+%%**()(V=[[[n,add3],[[v,a],[v,b]],":-",[[[n,tail],[[v,a],[v,b]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add3],[[v,a],[v,c]]],[[n,add0],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]]]->writeln1("v yes");true),
+
+%%(var(Program2)->true;(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]],Program2)->writeln1("p yes");true)),
+%%**()(Program2=[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]]]->writeln1("p yes");true),
+
+%%vyes(Program2),
+
+%%(((var(V)->true;(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add3],[[v,a],[v,c]]],[[n,add0],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]],V))),(var(Program2)->true;(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]],Program2))))->trace;true),
+
+%%**()((not(var(V)),V=[[[n,add3],[[v,a],[v,b]],":-",[[[n,tail],[[v,a],[v,b]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add3],[[v,a],[v,c]]],[[n,add0],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]]],
+%%Program2=[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]]])->trace;true),
+	%%trace;
+	%%true),
+
+	%%writeln([program2,Program2]),
+	%%(length(Program5,4)->writeln([program2,Program2])),
+	%%(Program2=[[[n,add0],[[v,a],[v,b],[v,c],[v,d],[v,e]],":-",[[[n,+],[[v,a],[v,b],[v,f]]],[[n,+],[[v,c],[v,f],[v,g]]],[[n,+],[[v,d],[v,g],[v,h]]],[[n,=],[[v,h],[v,e]]]]]]->trace;true),
+	%%writeln(["Press c."]),(get_single_char(97)->true;true),
+	
+	 %%writeln1([interpret(Debug,Query,Program2,OutputVarList)]),
+	
+ %writeln1(interpret(Debug,Query,Program2,VarLists)),
+	
+	
+%%([Debug,Query,Program2,[VarLists]]=[off,[[n,add],[[],[1,2],[v,d]]],[[[n,add],[[v,a],[v,c],[v,d]],":-",[[[n,[]],[[v,a]]],[[n,=],[[v,c],[v,d]]]]]],[[[[v,d],[1,2]]]]]->trace;true),
+
+%%([Debug,Query,Program2,[VarLists]]=[off,[[n,add0],[[1,2,3],[v,b]]],[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,add2],[[v,a],[v,d]]],[[n,=],[[v,d],[v,b]]]]]],[[[[v,b],[]]]]]->trace;true),
+
+%%(Program2=[[[n,add2],[[v,a],[v,b]],":-",[[[n,=],[[v,a],[]]],[[n,=],[[v,b],[]]]]],[[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,add2],[[v,a],[v,d]]],[[n,=],[[v,d],[v,b]]]]]]->trace;true),
+	%%interpret(Debug,Query,Program2,OutputVarList).
+	%%aggregate_all(count,(member(Item,VarLists),
+	%%varlists(VarLists02),
+	%%(
+	
+	%%notrace,
+	try_interpret(Positivity,Debug,Query,Program2,VarLists),%%trace,%%writeln(here),
+	%%trace,
+		%%trace,
+	add_furthest_rule1(New_rule_number1,Program2),
+	%%(Program2=[[[n,add],[[v,a],[v,b],[v,c],[v,d]],":-",[[[n,=],[[v,c],[v,d]]]]]]->true%%trace
+	%%;true),
+	%%trace,
+	(no_singletons(Vars2,Program5)),
+	
+	%%writeln1(Program2),	
+	%%writeln1([cawptest,passed,Program2]),abort,
+	%%->true;(%%notrace,fail)),
+ %%writeln1(interpret(Debug,Query,Program2,[VarLists])),
+
+%%(furthest_rule(A)->writeln(furthest_rule(A));true),%%notrace,
+	%%!.
+	!.%%!.
+	%%-> %% *** [VarLists] ?
+	/**(VarLists03=VarLists02,
+	%%retractall(varlists(_)),
+	%%assertz(varlists(VarLists03)),
+	Program2c=Program2);%%fail%%
+	(Program2c=[],VarLists03=VarLists02,%%append(VarLists,VarLists02,VarLists03),
+	retractall(varlists(_)),
+	assertz(varlists(VarLists03)),fail
+	)
+	),!.%%),Count), **** [VarLists02] to VarLists02
+	%%length(OutputVarList,Count),!.
+	**/
+	/**
+	
+	vyes(P):-%%((not(var(V)),
+	(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add3],[[v,a],[v,c]]],[[n,add0],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]],P),writeln("pyes*****")).%%,(var(Program2)->true;(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]],Program2)))).
+	vyes(V):-%%((not(var(V)),
+	(member([[n,add0],[[v,a],[v,b]],":-",[[[n,add2],[[v,a],[v,c]]],[[n,=],[[v,c],[v,b]]]]],V)),writeln("vyes*****")%%,(var(Program2)->true;(member([],Program2)))).
+.
+	vyes(V):-
+true.
+**/
+caw(Algorithms,Query,PredicateName,Rules,MaxLength,MaxPredicates,VarList,InputVars1,InputVars2,InputVars3,VarLists,OutputVars,Positivity,VarLists02,VarLists03,New_rule_number1,New_rule_number2,Program1,Program4,_V) :-
+%%writeln(here4),
+%%trace,
+
+%%writeln1(caw(Algorithms,Query,PredicateName,Rules,MaxLength,MaxPredicates,VarList,InputVars1,InputVars2,InputVars3,VarLists,OutputVars,Positivity,VarLists02,New_rule_number1,New_rule_number2,Program1,Program4)),
+%%trace,
+%%writeln([caw(Query,PredicateName,Rules,MaxLength,MaxPredicates,VarList,InputVars1,InputVars2,OutputVarList,OutputVars,Program1,Program4)]),?
+	MaxLength>=0, %%***
+	MaxLength2 is MaxLength - 1,
+	%%reverse(InputVars2,InputVars5),
+
+%%writeln([new_rule_number,New_rule_number,maxPredicates,MaxPredicates]),
+%%writeln(limit_reached(New_rule_number,MaxPredicates,Rules,PredicateName,InputVars1,OutputVars,Rules1)),
+%%trace,
+limit_reached(New_rule_number1,MaxPredicates,Rules,PredicateName,InputVars1,OutputVars,Rules1), %% *** Check these
+%%writeln([rules1,Rules1]),
+	%%repeat,
+	%%writeln(limit_reached(New_rule_number,MaxPredicates,Rules,PredicateName,InputVars1,OutputVars,Rules1)),
+%%get_char(_),
+	%%trace,
+	
+	
+	member([RuleName0,NumInputs0,NumOutputs0],Rules1),
+	
+	%%[RuleName0,NumInputs0,NumOutputs0]=[other_new_branch,_,_],
+	
+%%	**/
+	%%RuleName0=newrule123,
+%%writeln([member([RuleName,NumInputs,NumOutputs],Rules)]),
+%%writeln([rule(RuleName,NumInputs,NumOutputs,VarList,VarList2,Rule)]),
+	
+	
+	%%retractall(newrulenumber(_)),
+	%%assertz(newrulenumber(Newrulenumber1)),
+
+	%%[InputVars2,VarLists,Positivity]=[VarLists0311,VarLists0312,_VarLists0313], ***
+	%% **** InputVars1 or InputVars2?
+	%%length(VarLists0311,VarLists0311L),
+	%%length(VarLists0312,VarLists0312L),
+	
+	%%***newbranchifcall(RuleName0,PredicateName,Itema),
+	numInputs(NumInputs1a),numOutputs(NumOutputs1a),
+	member(NumInputs1,NumInputs1a),%%[1,2,3]),%%,0,2,3]),	 %%*** 4	
+	member(NumOutputs1,NumOutputs1a),%%[0,1]),%%,0,2,3]), %%***  4
+	
+	%%writeln([i,o,NumInputs1,NumOutputs1]),
+	%%*** caw x when creates a new pred, num extra clauses 0-2, doesn't add rule to pred, returns vl03 for (rules in) this pred
+	caw3(RuleName0,Algorithms,Algorithms2,NumInputs0,NumOutputs0,New_rule_number1,New_rule_number3,Rules,PredicateName,Program1,VarList,VarList2,InputVars2,InputVars4,OutputVars,Rule,NumInputs1,NumOutputs1,VarLists02,VarLists04,MaxPredicates,Rules2),
+	
+	
+%%->true
+%%;
+ %% InputVars5->InputVars2
+%%writeln([rule(RuleName,NumInputs,NumOutputs,InputVars1,InputVars3,VarList,VarList2,Rule)]),
+	%%writeln(not(member(Rule,Program1))),
+	not(member(Rule,Program1)), %% Need to stop repeats of arity 1 calls
+	append(Program1,[Rule],Program3),
+%%writeln([inputVars3,InputVars3]),
+%%InputVars2=InputVars3,
+%%writeln([program4,Program4]),
+	
+	%%retractall(varlists(_)),
+	%%assertz(varlists(VarLists02)),
+	%%writeln1(	caw(Algorithms2,Query,PredicateName,Rules2,MaxLength2,MaxPredicates,VarList2,InputVars1,InputVars4,InputVars3,VarLists,OutputVars,Positivity,VarLists02,New_rule_number3,New_rule_number2,Program3,Program4)),
+	caw(Algorithms2,Query,PredicateName,Rules2,MaxLength2,MaxPredicates,VarList2,InputVars1,InputVars4,InputVars3,VarLists,OutputVars,Positivity,VarLists04,VarLists03,New_rule_number3,New_rule_number2,Program3,Program4,_Algorithms2).
+
+caw3(RuleName0,Algorithms,Algorithms2,NumInputs0,NumOutputs0,New_rule_number,New_rule_number1,Rules,PredicateName,Program1,VarList,VarList2,InputVars2,InputVars4,OutputVars,Rule,_NumInputs1,_NumOutputs1,VarLists02,VarLists02,_MaxPredicates,Rules2) :-
+	
+	%% rules_existing
+	not(RuleName0=predicatename_new_branch),not(RuleName0=other_new_branch),not(RuleName0=[rules_new_branch,_]),
+	not(RuleName0=predicatename_existing),
+		%%trace,
+		find_rule_name(RuleName0,RuleName2),
+	Algorithms2=Algorithms,%%RuleName=RuleName0,
+NumInputs=NumInputs0,NumOutputs=NumOutputs0,New_rule_number1 = New_rule_number,Rules2=Rules,
+
+rulename_if_limit(RuleName2,PredicateName,RuleName),
+	rule(Program1,RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,OutputVars,Rule).
+	
+	
+caw3(RuleName0,Algorithms,Algorithms2,NumInputs0,NumOutputs0,New_rule_number,New_rule_number1,Rules,PredicateName,Program1,VarList,VarList2,InputVars2,InputVars4,OutputVars,Rule,NumInputs1,NumOutputs1,VarLists02,VarLists03,MaxPredicates,Rules2) :-
+
+%%Number_of_clauses2=1, %% Not tested nonrecursive multiclauses - use bottom up
+member(Number_of_clauses1,[1]),%%,3,4]),
+(Number_of_clauses1>=MaxPredicates->Number_of_clauses2=MaxPredicates;Number_of_clauses2=Number_of_clauses1),
+
+create_multiple_nonrecursive_clauses(Number_of_clauses2,RuleName0,Algorithms,Algorithms2,NumInputs0,NumOutputs0,New_rule_number,New_rule_number1,Rules,PredicateName,Program1,VarList,VarList2,InputVars2,InputVars4,OutputVars,Rule,NumInputs1,NumOutputs1,VarLists02,VarLists03,MaxPredicates,Rules2).
+
+
+
+create_multiple_nonrecursive_clauses(0,_RuleName0,Algorithms,Algorithms,_NumInputs0,_NumOutputs0,New_rule_number,New_rule_number,Rules,_PredicateName,_Program1,VarList,VarList,InputVars,InputVars,_OutputVars,_Rule,	_NumInputs1,_NumOutputs1,VarLists02,VarLists02,_MaxPredicates,Rules) :- 
+!.
+
+create_multiple_nonrecursive_clauses(Number_of_clauses1,RuleName0,Algorithms,Algorithms2,NumInputs0,NumOutputs0,New_rule_number1,New_rule_number3,Rules,PredicateName,Program1,VarList,VarList2,InputVars2,InputVars4,OutputVars,Rule,NumInputs1,NumOutputs1,VarLists02,VarLists03,MaxPredicates,Rules2) :-
+
+
+caw4a(RuleName0,New_rule_number1,Rules,PredicateName,NumInputs0,NumOutputs0,NumInputs1,NumOutputs1,Rules3,New_rule_number4,RuleName),
+%%writeln(before4b),
+%%trace,
+caw4b(VarLists02,VarLists04,Algorithms,New_rule_number5,MaxPredicates,New_rule_number4,Program1,RuleName,NumInputs1,NumOutputs1,InputVars2,InputVars5,VarList,VarList3,OutputVars,Rule,Algorithms3,Rules3),
+%%trace,
+
+Number_of_clauses2 is Number_of_clauses1-1,
+create_multiple_nonrecursive_clauses(Number_of_clauses2,RuleName0,Algorithms3,Algorithms2,NumInputs0,NumOutputs0,New_rule_number5,New_rule_number3,Rules3,PredicateName,Program1,VarList3,VarList2,InputVars5,InputVars4,OutputVars,Rule,NumInputs1,NumOutputs1,VarLists04,VarLists03,MaxPredicates,Rules2).
+
+
+
+caw4a(RuleName0,New_rule_number,Rules,_PredicateName,_NumInputs0,_NumOutputs0,NumInputs1,NumOutputs1,Rules2,New_rule_number1,RuleName) :-
+
+	RuleName0=other_new_branch, %% Command from Rules with new branch
+
+%%trace,
+	New_rule_number1 is New_rule_number+1,
+%%not(New_rule_number1=2), 
+
+RuleName=[n,New_rule_number1],
+
+	append(Rules,[[RuleName,NumInputs1,NumOutputs1]],Rules2)
+.
+
+caw4a(RuleName0,New_rule_number,Rules,PredicateName,NumInputs0,NumOutputs0,_NumInputs1,_NumOutputs1,Rules2,New_rule_number1,RuleName) :-
+	RuleName0=predicatename_new_branch, %% New branch with same name as current predicate
+RuleName=[n,PredicateName],
+	New_rule_number1 is New_rule_number+1,
+		append(Rules,[[RuleName,NumInputs0,NumOutputs0]],Rules2)
+
+.
+
+caw4a(RuleName0,New_rule_number,Rules,_PredicateName,NumInputs0,NumOutputs0,_NumInputs1,_NumOutputs1,Rules2,New_rule_number1,RuleName) :-
+	RuleName0=[rules_new_branch,RuleName], %% New branch with same name as current predicate
+%%trace,
+%%RuleName=[n,RuleName1],
+	New_rule_number1 is New_rule_number+1,
+		append(Rules,[[RuleName,NumInputs0,NumOutputs0]],Rules2)
+.
+
+caw4a(RuleName0,New_rule_number,Rules,PredicateName,NumInputs0,NumOutputs0,_NumInputs1,_NumOutputs1,Rules2,New_rule_number1,RuleName) :-
+	RuleName0=predicatename_existing,
+		%%trace,
+		find_rule_name(RuleName0,RuleName2),
+	%%Algorithms2=Algorithms,
+	%%RuleName=RuleName0, *** not this
+%%NumInputs1=NumInputs0,NumOutputs1=NumOutputs0,%% n i,o epsilon to 1
+New_rule_number1 = New_rule_number,%%Rules2=Rules,
+
+rulename_if_limit(RuleName2,PredicateName,RuleName),
+		append(Rules,[[RuleName,NumInputs0,NumOutputs0]],Rules2)
+.
+	%%rule(Program1,RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,OutputVars,Rule).
+
+
+caw4b(VarLists02,VarLists03,Algorithms,New_rule_number2,MaxPredicates,New_rule_number1,Program1,RuleName,NumInputs1,NumOutputs1,InputVars2,InputVars4,VarList,VarList2,OutputVars,Rule,Algorithms2,Rules2) :-
+	%%writeln1(append(Rules,[[RuleName,NumInputs0,NumOutputs0]],Rules2)),
+	%%MaxPredicates2 is MaxPredicates-1,
+	
+	maxlength(MaxLength3),
+	
+%%writeln(    caw01(VarLists02,Algorithms,New_rule_number1,New_rule_number2,Rules2,MaxLength3,MaxPredicates,New_rule_number1,[],Program2)),
+    %%writeln(here3),
+    %%trace,
+    %%writeln(    RuleName=[_,RuleName1]),
+    RuleName=[_,RuleName1],
+caw01(VarLists02,VarLists03,Algorithms,%%New_rule_number1
+    RuleName1
+,Rules2,MaxLength3,MaxPredicates,New_rule_number1,New_rule_number2,[],Program2,_Program12), %% *** VarLists02     
+    %%writeln(here4),
+%%to [VarLists02]
+%%Program2=[[[[n,1],[[v,a],[v,b],[v,c]],":-",[[[n,+],[[v,a],[v,b],[v,d]]],[[n,=],[[v,d],[v,c]]]]]]],
+%%writeln([caw01,Program2]),
+%%trace,
+rule(Program1,RuleName,NumInputs1,NumOutputs1,InputVars2,InputVars4,VarList,VarList2,OutputVars,Rule),
+%%trace,
+	%%writeln(["2*",append(Program2,Algorithms,Algorithms2)]), %% *** swapped a,p2
+	%%[Program2a]=Program2,
+	%%not(member(Program2a,Algorithms)),
+	%append(Program2,Algorithms,Algorithms2) %% *** swapped a,p2
+	Program2=Algorithms2
+	.
+	
+find_rule_name(RuleName0,RuleName2) :-
+	RuleName0=[_,RuleName1],RuleName2=RuleName1.
+find_rule_name(RuleName0,RuleName2) :-
+	not(RuleName0=[_,_RuleName1]),RuleName2=RuleName0.
+
+try_interpret(Positivity,Debug,Query,Program2,VarLists) :-
+	Positivity=true,catch(call_with_time_limit(0.05, 
+		international_interpret([lang,"en"],Debug,Query,Program2,[VarLists])),
+      time_limit_exceeded,
+      fail),!.
+      
+try_interpret(Positivity,Debug,Query,Program2,VarLists) :-
+	not(Positivity=true),catch(call_with_time_limit(0.05, 
+		not(international_interpret([lang,"en"],Debug,Query,Program2,[VarLists]))),
+      time_limit_exceeded,
+      fail),!.
+
+append_last_rule(Program2):-
+	lastrule(LastRule1),
+	append_last_rule1(Program2,LastRule1).
+	
+%%append_last_rule1(_Program2,LastRule1) :-
+%%	LastRule1=[],!.
+append_last_rule1(Program2,LastRule1) :-
+%%	not(LastRule1=[]),
+	not(member(Program2,LastRule1)),
+	append(LastRule1,[Program2],LastRule2),
+	retractall(lastrule(_)),
+   assertz(lastrule(LastRule2)).
+
+add_furthest_rule1(New_rule_number,Program1) :-
+	furthest_rule(Rule),Rule=[Number,Rules],
+	add_furthest_rule2(New_rule_number,Number,Rules,Program1).
+/**add_furthest_rule2(New_rule_number,Number,_Rules,Program1) :-
+	New_rule_number>Number,
+	retractall(furthest_rule(_)),
+   assertz(furthest_rule([New_rule_number,[Program1]])),!.
+   **/
+add_furthest_rule2(New_rule_number,_Number,Rules,Program1) :-
+%%trace,
+	%%New_rule_number=Number,
+	retractall(furthest_rule(_)),
+	delete(Rules,Program1,Rules1),
+	append(Rules1,[Program1],Rules2),
+   assertz(furthest_rule([New_rule_number,Rules2])).
+/**add_furthest_rule2(New_rule_number,Number,_Rules,_Program1) :-
+	New_rule_number<Number,!.
+**/
+rulename_if_limit(RuleName0,PredicateName,RuleName) :-
+	RuleName0=predicatename_existing,RuleName=[n,PredicateName],!.
+rulename_if_limit(RuleName0,_PredicateName,RuleName) :-
+	not(RuleName0=predicatename_existing),RuleName=RuleName0.
+
+/**
+everyvarmentioned(Vars1,Program) :-
+	everyvarmentioned1(Vars1,Program).
+	%%underscore_occurs_once_per_var(Vars1,Program).
+
+everyvarmentioned1([],_Program) :- !.
+everyvarmentioned1(Vars1,Program) :-
+	Vars1=[Vars2|Vars3],
+	
+	findall(Vars2,(member(C,Program),(
+	%%(C=[[n,"_"],[[v,b]]]->(true);true),
+	C=[_E,D],
+	member(Vars2,D)
+	
+
+	%%Vars2=true
+	)),B),not(B=[]),
+	everyvarmentioned1(Vars3,Program).
+**/
+
+no_singletons(Vars1,Program):-
+	findall(DA,(member(C,Program),C=[_E,D],member(DA,D)),Vars2),
+	%%append_list(Vars2,Vars2A),
+	append(Vars1,Vars2,Vars3),
+	findall(Count1,(member(Item,Vars3),aggregate_all(count,(member(Item,Vars3)),Count1),
+	Count1=1),G),G=[].
+
+
+
+/**
+underscore_occurs_once_per_var([],_,_Program) :- !.
+underscore_occurs_once_per_var(Vars1,Program) :-
+	
+	findall(Var,(aggregate_all(count,(member(Var,Vars1),
+	member(C,Program),C=[[n,"_"],[Var]]),Count),Count=<1),List),
+	not(List=[]).
+**/
+
+limit_reached(New_rule_number,MaxPredicates,Rules0,PredicateName,InputVars1,OutputVars,Rules1) :-
+	New_rule_number<MaxPredicates,
+	length(InputVars1,InputVars1L),
+	length(OutputVars,OutputVarsL),
+	pred_already_in_list1(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules),
+	
+append(Rules,[[predicatename_new_branch,InputVars1L,OutputVarsL], %% Uncommented for test 7, commented for test 7
+[other_new_branch,_,_] %% commented for test 7
+],Rules1),!.
+limit_reached(New_rule_number,MaxPredicates,Rules0,PredicateName,InputVars1,OutputVars,Rules1) :-
+	New_rule_number>=MaxPredicates,
+	length(InputVars1,InputVars1L),
+	length(OutputVars,OutputVarsL),
+	pred_already_in_list1(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules1).
+
+	pred_already_in_list1(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules) :-
+	pred_already_in_list2(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules).
+	
+		pred_already_in_list2(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules) :-
+	member([[n,PredicateName],InputVars1L,OutputVarsL],Rules0),
+		apply_rules_existing_and_new_branch(Rules0,Rules),!.
+			pred_already_in_list2(PredicateName,InputVars1L,OutputVarsL,Rules0,Rules) :-
+	not(member([[n,PredicateName],InputVars1L,OutputVarsL],Rules0)),
+	apply_rules_existing_and_new_branch(Rules0,Rules01),
+	append(Rules01,[[predicatename_existing,InputVars1L,OutputVarsL]  %% Uncommented for test 7
+	],Rules).
+
+apply_rules_existing_and_new_branch(Rules1,Rules2) :-
+apply_rules_existing_and_new_branch2(Rules1,Rules3),
+apply_rules_existing_and_new_branch3(Rules1,Rules4),
+append(Rules3,Rules4,Rules2).
+
+apply_rules_existing_and_new_branch2(Rules1,Rules2) :-
+	findall([A,C1,C2],(member(B,Rules1),B=[A1,C1,C2],member(D,[rules_existing
+	]),A=[D,A1]),Rules2).
+	
+apply_rules_existing_and_new_branch3(Rules1,Rules2) :-
+	findall([A,C1,C2],(member(B,Rules1),B=[A1,C1,C2],member(D,[%%rules_new_branch
+	]),A=[D,A1]),Rules2).
+	
+%%append(Rules,[[predicatename_existing,InputVars1L,OutputVarsL]%%%%,[other_existing,_,_]
+%%],Rules1),!.
+
+/**
+newbranchifcall(RuleName0,PredicateName,Itema):-
+		RuleName0=[n,PredicateName],member(Itema,[useexisting,newbranch]).
+newbranchifcall(RuleName0,PredicateName,Itema):-
+		not(RuleName0=[n,PredicateName]),Itema=useexisting.
+**/
+
+varnames([],Vars,Vars,Values,Values) :- !.
+varnames(VarList,Vars1,Vars2,Values1,Values2) :-
+	VarList=[Var|Vars3],
+	Var=[VarName,Value],
+	append(Vars1,[VarName],Vars4),
+	append(Values1,[Value],Values3),
+	varnames(Vars3,Vars4,Vars2,Values3,Values2),!.
+
+/**
+%%addrules(_,_,[],PV,PV,Program,Program) :- !.
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program3) :-
+writeln1(addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program3)),
+%%trace,
+	OutputVars2=[],%%[OutputVar|OutputVars3],
+	member(Var,VarList),
+	%%member(OutputVar,OutputVars1),%%()
+	append(VarList,OutputVars1,OutputVars4),
+	member(Var2,OutputVars4),
+	append(Program1,[[[n,=],[Var,Var2%%OutputVar
+	]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars2).
+	
+	**/
+	/**
+	%%addrules(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2).
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+%%trace,
+	OutputVars2=[OutputVar|OutputVars3],
+	member(Var,VarList),
+	member(OutputVar,OutputVars1),%%()
+	append(VarList,OutputVars1,OutputVars4),
+	member(Var2,OutputVars4),
+	append(Program1,[[[n,=],[Var,Var2%%OutputVar
+	]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars3),
+	addrules(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2).
+**/
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+find_addrules_outputvars(OutputVars1,OutputVars3),
+	addrules1(OutputVars3,VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2).%%;(
+	
+addrules1([],_VarList,_OutputVars1,_OutputVars2,PenultimateVars,PenultimateVars,Program,Program) :- !.
+addrules1(OutputVars3,VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+OutputVars3=[_OutputVars31|OutputVars32],
+addrules2(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars3,Program1,Program3),
+addrules1(OutputVars32,VarList,OutputVars1,OutputVars2,PenultimateVars3,PenultimateVars2,Program3,Program2).
+
+addrules2([],_,_,PV,PV,Program,Program) :- !.
+addrules2([[v,_]],_,_,PV,PV,Program,Program) :- !.
+addrules2(VarList,OutputVars1,_OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program3) :- %%*** Underscored OutputVars2
+%%writeln1(addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program3)),
+%%trace,
+	%%OutputVars2=[],%%[OutputVar|OutputVars3],
+	member(Var,VarList),
+	%%member(OutputVar,OutputVars1),%%()
+	append(VarList,OutputVars1,OutputVars4),
+	member(Var2,OutputVars4),
+	not(Var=Var2),
+	append(Program1,[[[n,=],[Var,Var2%%OutputVar
+	]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars2).
+
+find_addrules_outputvars(OutputVars1,OutputVars3) :-
+	OutputVars1=[],OutputVars3=[_],!.
+find_addrules_outputvars(OutputVars1,OutputVars3) :-
+	not(OutputVars1=[]),OutputVars3=OutputVars1.
+%% optimise([[append,[a,a,d]],[append,[a,a,e]],[append,[a,a,f]],[append,[a,b,g]]],[g],P).
+/****
+optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program2) :-
+	findrulesflowingtopv1(Program1,InputVars1,InputVars2,PenultimateVars,[],Rules,true),
+	%%findrulesflowingtopv1a(Program1,_Program32,InputVars1,InputVars2,PenultimateVars,[],_Rules1),
+	intersection(Program1,Rules,Program3),
+	unique1(Program3,[],Program2).
+findrulesflowingtopv1(_,_,_,[],Rules,Rules,false).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	(Var=[v,_]),%%***;length(Var,1)),
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars1,Rules1,Rules2,IV1Flag1) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2), 
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars2,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv20(_,[],_InputVars1,_InputVars2,_Var,Rules,Rules,false).
+findrulesflowingtopv20(Program0,Rules4,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rules4=[Rule|Rules],
+	(findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2)->true;(Rules3=Rules1,IV1Flag2=false)),
+	%%delete(Program0,Rule,Program1),
+	findrulesflowingtopv20(Program0,Rules,InputVars1,InputVars2,Var,Rules3,Rules2,IV1Flag3),%%p1->0
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+%%findrulesflowingtopv2(_,[],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[[n,_PredicateName],Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	%%(not(intersection(Rulesx,Rules1))-> x
+	%% append, append, unique1
+	%%append(Rules1,[Rule],Rules3);Rules3=Rules1),
+
+	%%member(Var2,Rest),
+	%%member(Var2,InputVars1),
+
+	length(Rest,Length1), Length1>=1,
+	subtract(Rest,InputVars1,IV3s),
+	length(IV3s,Length3),
+	subtract(Rest,IV3s,IV1s),
+	length(IV1s,Length2), Length2>=1,
+	subtract(IV3s,InputVars2,[]),
+
+	IV1Flag2=true,
+
+	%%delete(Program0,Rule,Program1),
+
+	%%(delete(Program0,Rule,Program3),
+	%%iv3s1(IV3s,Program3,IV3s,[]),
+	(Length3>=1->
+	(findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV3s,[],Rules5,IV1Flag3),not(Rules5=[]));
+	(Rules5=[],IV1Flag3=false)),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag4),
+	%%->true; Rules5=[],IV1Flag1=IV1Flag4),
+	
+	((findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV1s,[],Rules6,IV1Flag5), %%iv1s->rest, etc
+	iv1flagdisjunction(IV1Flag4,IV1Flag5,IV1Flag1))->true;(Rules6=[],IV1Flag1=IV1Flag4)),
+
+	append([Rule],Rules1,Rules9),
+	append(Rules9,Rules5,Rules7),
+	append(Rules7,Rules6,Rules8),
+	unique1(Rules8,[],Rules2).
+	
+
+**
+findrulesflowingtopv2(_Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	(not(member(Rule,Rules1))->
+	append(Rules1,[Rule],Rules2);Rules2=Rules1),
+	subset(Rest,InputVars2),
+
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+
+	IV1Flag1=false.
+**
+**
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),	
+	%%delete(Program1,[PredicateName,Vars],Program3),
+	%%Program3=Program1,
+	%%append(Rules1,[Rule],Rules3),
+	subset(Rest,InputVars2),
+	
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+
+%%	delete(Program0,Rule,Program1),
+
+	IV1Flag2=false,
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Rest,[],Rules4,IV1Flag3),
+	%%not(Rules4=[]),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1),
+
+	append(Rules1,[Rule],Rules7),
+	append(Rules7,Rules4,Rules8),
+	unique1(Rules8,[],Rules2).
+**
+**
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2(Rule,Program0,Program1,_Program2,InputVars1,InputVars,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	%%Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1(Program0,Program1,_Program2,InputVars1,InputVars,Rest,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+
+**
+iv1flagdisjunction(A,B,true) :-
+	(A=true); (B=true).
+iv1flagdisjunction(_,_,false).
+**
+iv3s0([],_,IV3s1,IV3s2).
+iv3s0(IV3s,Program0,IV3s1,IV3s2).
+	IV3s=[IV3|IV3s3],
+	iv3s1(IV3,Program0,IV3s1,IV3s4),
+	iv3s0(IV3s3,Program0,IV3s4,IV3s2).
+iv3s1(_,[],IV3s,IV3s).	
+iv3s1(IV3,Program0,IV3s1,IV3s2) :-
+	Program0=[Rule|Rules],
+	iv3s2(IV3,Rule,IV3s1,IV3s3),
+	iv3s1(IV3,Rules,IV3s3,IV3s2).
+iv3s2(IV3,Rule,IV3s,IV3s1,IV3s2).
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],_Rest,IV3),	
+	delete(IV3s1,IV3,IV3s2).
+
+
+findrulesflowingtopv1a(_,_,_,_,[],Rules,Rules).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	atom(Var),
+	findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Vars1,Rules1,Rules2) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv2(Program1,Program3,InputVars1,InputVars2,Var,Rules1,Rules3),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Vars2,Rules3,Rules2).
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv2a([],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2a(Program1,Program2,_InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program2),
+Program2=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules2),
+	subset(Rest,InputVars2)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program3),
+Program3=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	subset(Rest,InputVars2)),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Rest,Rules3,Rules2).
+
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1a(Program4,Program2,InputVars1,InputVars,Rest,Rules3,Rules2).
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+	**
+**/
+restlast([],_,_,_) :- fail, !.	
+restlast([Last],Rest,Rest,Last) :-
+	Last=[v,_],!.
+restlast(Last,Rest,Rest,Last) :-
+	length(Last,1),!.
+restlast(Vars1,Rest1,Rest2,Last) :-
+	Vars1=[Var|Vars2],
+	append(Rest1,[Var],Rest3),
+	restlast(Vars2,Rest3,Rest2,Last),!.
+
+
+rule(Program1,RuleName,InModes,OutModes,InputVars1,InputVars2,VarList,VarList2,OutputVars,Rule) :-
+
+/*
+findall(Rule_vars1,member([_Rule_name,Rule_vars1],Program1),Rule_vars2),foldr(append,Rule_vars2,Rule_vars3),
+
+% count vars
+	sort(Rule_vars3,K),
+	findall(G,(member(G,K),findall(G,member(G,Rule_vars3),H),length(H,J),J>2),L),
+% remove vars occuring more than twice
+%(not(InputVars10=[])->trace;true),
+(var(InputVars10)->InputVars10=InputVars1;subtract(InputVars10,L,InputVars1)),
+(var(VarList0)->VarList0=VarList;subtract(VarList0,L,VarList)),
+%notrace,
+*/
+%trace,
+%writeln1(rule(Program1,RuleName,InModes,OutModes,InputVars1,InputVars2,VarList,VarList2,OutputVars,Rule)),
+%notrace,
+
+rule1(RuleName,InModes,OutModes,InputVars1,InputVars2a,VarList,VarList2a,OutputVars,Rule1),
+((1 is InModes+OutModes,member(Rule1,Program1))->(InputVars1=[_|InputVars3],rule(Program1,RuleName,InModes,OutModes,InputVars3,InputVars2,VarList,VarList2,OutputVars,Rule2),Rule=Rule2);(%%InputVars1=InputVars3, *** Commented out
+Rule=Rule1,InputVars2=InputVars2a,VarList2a=VarList2))
+%%writeln1(Rule),(Rule=[[n,-],[[v,c],[v,c],[v,d]]]->true;true)
+.%%->writeln(rule(RuleName,InModes,OutModes,InputVars1,InputVars2,VarList,VarList2,OutputVars,Rule));true).%%(writeln(stop),abort)).
+%%.
+rule1(RuleName,InModes,OutModes,InputVars1,InputVars2,VarList,VarList2,OutputVars,Rule) :-
+%%writeln(rule(RuleName,InModes,OutModes,InputVars1,InputVars2,VarList,VarList2,OutputVars,Rule)),
+	get_members(InModes,InputVars1,[],Vars1),
+	rulea(OutModes,RuleName,Vars1,VarList,VarList2,
+		Rule,OutputVars,Vars2),
+	(num_modes(OutModes,Last,InputVars1),
+	(equals_or(Vars1,Last)->true;equals_or(Vars2,Last))),
+	append(InputVars1,Vars2,InputVars2)
+	%%retractall(lastrule(_)),
+   %%assertz(lastrule(Rule)),
+	.
+
+num_modes(OutModes,Last,_InputVars1) :-
+	OutModes=0,Last=[],!.
+num_modes(OutModes,Last,InputVars1) :-
+	not(OutModes=0),restlast(InputVars1,[],_,Last),!.
+	
+member_functions(Rule,Algorithms,Item) :-
+	member(Item,Algorithms),
+	Item=[Rule|_Rest].
+
+%%get_members(0,_,Vars,Vars):-true.
+get_members(_,[],Vars,Vars).
+get_members(InModes1,InputVars,Vars1,Vars2) :-
+	(not(InModes1=0)->(
+	%%findnsols(InModes1,A,(member(A,InputVars)),Vars2).
+	%%length(Vars2,InModes1),append(Vars2,_,InputVars).
+	member(Var,InputVars),
+	%%InputVars=[Var|InputVars2],
+	%%delete(InputVars,Var,InputVars2),
+	append(Vars1,[Var],Vars3),
+	InModes2 is InModes1-1,
+	get_members(InModes2,InputVars,Vars3,Vars2));
+	Vars1=Vars2). %%InModes2->1
+
+equals_or([],_) :- true,!.%%fail.***
+equals_or(List,Item) :-
+	List=[Item|_Rest],!.
+equals_or(List,Item1) :-
+	List=[Item2|Rest],
+	not(Item1=Item2),
+	equals_or(Rest,Item1),!.
+
+rulea(OutModes,RuleName,Vars1,VarList,VarList3,Rule,OutputVars,Vars2) :-
+    get_vars(OutModes,VarList,VarList3,OutputVars,[],Vars2),
+    append(Vars1,Vars2,Vars3),
+    Rule=[RuleName,Vars3],!.
+
+get_vars(0,VarList,VarList,_,Vars,Vars) :- !.
+get_vars(OutModes1,VarList1,VarList2,OutputVars,Vars1,Vars2) :-
+    var(VarList1,Var,VarList3,OutputVars),
+    append(Vars1,[Var],Vars3),
+    OutModes2 is OutModes1 - 1,
+	 get_vars(OutModes2,VarList3,VarList2,OutputVars,Vars3,Vars2),!.
+	
+/**
+
+rule(RuleName,1,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+	member(Var,InputVars1),
+	rule2(RuleName,Var,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule2(RuleName,Var,VarList,VarList2,Rule,Var1) :-
+	var(VarList,Var1,VarList2),
+	Rule=[RuleName,[Var,Var1]],!.
+
+rule(RuleName,1,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        rule3(RuleName,Var,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule3(RuleName,Var,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Var1,Var2]],!.
+
+rule(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        member(Vara,InputVars1),
+        rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1) :-
+        var(VarList,Var1,VarList2),
+        Rule=[RuleName,[Var,Vara,Var1]],!.
+
+rule(RuleName,2,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars),
+        member(Vara,InputVars),
+        rule5(RuleName,Var,Vara,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule5(RuleName,Var,Vara,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Vara,Var1,Var2]],!.
+
+**/
+
+%%var(Item,Var,Vars,Vars) :-
+%%	member([Item,Var],Vars).
+var(Vars1,Var1,Vars2,OutputVars) :-
+	length(Vars1,Vars1Length1),
+	Vars1Length2 is Vars1Length1-1,
+	length(Vars3,Vars1Length2),
+	append(Vars3,[Var2A],Vars1),
+	Var2A=[v,Var2],
+	char_code(Var2,Var2Code1),
+	Var2Code2 is Var2Code1 + 1,
+	var2(Var2Code2,Var1A,OutputVars),
+	Var1=[v,Var1A],
+	append(Vars1,[Var1],Vars2),!.
+
+var2(Code,Var1,OutputVars) :-
+	%%outputvars(OutputVars),
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Code =< Code2, %% 122
+	char_code(Var1,Code),
+	not(member(Var1,OutputVars)),!.
+var2(Var2Code,Code3,OutputVars) :-
+	Var2Code2 is Var2Code + 1,	
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Var2Code2 =< Code2,
+	var2(Var2Code2,Code3,OutputVars),!.
+/**
+algorithmstopredicates1([],Predicates1,Predicates1) :-!.
+algorithmstopredicates1(Algorithms1,Predicates1,Predicates2) :-
+	Algorithms1=[Algorithm1|Algorithms2],
+	Algorithm1=[_TestNumber,_Queries,Algorithm3],
+	algorithmstopredicates2(Algorithm3,[],Algorithm4),
+	append_list(Predicates1,Algorithm4,Predicates4),
+	algorithmstopredicates1(Algorithms2,Predicates4,Predicates2).
+algorithmstopredicates2([],Predicates1,Predicates1) :- !.
+algorithmstopredicates2(Algorithms1,Predicates1,Predicates2) :-
+	Algorithms1=[Algorithm1|Algorithms2],
+	Algorithm1=[Name,In,Out|Rest],
+	append(Predicates1,[[Name,In,Out|Rest]],Predicates4),
+	algorithmstopredicates2(Algorithms2,Predicates4,
+		Predicates2).
+**/
+split3([],List,List) :- !.
+split3(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[[n,Name],In,Out]|_Rest],
+	append(List1,[[[n,Name],In,Out]],List6),
+	split3(List4,List6,List2),!.
+	
+split2([],List,List) :- !.
+split2(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[[n,Name],_In,_Out]|Rest],
+	append(List1,[[[n,Name]|Rest]],List6),
+	split2(List4,List6,List2),!.
+
+/**
+split2([],List,List) :- !.
+split2(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=[[n,[Name,[[test,Test1],[numin,Numin],
+		[numout,Numout]]]]|Rest],
+	member([[n,[Name,[[test,_Test3],[numin,Numin],
+		[numout,Numout]]]]|Rest],List4),
+	delete(List4,[[n,[Name,[[test,_Test4],[numin,Numin],
+		[numout,Numout]]]]|Rest],
+		List7),
+	append(List1,[[[n,[Name,[[test,Test1],[numin,Numin],
+		[numout,Numout]]]]|Rest]],List6),
+	split2(List7,List6,List2),!.
+split2(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=[[n,[Name,[[test,Test1],[numin,Numin],
+		[numout,Numout]]]]|Rest],
+	append(List1,[[[n,[Name,[[test,Test1],[numin,Numin],
+		[numout,Numout]]]]|Rest]],List6),
+	split2(List4,List6,List2),!.
+	
+append_list(A,[],A):-!.
+append_list(A,List,B) :-
+	List=[Item|Items],
+	append(A,[Item],C),
+	append_list(C,Items,B).
+
+**/
+
+eliminate_unused_predicates(Program1a,Algorithms1a,Algorithms2) :-
+	%% System calls and mode arities
+	%%System_calls=[[is,1,1],[+,2,1],[=,2,1],[wrap,1,1],
+	%%[unwrap,1,1],[head,1,1],[tail,1,1],[member,1,1],
+	%%[delete,2,1],[append,2,1]], %% Ignore whether system calls are in Program and Algorithm - the interpreter will have detected whether system and user predicates clash earlier
+
+	Program1a=[[[n, PredicateName], Arguments, ":-", _Body]],
+	length(Arguments,ArgumentsLength),
+	Start=[[[n,PredicateName],ArgumentsLength]],
+		convert_to_grammar_part1(Program1a,[],_Program1b,Program1),
+	%% Find calls in Program
+	%%writeln([program1,Program1]),
+	find_calls1(Start,Program1,[],Program2),
+	%%writeln([program2,Program2]),
+	%% Find calls in Algorithm
+		convert_to_grammar_part1(Algorithms1a,[],_Algorithms1b,Algorithms1),
+	%%writeln([algorithms1,Algorithms1]),
+	find_calls1(Program2,Algorithms1,[],Algorithms3),
+	%%writeln([algorithms3,Algorithms3]),
+	append(Program2,Algorithms3,Rules),
+	%% Eliminate user predicates mentioned in Program and Algorithms in Algorithms 
+	eliminate_unused_predicates1(Rules,Algorithms1,[],
+		Algorithms2).
+	
+find_calls1(_,[],Program,Program) :- !.
+find_calls1(Program0,Program1,Program2,Program3) :-
+	Program1=[[_Program4a,Program4]|Program5],
+	%% The first predicate in Program4 only is needed to find the calls x
+	(findall(Program7a,(((member([[n,PredicateName],Arguments,":-",Program6],Program4)->true;((member([[n,PredicateName],Arguments],Program4),Program6=[])->true;Program4=[[n,PredicateName],Arguments,":-",Program6])),
+	length(Arguments,ArgumentsLength),
+	Item=[[n,PredicateName],ArgumentsLength],
+	(member(Item,Program0)->Program6=Program6a;Program6a=[])%%->true;
+	%%Item=Program0
+	),
+	(find_calls2(Program6a,[],Program7a))),[Program7])),
+	%%append(Program2,Program7,Program8),
+	%%append(Program0,Program7,Program01));
+	%%(Program8=Program2,Program01=Program0)),
+	append(Program2,Program7,Program8),
+	append(Program0,Program7,Program01),
+	find_calls1(Program01,Program5,Program8,Program3).
+	
+find_calls2([],Program,Program) :- !.
+/**
+find_calls2(Program1,Program2,Program3) :-
+	Program1=[Line|Program41],
+	Line=[[n,code]|Program42],
+	find_calls2(Program41,Program2,Program5),
+	append(Program5,Program42,Program6),
+	find_calls2(Program6,[],Program3).
+**/
+
+find_calls2(Program1,Program2,Program3) :-
+	Program1=[Line|Program4],
+	(Line=[[n,PredicateName],Arguments]->
+	length(Arguments,ArgumentsLength);
+	(Line=[[n,PredicateName]],ArgumentsLength=0)), %% correct syntax is [true] not true
+	Item=[[[n,PredicateName],ArgumentsLength]],
+	append(Program2,Item,Program5),
+	find_calls2(Program4,Program5,Program3).
+
+eliminate_unused_predicates1(_Rules,[],Algorithms,Algorithms) :- !.
+eliminate_unused_predicates1(Rules,Algorithms1,Algorithms2,Algorithms3) :-
+	Algorithms1=[[Algorithms4a,Algorithms4]|Algorithms5],
+	%%(Algorithms4a=[]->
+		%%eliminate_unused_predicates1(Rules,Algorithms5,Algorithms2,
+		%%Algorithms3),%%;
+((findall(Algorithms6a,(((member(Algorithms4a1,Algorithms4),Algorithms4a1=[[n,_]|_])->true;Algorithms4a1=Algorithms4),	((Algorithms4a1=[[n,PredicateName],Arguments,":-",_Program6],
+%%Algorithms4a1=[[n,PredicateName],Arguments])->
+	length(Arguments,ArgumentsLength))->true;
+	(Algorithms4a1=[[n,PredicateName],Arguments2],
+		length(Arguments2,ArgumentsLength)->true;
+		(Algorithms4a1=[[n,PredicateName]],ArgumentsLength=0))),
+	Item=[[n,PredicateName],ArgumentsLength],
+	(member(Item,Rules)->
+		(Algorithms4a=[]->Algorithms2=Algorithms6a;
+		append(Algorithms2,
+		[Algorithms4a],Algorithms6a));
+		Algorithms6a=Algorithms2)),Algorithms6b)),
+		Algorithms6b=[Algorithms6c|_],
+		(var(Algorithms6c)->Algorithms6=[];Algorithms6=Algorithms6c),
+		%%length(Algorithms4,Count)),
+	eliminate_unused_predicates1(Rules,Algorithms5,Algorithms6,
+		Algorithms3)).

Combination-Algorithm-Writer-Multiple-Predicates/cawmp.bib

@@ -0,0 +1,7 @@
+@misc {cawmp,
+  author    = {Lucian Green},
+  title  = {Combination Algorithm Writer with Multiple Predicates System},
+  year   = {2019},
+  howpublished = "https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates",
+  URL = "https://github.com/luciangreen/Combination-Algorithm-Writer-Multiple-Predicates"
+}

Combination-Algorithm-Writer-Multiple-Predicates/cawplistprolog.pl

@@ -0,0 +1,43 @@
+:- include('../listprologinterpreter/grammar.pl').
+:- include('lpi_caw_commands.pl').
+:- include('../listprologinterpreter/listprologinterpreter1listrecursion4.pl').
+:- include('../listprologinterpreter/listprologinterpreter3preds5.pl').
+:- include('../listprologinterpreter/lpiverify4.pl').
+:- include('../listprologinterpreter/lpiverify4_open.pl').
+:- include('../listprologinterpreter/lpiverify4_types.pl').
+:- include('../listprologinterpreter/lpiverify4_open_types.pl').
+:- include('caw5 copy 12.pl').
+:- include('cawpverify.pl').
+%%:- include('rcawp.pl').
+%%:- include('rcaw.pl').
+%%:- include('../Text-to-Breasonings/texttobr2.pl').
+:- include('../listprologinterpreter/la_strings.pl').
+:- include('../listprologinterpreter/la_string_codes.pl').
+:- include('../listprologinterpreter/la_maths.pl').
+:- include('remove_duplicate_predicates.pl').
+:- include('cawpverifya.pl').
+
+
+%%:- include('caw5 copy 12.pl').
+%%:- include('cawpverify.pl').
+%%:- include('rcawp.pl').
+%%:- include('rcaw.pl').
+%%:- include('texttobr2.pl').
+:- include('../listprologinterpreter/la_strings.pl').
+%:- include('../Languages/lang_db_generator.pl'). % leave off, run separately through Languages
+%:- include('../listprologinterpreter/lpiverify4-fr.pl').
+:- include('../listprologinterpreter/operators.pl').
+:- include('../listprologinterpreter/lpiverify4_test_lang_all.pl').
+:- include('../listprologinterpreter/lpiverify4_test_bt_lang_all.pl').
+:- include('../Languages/make_docs.pl').
+:- include('../SSI/find_pred_sm.pl').
+:- include('../listprologinterpreter/e4_fa_get_vals.pl').
+%:- include('../listprologinterpreter/equals4_first_args.pl').
+:- include('../listprologinterpreter/expression_not_var.pl').
+:- include('../listprologinterpreter/collect_arguments.pl').
+:- include('../listprologinterpreter/reserved_words2.pl').
+:- include('../listprologinterpreter/expand_types.pl').
+:- include('../listprologinterpreter/replace_in_term.pl').
+:- include('../listprologinterpreter/preds_converters_and_matrices.pl').
+%:- include('numbers_of_items_correspond.pl').
+:- include('../listprologinterpreter/match_get_put_vals.pl').

Combination-Algorithm-Writer-Multiple-Predicates/cawpverify.pl

@@ -0,0 +1,429 @@
+
+%% cawptest(Debug[on/off],Total,Score).
+
+cawptest(Debug,NTotal,Score) :- cawptest(Debug,0,NTotal,0,Score),!.
+cawptest(_Debug,NTotal,NTotal,Score,Score) :- NTotal=9, !.
+cawptest(Debug,NTotal1,NTotal2,Score1,Score2) :-
+	NTotal3 is NTotal1+1,
+	cawptest2(NTotal3,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs,Numoutputs,Specifications,AlgDict,Program1),
+	
+	%%writeln([cawptest2(NTotal3,Specifications,Program1)]),
+	(((%%writeln(caw00(Debug,function0,[],5,TotalVars,Specifications,[],Program1)),
+	caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program1)
+	
+	%%sort(Program1,ProgramA),
+	%%sort(Program2,ProgramA)
+	%%writeln1(Program1),writeln1(Program2)
+	%%Program1=Program2
+	))->(Score3 is Score1+1,writeln([cawptest,NTotal3,passed]));(Score3=Score1,writeln([cawptest,NTotal3,failed]))),
+	writeln(""),
+	cawptest(Debug,NTotal3,NTotal2,Score3,Score2),!.
+
+%% Test individual cases, Debug=trace=on or off, N=case number, Passed=output=result
+
+cawptest1(Debug,N,Passed) :-
+	cawptest2(N,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,Program1),
+	%%writeln1([cawptest2(N,Specifications,Program1)]),
+	%%writeln1(caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program2)),
+
+	(((caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program1)
+	%%sort(Program1,ProgramA),
+	%%sort(Program2,ProgramA)
+
+	%writeln(Program1),
+	%writeln(Program2),
+	%Program1=Program2
+	))->(Passed=passed,writeln([cawptest,N,passed]));(Passed=failed,writeln([cawptest,N,failed]))),!.
+
+
+/**
+cawptest2(1,add0,[[[n,+],2,1%% Modes=2 inputs, 1 output
+]],2,2,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+4,
+[2],[1],%% Numinputs, Numoutputs tested for
+[
+    [[[[[v,a],1],[[v,b],1]],[[[v,c],2]],true]],
+    [[[[[v,a],1],[[v,b],1]],[[[v,c],2]],true]]
+]
+,
+[], %% Algorithm dictionary
+[ %% Result
+        [[n,1],[[v,a],[v,b],[v,c]],":-",
+        [       [[n,+],[[v,a],[v,b],[v,d]]],
+                [[n,=],[[v,d],[v,c]]]]],
+        [[n,add0],[[v,a],[v,b],[v,c]],":-",
+        [       [[n,1],[[v,a],[v,b],[v,d]]],
+                [[n,=],[[v,d],[v,c]]]]]
+]).
+**/
+cawptest2(1,add0,[[[n,+],2,1%% Modes=2 inputs, 1 output
+]],2,2,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+4,
+[2],[1],%% Numinputs, Numoutputs tested for
+[
+    [[[[[v,a],1],[[v,b],1]],[[[v,c],2]],true]],
+    [[[[[v,a],2],[[v,b],1]],[[[v,c],3]],true]]
+]
+,
+[], %% Algorithm dictionary
+[ %% Result
+        [[n,1],[[v,a],[v,b],[v,c]],":-",
+        [       [[n,+],[[v,a],[v,b],[v,d]]],
+                [[n,=],[[v,d],[v,c]]]]],
+        [[n,add0],[[v,a],[v,b],[v,c]],":-",
+        [       [[n,1],[[v,a],[v,b],[v,d]]],
+                [[n,=],[[v,d],[v,c]]]]]
+]).
+
+%% With a=input and b=input, returns [[[n,1],[[v,a],[v,b]],:-,[[[n,+],[[v,a],1,[v,c]]],[[n,=],[[v,c],[v,b]]]]],[[n,1],[[v,a],[v,b]],:-,[[[n,-],[[v,a],1,[v,c]]],[[n,=],[[v,c],[v,b]]]]],[[n,add0],[[v,a],[v,b]],:-,[[[n,1],[[v,b],[v,c]]],[[n,=],[[v,a],[v,a]]]]]] which is incorrect, and with a=input and b=output nondeterministic clauses fail
+%% Non-determinism is not supported in List Prolog.  List Prolog should use if-then instead of non-deterministic clauses.
+%% Use if-then with calls to predicates as consequents.
+cawptest2(2,add0,[],2,1,3,[1,2],[0,1],
+[[[[[[v,a],1],[[v,b],2]],[],true],[[[[v,a],2],[[v,b],1]],[],true]]],
+
+[ %% Algorithm dictionary
+        [[[n,1],1,1],[[v,a],[v,b]],":-",
+        [       [[n,+],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[[n,1],1,1],[[v,a],[v,b]],":-",
+        [       [[n,-],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]]
+],
+
+ %% Result
+
+[[[n,1],[[v,a],[v,b]],":-",
+	[[[n,+],[[v,a],1,[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,1],[[v,a],[v,b]],":-",
+	[[[n,-],[[v,a],1,[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,1],[[v,a],[v,c]]],
+	[[n,=],[[v,b],[v,c]]]]]]
+
+).
+
+%%[[[n,a2],[[v,a],[v,b]],:-,[[[n,+],[[v,a],1,[v,c]]],[[n,=],[[v,c],[v,b]]]]],[[n,add0],[[v,a],[v,b]],:-,[[[n,a2],[[v,a],[v,c]]]]]]
+
+
+%% () Can underscore vars in spec, ignore in choose var, everyvarcovered
+
+%% Was test 9 on bu16
+
+cawptest2(3,add,[[[n,[]],1,0],[[n,"_"],1,0]],1,1,1,[1],[0],
+[
+/**[[[[[v,a],[1,2,3]],[[v,b],3],[[v,c],[]]],
+	[[[v,d],[4,5,6]],[[v,e],[2,3]]],true],**/
+	[[[[[v,a],3]],
+	[],true]]
+
+	/**
+[[[[[[v,a],[1,2,3]],[[v,b],3],[[v,c],[]]],
+	[[[v,d],[4,5,6]],[[v,e],[2,3]]],true],
+[[[[v,a],[]],[[v,b],3],[[v,c],[4,5,6]]],
+	[[[v,d],[4,5,6]],[[v,e],5]],true]]]],
+**/
+],
+[ %% Algorithm dictionary
+],
+%% Result
+
+	[[[n,add],[[v,a]],":-",[[[n,"_"],[[v,a]]]]]]
+
+	/**
+[[n,1],[[v,a],[v,b],[v,c],[v,d]],":-", %% Test by self
+	[[[n,[]],[[v,c]]]]],
+[[n,add],[[v,a],[v,b],[v,c],[v,d]],":-",
+	[[n,1],[[v,a],[v,b],[v,c],[v,d]]]]**/
+).
+
+
+
+cawptest2(4,function3,[[[n,+],2,1]],3,1,5,[2],[1],
+[[[[[[v,a],1],[[v,b],1]],[[[v,c],3]],true],
+[[[[v,a],1],[[v,b],2]],[[[v,c],5]],true]]],
+[ %% Algorithm dictionary
+],
+[ %% Result
+[[n,function3],[[v,a],[v,b],[v,c]],":-",
+	[[[n,+],[[v,a],[v,b],[v,d]]],
+	[[n,+],[[v,b],[v,d],[v,e]]],
+	[[n,=],[[v,e],[v,c]]]]]]).
+
+
+cawptest2(5,add0,[[[n,+],2,1]],1,1,4,% 3 x 5 %% 2,2,3
+[2],[1],
+[
+    [[[[[v,a],1],[[v,b],1]],[[[v,c],2]],true]]
+%%  [[[[[v,a],1]],[[[v,b],2]],true]],
+%%  [[[[[v,a],1],[[v,b],1]],[[v,c],2],true]]
+]
+,
+[ %% Algorithm dictionary
+],
+[ %% Result
+        [[n,add0],[[v,a],[v,b],[v,c]],":-",
+        [       [[n,+],[[v,a],[v,b],[v,d]]],
+                [[n,=],[[v,d],[v,c]]]]]
+
+]).
+
+%%%%*****
+
+
+cawptest2(6,function3,[],2,1,4,[2],[1],
+[[[[[[v,a],1],[[v,b],1]],[[[v,c],2]],true],
+	[[[[v,a],1],[[v,b],2]],[[[v,c],3]],true],
+[[[[v,a],1],[[v,b],1]],[[[v,c],1]],fail],
+	[[[[v,a],1],[[v,b],1]],[[[v,c],3]],fail]]],
+[ %% Algorithm dictionary
+
+	[[[n,function1],2,1],[[v,a],[v,b],[v,c]],":-", 
+	[
+		[[n,+],[[v,a],[v,b],[v,c]]]
+	]
+	]
+
+],
+[ %% Result
+[[n,function1],[[v,a],[v,b],[v,c]],":-",
+	[[[n,+],[[v,a],[v,b],[v,c]]]]],
+[[n,function3],[[v,a],[v,b],[v,c]],":-",
+	[[[n,function1],[[v,a],[v,b],[v,d]]],
+	[[n,=],[[v,d],[v,c]]]]]]).
+
+/**
+%%**
+cawptest2(7,add0,[],3,3,%% it could be 5
+4,
+[1],[1],
+[
+[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[1,2]]],[[[v,b],[2]]],true]],
+[[[[[v,a],[2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[]]],[[[v,b],[]]],true]]
+],
+[ %% Algorithm dictionary
+[[[n,add2],1,1],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[[n,add3],1,1],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]]
+],
+[ %% Result
+[[n,add2],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[n,add3],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,1],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,1],[[v,a],[v,b]],":-",
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,1],[[v,a],[v,b]],":-",
+	[[[n,add3],[[v,a],[v,c]]],
+	[[n,1],[[v,c],[v,d]]],
+	[[n,=],[[v,d],[v,b]]]]]]).
+
+cawptest2(7.1,add0,[],2,1,%% it could be 5
+3,
+[1],[1],
+[
+%%[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+%%[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+%%[[[[[v,a],[1,2]]],[[[v,b],[2]]],true]],
+%%[[[[[v,a],[2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[]]],[[[v,b],[]]],true]]
+],
+[ %% Algorithm dictionary
+[[[n,add2],1,1],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]]
+%%[[[n,add3],1,1],[[v,a],[v,b]],":-",
+%%	[[[n,tail],[[v,a],[v,b]]]]]
+],
+[ %% Result
+[[n,add2],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]]]
+).
+
+cawptest2(7.2,add0,[],3,2,%% it could be 5
+3,
+[1],[1],
+[
+[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[1,2]]],[[[v,b],[2]]],true]],
+[[[[[v,a],[2]]],[[[v,b],[]]],true]],
+[[[[[v,a],[]]],[[[v,b],[]]],true]]
+],
+[ %% Algorithm dictionary
+[[[n,add2],1,1],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[[n,add3],1,1],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]]
+],
+[ %% Result
+[[n,add2],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[n,add3],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,add3],[[v,a],[v,c]]],
+	[[n,add0],[[v,c],[v,d]]],
+	[[n,=],[[v,d],[v,b]]]]]]).
+	**/
+
+cawptest2(7,add0,[[[n,+],2,1%% Modes=2 inputs, 1 output
+],[[n,-],2,1]],4,1,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+6,
+[2],[1],%% Numinputs, Numoutputs tested for
+[
+    [[[[[v,a],1],[[v,b],1]],[[[v,c],0],[[v,d],2]],true],
+    [[[[v,a],1],[[v,b],2]],[[[v,c],1],[[v,d],3]],true]]
+]
+,
+[], %% Algorithm dictionary
+/**[ %% Result
+        [[n,add0],[[v,a],[v,b],[v,c],[v,d]],":-",
+        [       [[n,+],[[v,a],[v,b],[v,e]]],
+                [[n,+],[[v,a],[v,b],[v,f]]],
+                [[n,=],[[v,c],[v,e]]],
+                [[n,=],[[v,f],[v,d]]]]]**/
+                
+       /**
+        [[[n,add0],[[v,a],[v,b],[v,c],[v,d]],":-",
+                [[[n,+],[[v,a],[v,a],[v,e]]],
+                [[n,+],[[v,a],[v,b],[v,f]]],
+                [[n,=],[[v,e],[v,c]]],
+                [[n,=],[[v,e],[v,d]]]]]
+                **/
+                
+               /**
+                [[[n,add0],[[v,a],[v,b],[v,c],[v,d]],":-",
+                	[[[n,+],[[v,a],[v,b],[v,e]]],
+                	[[n,-],[[v,b],[v,a],[v,f]]],
+                	[[n,=],[[v,e],[v,d]]],
+                	[[n,=],[[v,f],[v,c]]]]]]
+**/
+
+[[[n,add0],[[v,a],[v,b],[v,c],[v,d]],":-",
+	[[[n,+],[[v,a],[v,b],[v,e]]],
+	[[n,-],[[v,b],[v,a],[v,f]]],
+	[[n,=],[[v,e],[v,d]]],
+	[[n,=],[[v,f],[v,c]]]]]]
+
+).
+
+/**
+ Not tested nonrecursive multiclauses
+cawptest2(8,add0,[[[n,+],2,1],[[n,-],2,1]],2,3,4,[2],[1],
+[[[[[[v,a],1],[[v,b],1]],[[[v,b],2]],true],[[[[v,a],2],[[v,b],1]],[[[v,b],1]],true]],
+[[[[[v,a],1],[[v,b],1]],[[[v,b],2]],true]],
+[[[[[v,a],2],[[v,b],1]],[[[v,b],1]],true]]],
+
+[ %% Algorithm dictionary
+],
+
+ %% Result
+
+[[[n,1],[[v,a],[v,b],[v,c]],":-",
+	[[[n,+],[[v,a],[v,b],[v,d]]],
+	[[n,=],[[v,c],[v,d]]]]],
+[[n,1],[[v,a],[v,b],[v,c]],":-",
+	[[[n,-],[[v,a],[v,b],[v,d]]],
+	[[n,=],[[v,d],[v,c]]]]],
+[[n,add0],[[v,a],[v,b],[v,c]],":-",
+	[[[n,1],[[v,a],[v,b],[v,d]]],
+	[[n,=],[[v,c],[v,d]]]]]]
+).
+**/
+ 
+/**
+
+cawptest2(8,add0,[[[n,+],2,1%% Modes=2 inputs, 1 output
+]],4,1,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+8,
+[2],[1],%% Numinputs, Numoutputs tested for
+[
+    [[[[[v,a],1],[[v,b],1],[[v,c],2],[[v,d],1]],[[[v,e],5]],true],
+    [[[[v,a],2],[[v,b],2],[[v,c],2],[[v,d],1]],[[[v,e],7]],true]]
+]
+,
+[],
+%% add options to remove extra choice points
+%% test on lpiv
+%% caw00(off,add0,[[[n,+],2,1]],4,1,8,[2,4],[1],[[[[[[v,a],1],[[v,b],1],[[v,c],2],[[v,d],1]],[[[v,e],5]],true],[[[[v,a],2],[[v,b],2],[[v,c],2],[[v,d],1]],[[[v,e],7]],true]]],[],[],P).
+%% x:
+
+[[[n,add0],[[v,a],[v,b],[v,c],[v,d],[v,e]],":-",[[[n,+],[[v,a],[v,b],[v,f]]],[[n,+],[[v,c],[v,f],[v,g]]],[[n,+],[[v,d],[v,g],[v,h]]],[[n,=],[[v,h],[v,e]]]]]]
+
+).
+
+**/
+
+% ["Computational English","COMPUTATIONAL ENGLISH by Lucian Green Conglish Reflection 2 of 4.txt",0,algorithms,"14.   *I prepared to serve the vegetable burger.  I did this by cooking the vegetable patty.  First, I made the patty from semolina, soy and carrot.  Second, I minced it up.  Third, I cooked it.  In this way, I prepared to serve the vegetable burger by cooking the vegetable patty."]
+
+
+cawptest2(8,append1,[[[n,append],2,1%% Modes=2 inputs, 1 output
+]],3,1,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+7,
+[3],[1],%% Numinputs, Numoutputs tested for
+[
+	[[[[[v,a],["top"]],[[v,b],["middle"]],[[v,c],["bottom"]]],
+		[[[v,d],["top","middle","bottom"]]],true]]
+]
+,
+[],
+[[[n,append1],[[v,a],[v,b],[v,c],[v,d]],":-"	,[[[n,append],[[v,a],[v,b],[v,e]]],[[n,append],[[v,e],[v,c],[v,f]]],[[n,=],[[v,f],[v,d]]]]]]
+
+).
+    
+% ["Fundamentals of Pedagogy and Pedagogy Indicators","FUNDAMENTALS OF PEDAGOGY by Lucian Green Two Uses 23 of 30.txt",0,algorithms,"225.	ALEXIS: *The subject should write logically connected breasonings."]
+
+/**
+
+cawptest2(9,mp*,[[[n,append],2,1%% Modes=2 inputs, 1 output
+]],3,1,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+7,
+[3],[1],%% Numinputs, Numoutputs tested for
+[
+	[[[[[v,a],["p1"]],[[v,b],["p1","p2"]]],
+		[[[v,c],["p2"]]],true]]
+]
+,
+[],
+[[[n,mp],[[v,a],[v,b],[v,c],[v,d]],":-"	,[[[n,append],[[v,a],[v,b],[v,e]]],[[n,append],[[v,e],[v,c],[v,f]]],[[n,=],[[v,f],[v,d]]]]]]
+
+).
+
+**/
+
+/*
+cawptest2(9,append1,[[[n,append],2,1%% Modes=2 inputs, 1 output
+]],3,1,%% MaxPredicates is not the number of predicates in the result, it is the number of non-dictionary predicates in the result.
+7,
+[3],[1],%% Numinputs, Numoutputs tested for
+[
+	[[[[[v,a],["top"]],[[v,b],["middle"]],[[v,c],["bottom"]]],
+		[[[v,d],["top","middle","bottom"]]],true]]
+]
+,
+[],
+[[[n,append1],[[v,a],[v,b],[v,c],[v,d]],":-"	,[[[n,append],[[v,a],[v,b],[v,e]]],[[n,append],[[v,e],[v,c],[v,f]]],[[n,=],[[v,f],[v,d]]]]]]
+
+).
+*/

Combination-Algorithm-Writer-Multiple-Predicates/cawpverifya.pl

@@ -0,0 +1,129 @@
+%% Test individual cases, Debug=trace=on or off, N=case number, Passed=output=result
+
+cawptest1a(Debug,N,Passed) :-
+	cawptest2a(N,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,Program1),
+	%%writeln1([cawptest2(N,Specifications,Program1)]),
+	%%writeln1(caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program2)),
+
+	(((caw000(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program1)
+	%%sort(Program1,ProgramA),
+	%%sort(Program2,ProgramA)
+
+	%%writeln(Program1),
+	%%writeln(Program2),
+	%%Program1=Program2
+	))->(Passed=passed,writeln([cawptest,N,passed]));(Passed=failed,writeln([cawptest,N,failed]))),!.
+	
+cawptest2a(7,[add0,add0],[],[2,3],[1,1],%% it could be 5
+[3,4], %% 4 not 3 because of bug
+[1],[1],
+[
+[[[[[[v,a],[]]],[[[v,b],[]]],true]]],
+
+[[[[[[v,a],[1,2,3]]],[[[v,b],[]]],true]]]
+%%[[[[[v,a],[2]]],[[[v,b],[]]],true]], %% Needs to progress bottom up by writing base case first
+%%[[[[[v,a],[1,2]]],[[[v,b],[]]],true]], %% add0 second clause has this not spec below
+%%[[[[[v,a],[1,2]]],[[[v,b],[2]]],true]],
+%%[[[[[v,a],[2]]],[[[v,b],[]]],true]]
+%%[[[[[v,a],[1,2]]],[[[v,b],[]]],true]],
+],
+[ %% Algorithm dictionary
+[[[n,add2],1,1],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[[n,add3],1,1],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]]
+	
+	 %% Result
+/**[[[n,add1],1,1],[[v,a],[v,b]],":-",
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]]
+**/
+],
+[ %% Result
+%%[[n,add3],[[v,a],[v,b]],":-", %% swapped a3,a2
+	%%[[[n,tail],[[v,a],[v,b]]]]],
+
+/**[[n,add2],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[n,add0],[[v,a],[v,b]],":-", 
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]]],
+**/	
+	 %% Resulting base case
+
+	[[[n,add2],[[v,a],[v,b]],":-",
+		[[[n,=],[[v,a],[]]],
+		[[n,=],[[v,b],[]]]]],
+	[[n,add0],[[v,a],[v,b]],":-",
+		[[[n,add2],[[v,a],[v,c]]],
+		[[n,=],[[v,c],[v,b]]]]]],
+	
+	[ %% Resulting recursive algorithm
+	
+[[n,add2],[[v,a],[v,b]],":-",
+	[[[n,=],[[v,a],[]]],
+	[[n,=],[[v,b],[]]]]],
+[[n,add3],[[v,a],[v,b]],":-",
+	[[[n,tail],[[v,a],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,add2],[[v,a],[v,c]]],
+	[[n,=],[[v,c],[v,b]]]]],
+[[n,add0],[[v,a],[v,b]],":-",
+	[[[n,add3],[[v,a],[v,c]]],
+	[[n,add0],[[v,c],[v,d]]],
+	[[n,=],[[v,d],[v,b]]]]]]]
+	
+	).
+
+
+%%[[[n,add],[[v,a],[v,c],[v,d]],":-",[[[n,[]],[[v,a]]],[[n,=],[[v,c],[v,d]]]]]]
+
+%% Add cover all vars before returning
+%%**/
+
+
+/** Doesn't work
+%% before now, io=21
+cawptest2(7,add0,[],2,3,5,% 3 x 5
+[1,2],[0,1],
+[[[[[[v,a],1],[[v,b],2]],[],true],[[[[v,a],2],[[v,b],1]],[],true]],
+%%[[[[[v,a],1],[[v,b],2]],[],true],[[[[v,a],2],[[v,b],1]],[],true]],
+[[[[[v,a],1]],[[[v,b],2]],true]],
+[[[[[v,a],2]],[[[v,b],1]],true]]
+],
+
+[ %% Algorithm dictionary
+
+        [[[n,a2],1,1],[[v,a],[v,b]],":-",
+        [       [[n,+],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[[n,a3],1,1],[[v,a],[v,b]],":-",
+        [       [[n,-],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]]
+],
+
+[ %% Result
+        [[n,a2],[[v,a],[v,b]],":-",
+        [       [[n,+],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[n,a3],[[v,a],[v,b]],":-",
+        [       [[n,-],[[v,a],1,[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[n,add0],[[v,a],[v,b]],":-",
+        [       [[n,1],[[v,a],[v,b]]]]],
+        
+        [[n,1],[[v,a],[v,b]],":-",
+        [       [[n,a2],[[v,a],[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]],
+
+        [[n,1],[[v,a],[v,b]],":-",
+        [       [[n,a3],[[v,a],[v,c]]],
+                [[n,=],[[v,c],[v,b]]]]]
+]).
+
+**/

Combination-Algorithm-Writer-Multiple-Predicates/convert_lp_to_caw0000.pl

@@ -0,0 +1,68 @@
+% 
+
+
+/**
+
+convert_lp_to_caw0000(
+[
+        [[n,reverse],[[],[v,l],[v,l]]],
+        [[n,reverse],[[v,l],[v,m],[v,n]],":-",
+        [       [[n,head],[[v,l],[v,h]]],
+                [[n,tail],[[v,l],[v,t]]],
+                [[n,wrap],[[v,h],[v,h1]]],
+                [[n,append],[[v,h1],[v,m],[v,o]]],
+                [[n,reverse],[[v,t],[v,o],[v,n]]]
+        ]
+        ]
+],
+
+[
+	% gets used i,o (with header with vars that are only either 
+	% 	in the header or used in another reverse_c4*
+
+	% skips writeln, other predetermined commands
+	% assumes wrap, unwrap used
+	% doesn't use read_string (takes var input instead)
+	
+	[[n,reverse],[[],[v,l],[v,l]]],
+	
+	[[n,reverse_c41],[[v,l],[v,t],[v,h1]],":-",
+	[	[[n,head],[[v,l],[v,h]]],
+		[[n,tail],[[v,l],[v,t]]],
+		[[n,wrap],[[v,h],[v,h1]]]
+	]],
+	
+	% with vars it needs from another r_c4* or the header
+	
+	[[n,reverse_c42],[[v,h1],[v,m],[v,t],[v,n]],":-",
+	[	[[n,append],[[v,h1],[v,m],[v,o]]],
+		[[n,reverse],[[v,t],[v,o],[v,n]]]
+	]]
+],
+
+[
+	% finds algs (configuration of calls to certain 
+	% 	commands with header
+	% puts together pred
+
+	[[n,reverse],[[],[v,l],[v,l]]],
+	
+	[[n,reverse],[[v,l],[v,m],[v,n]],":-",
+	[	[n,reverse_c41],[[v,l],[v,t],[v,h1]],
+		[n,reverse_c42],[[v,h1],[v,m],[v,t],[v,n]]
+	]]
+],
+
+	% finds specs for r_c4*'s by using lpi with a 
+	% flag switched on that returns the specs
+	% - specs are i,o vars for lines, where c4 alg
+	%   finds algs meeting spec for set of lines
+	
+	% * LPI numbers pred, pred lines, has widgets that 
+	% indicate these and the var states
+	% - with assertz x another var
+
+**/
+
+convert_lp_to_caw0000 :-
+

Combination-Algorithm-Writer-Multiple-Predicates/lpi_caw_commands.pl

@@ -0,0 +1,173 @@
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,Operator]],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	isop(Operator),
+	interpretpart(not_is,Variable1,Variable2,Vars1,Vars2),!.
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,Operator]],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	comparisonoperator(Operator),
+%%writeln1(4),
+        interpretpart(not_iscomparison,Operator,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,member]],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln1(8),
+        interpretpart(not_member,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,head]],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln1(6),
+        interpretpart(not_head,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,tail]],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln1(61),
+        interpretpart(not_tail,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,append]],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+%%writeln1(9),
+        interpretpart(not_append,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[not,stringconcat]],[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+        interpretpart(not_stringconcat,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,[]],[Variable1]],Vars1,Vars2,true,nocut) :-
+%%writeln1(8),
+        interpretpart([],Variable1,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,""],[Variable1]],Vars1,Vars2,true,nocut) :-
+%%writeln1(8),
+        interpretpart("",Variable1,Vars1,Vars2).
+
+interpretstatement1(ssi,_F0,_Functions,[[n,"_"],[Variable1]],Vars1,Vars2,true,nocut) :-
+%%writeln1(8),
+        interpretpart("_",Variable1,Vars1,Vars2).
+
+
+interpretpart(not_is,Variable1,Variable2,Vars1,Vars1) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        	not(isempty(Value1)),
+        	not(isempty(Value2)),
+        debug_call(Skip,[[n,[not,=]],[Value1,Value2]]),
+        ((not(Value1 = Value2)
+		)->
+      debug_exit(Skip,[[n,[not,=]],[Value1,Value2]])
+;     debug_fail(Skip,[[n,[not,=]],[Value1,Value2]])),!.                        	
+
+interpretpart(not_iscomparison,Operator,Variable1,Variable2,Vars1,Vars1) :-        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        debug_call(Skip,[[n,[not,Operator]],[Value1,Value2]]),
+	((isval(Value1),
+	isval(Value2),
+	Expression=..[Operator,Value1,Value2],
+        not(Expression))->
+      debug_exit(Skip,[[n,[not,Operator]],[Value1,Value2]])
+;     debug_fail(Skip,[[n,[not,Operator]],[Value1,Value2]])),!.
+
+interpretpart(not_member,Variable1,Variable2,Vars1,Vars1) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+debug_call(Skip,[[n,[not,member]],[Value1,Value2]]),
+  	(((not(Value2=empty)->%%member(Value2,Value1),
+	(not(member(Value2,Value1))
+	%%putvalue(Variable2,Value3,Vars1,Vars2)%%,Vars2=Vars1
+	)))->
+      debug_exit(Skip,[[n,[not,member]],[Value1,Value2]])
+;     debug_fail(Skip,[[n,[not,member]],[Value1,Value2]])),!.
+
+interpretpart(not_head,Variable1,Variable2,Vars1,Vars1) :-
+	getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+debug_call(Skip,[[n,[not,head]],[Value1,Value2]]),
+	((not(Value1=[Value2|_Rest])
+        %%val1emptyorvalsequal(Value2,Value1A),
+        %%putvalue(Variable2,Value1A,Vars1,Vars2)
+        )->
+      debug_exit(Skip,[[n,[not,head]],[Value1,Value2]])
+;     debug_fail(Skip,[[n,[not,head]],[Value1,Value2]])),!.
+        	
+interpretpart(not_tail,Variable1,Variable2,Vars1,Vars1) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+debug_call(Skip,[[n,[not,tail]],[Value1,Value2]]),
+        ((not(Value1=[_Head|Value2])
+	%%removebrackets(Value1A,Value1B), 
+        %%val1emptyorvalsequal(Value2,Value1A),
+        %%putvalue(Variable2,Value1A,Vars1,Vars2)
+        )->
+      debug_exit(Skip,[[n,[not,tail]],[Value1,Value2]])
+;     debug_fail(Skip,[[n,[not,tail]],[Value1,Value2]])),!.
+        	
+interpretpart(not_append,Variable1,Variable2,Variable3,Vars1,Vars1) :-
+        	
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        debug_call(Skip,[[n,[not,append]],[Value1,Value2,Value3]]),
+        ((islist(Value1),islist(Value2),
+        not(append1(Value1,Value2,Value3))
+        %%val1emptyorvalsequal(Value3,Value3A),
+       %% putvalue(Variable3,Value3A,Vars1,Vars2)
+       )->
+      debug_exit(Skip,[[n,[not,append]],[Value1,Value2,Value3]])
+;     debug_fail(Skip,[[n,[not,append]],[Value1,Value2,Value3]])),!.                        	
+
+interpretpart(not_stringconcat,Variable1,Variable2,Variable3,Vars1,Vars1) :-
+        	
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        debug_call(Skip,[[n,[not_stringconcat]],[Value1,Value2,Value3]]),
+        ((string(Value1),string(Value2),string(Value3),
+        stringconcat(Value1,Value2,Value3)
+        %%val1emptyorvalsequal(Value3,Value3A),
+        %%putvalue(Variable3,Value3A,Vars1,Vars2)
+        )->
+      debug_exit(Skip,[[n,[not_stringconcat]],[Value1,Value2,Value3]])
+;     debug_fail(Skip,[[n,[not_stringconcat]],[Value1,Value2,Value3]])),!.                        	
+
+interpretpart([],Variable1,Vars1,Vars1) :-
+        getvalue(Variable1,Value1,Vars1),
+        %%getvalue(Value1,Value1A,Vars1),
+	%%isvalstr(Value1),
+	%%isvalstr(Value1A),
+	not(isempty(Value1)),
+	%%isempty(Value2),
+        %%val1emptyorvalsequal(Value2,Value1),
+	%%isval(Value2),
+debug_call(Skip,[[n,[]],[Value1]]),
+(        Value1=[]->
+debug_exit(Skip,[[n,[]],[Value1]])
+;     debug_fail(Skip,[[n,[]],[Value1]])),!.
+
+interpretpart([],Variable1,Vars1,Vars2) :-
+        getvalue(Variable1,Value1,Vars1),
+        %%getvalue(Value1,Value1A,Vars1),
+	%%isvalstr(Value1),
+	%%isvalstr(Value1A),
+	isempty(Value1),
+        %%val1emptyorvalsequal(Value1,[]),
+	%%isval(Value2),
+debug_call(Skip,[[n,[]],[variable]]),
+(        putvalue(Variable1,[],Vars1,Vars2)->
+debug_exit(Skip,[[n,[]],[[]]])
+;     debug_fail(Skip,[[n,[]],[variable]])),!.
+		
+interpretpart("",Variable1,Vars1,Vars1) :-
+        getvalue(Variable1,Value1,Vars1),
+        %%getvalue(Value1,Value1A,Vars1),
+	%%isvalstr(Value1),
+	%%isvalstr(Value1A),
+	not(isempty(Value1)),
+	%%isempty(Value2),
+        %%val1emptyorvalsequal(Value2,Value1),
+	%%isval(Value2),
+debug_call(Skip,[[n,""],[Value1]]),
+(        Value1=""->
+debug_exit(Skip,[[n,""],[Value1]])
+;     debug_fail(Skip,[[n,""],[Value1]])),!.
+
+interpretpart("",Variable1,Vars1,Vars2) :-
+        getvalue(Variable1,Value1,Vars1),
+        %%getvalue(Value1,Value1A,Vars1),
+	%%isvalstr(Value1),
+	%%isvalstr(Value1A),
+	isempty(Value1),
+        %%val1emptyorvalsequal(Value1,""),
+	%%isval(Value2),
+debug_call(Skip,[[n,""],[variable]]),
+(        putvalue(Variable1,"",Vars1,Vars2)->
+debug_exit(Skip,[[n,""],[""]])
+;     debug_fail(Skip,[[n,""],[variable]])),!.
+		
+
+interpretpart("_",_,V,V) :- 
+debug_call(Skip,[[n,"_"],[variable]]),
+debug_exit(Skip,[[n,"_"],[variable]]),!.

Combination-Algorithm-Writer-Multiple-Predicates/rcaw.pl

@@ -0,0 +1,298 @@
+:- dynamic debug/1.
+
+caw00(Debug,PredicateName,Rules,MaxLength,TotalVars,_InputVarList,_OutputVarList,Program1,_Program2,Ps1) :-
+	repeat,
+	%%MaxLength2 is MaxLength + 1,
+	%%TotalVars = MaxLength,
+	randvars(MaxLength,MaxLength,[],RandVars),
+	populatevars(RandVars,MaxLength,[],PV),
+	Code is MaxLength + 1 + 97,
+	char_code(Char,Code),
+	OutputVarList=[[[v,Char],1]],
+	retractall(debug(_)),
+    	assertz(debug(Debug)),
+	retractall(totalvars(_)),
+    	assertz(totalvars(TotalVars)),
+	caw0(PredicateName,Rules,MaxLength,PV,OutputVarList,Program1,_Program3,Ps),
+	sort(Ps,Ps1),not(Ps1=[]),!.
+
+randvars(0,_,V,V) :- !.
+randvars(N,L,V1,V2) :-
+	random(N1), N2A is round(97+(N1*L)), char_code(V3,N2A), V31=[v,V3], ((member(V31,V1))->randvars(N,L,V1,V2);
+	(append(V1,[V31],V4),
+	NA is N-1, randvars(NA,L,V4,V2))),!.
+randvars2(0,_L,V,V) :- !.
+randvars2(N,L,V1,V2) :-
+	random(N1), N2A is round(97+(N1*L)), char_code(V3,N2A), atom_string(V3,V4), %%V41=[v,V4],
+	((member(V4,V1))->randvars2(N,L,V1,V2);
+	(append(V1,[V4],V5),
+	NA is N-1, randvars2(NA,L,V5,V2))),!.
+populatevars([],_,PV,PV) :- !.
+populatevars([RV1|RVs],MaxLength2,PV1,PV2) :-
+	randvars2(MaxLength2,MaxLength2,[],RV2),
+	append(PV1,[[RV1,RV2]],PV3),
+	populatevars(RVs,MaxLength2,PV3,PV2),!.
+
+caw0(PredicateName,Rules,MaxLength,InputVarList,OutputVarList,Program1,Program2,Ps2) :-
+	varnames(InputVarList,[],InputVars,[],InputValues),
+	varnames(OutputVarList,[],OutputVars,[],_OutputValues),
+	retractall(outputvars(_)),
+    	assertz(outputvars(OutputVars)),
+	append(InputVars,OutputVars,Vars11),
+	%%Vars11=InputVars,
+	%%Vars12=InputVars,
+	append(InputValues,OutputVars,Vars2),
+	%%append(InputValues,OutputValues,Values),
+	Query=[PredicateName,Vars2],
+	caw1(Query,PredicateName,Rules,MaxLength,Vars11,InputVars,InputVars,_,OutputVarList,OutputVars,Program1,Program2,[],Ps2), !.
+
+caw1(_,_,_,0,_,_,_,_,_,_,_,_,Ps,Ps) :- !.
+caw1(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program2,Programs2,Ps1) :-
+	MaxLength2 is MaxLength - 1,
+	addrules0(InputVars2,OutputVars,OutputVars,[],Program3),
+	%%writeln([addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3)]),	
+	%%optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program4), %% IV2->3
+	%%writeln([optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program4)]),
+	append(Program1,Program3,Program5),
+	append(InputVars1,OutputVars,Vars2),
+	Program2=[
+        [PredicateName,Vars2,":-",
+                Program5
+        ]
+        ],debug(Debug),
+
+        %%writeln([interpret(Debug,Query,Program2,OutputVarList2)]),
+
+	interpret(Debug,Query,Program2,OutputVarList2),
+        %%writeln([interpret(Debug,Query,Program2,OutputVarList2)]),
+	append(Programs2,[[Query,Program2,OutputVarList2]],Programs3),
+	caw1a(Query,PredicateName,Rules,MaxLength2,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,[],_Program2,Programs3,Ps1),!.
+
+%%caw1(_Query,_PredicateName,_Rules,_MaxLength,_VarList,_InputVars1,_InputVars2,_InputVars3,_OutputVarList,_OutputVars,_Program1,_Program4,Ps,Ps) :- writeln(here1),!.
+caw1(_Query,_PredicateName,_Rules,_MaxLength2,_VarList,_InputVars1,_InputVars2,_InputVars3,_OutputVarList,_OutputVars,[],_Program2,Programs3,Programs3) :- !.
+	%%writeln([here1,	caw1(Query,PredicateName,Rules,MaxLength2,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,[],_Program21,Programs3,Programs3)]),!.
+
+caw1a(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4,Ps1,Ps2) :-
+	
+	%%writeln([caw(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,OutputVarList,OutputVars,Program1,Program4)]),
+	%%MaxLength2 is MaxLength - 1,
+	%%writeln(["ml",MaxLength2]),
+	reverse(InputVars2,InputVars5),
+	random_member([RuleName,NumInputs,NumOutputs],Rules),
+	%%writeln([member([RuleName,NumInputs,NumOutputs],Rules)]),
+	%%writeln([rule(RuleName,NumInputs,NumOutputs,VarList,VarList2,Rule)]),
+	rule(RuleName,NumInputs,NumOutputs,InputVars5,InputVars4,VarList,VarList2,Rule),
+%%writeln([inputVars1,InputVars1]),
+%%	writeln([rule(RuleName,NumInputs,NumOutputs,InputVars5,InputVars4,VarList,VarList2,Rule)]),
+	append(Program1,[Rule],Program3),
+	%%writeln([inputVars3,InputVars3]),
+	%%InputVars2=InputVars3,
+	%%writeln([program4,Program4]),
+
+%%caw1a(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4,Ps,Ps) :-
+%%writeln([here,caw1a(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4,Ps,Ps)])
+
+
+caw(Query,PredicateName,Rules,MaxLength,VarList2,InputVars1,InputVars4,InputVars3,OutputVarList,OutputVars,Program3,Program4,Ps1,Ps2),!.
+
+
+caw(_,_,_,0,_,_,_,_,_,_,_,_,Ps,Ps) :- !.
+caw(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program2,Programs1,Programs2) :-
+	MaxLength2 is MaxLength - 1,
+	addrules(InputVars2,OutputVars,OutputVars,[],_PenultimateVars,[],Program3),
+	%%writeln([addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3)]),	
+	%%optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program4), %% IV2->3
+	%%writeln([optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program4)]),
+	append(Program1,Program3,Program5),
+	append(InputVars1,OutputVars,Vars2),
+	Program2=[
+        [PredicateName,Vars2,":-",
+                Program5
+        ]
+        ],debug(Debug),
+%%***
+%% () choose iv1 as args during caw, () eliminate e problem, could move forward in optimiser but don't need it v
+%% should have a leading edge of 1 immediately previous (new output) as an arg in latest rule v, go backwards to choose latest possible args x, 3 x rules can have same as previous rule's output as an output x: at a time
+%% chunks will solve having at least 1 rule that connects to last output
+%% can optimise number of inputs
+
+%% test member, = in caw
+
+	%%writeln([interpret(Debug,Query,Program2,OutputVarList2)]),
+
+	interpret(Debug,Query,Program2,OutputVarList2),
+	%%writeln([interpret(Debug,Query,Program2,OutputVarList2)]),
+	append(Programs1,[[Query,Program2,OutputVarList2]],Programs3),
+	cawa(Query,PredicateName,Rules,MaxLength2,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,[],_Program2,Programs3,Programs2),!.
+%%caw(_,_,_,_,_,_,_,_,_,_,_,_,Ps,Ps) :- !.
+
+caw(_Query,_PredicateName,_Rules,_MaxLength2,_VarList,_InputVars1,_InputVars2,_InputVars3,_OutputVarList,_OutputVars,[],_Program2,Programs3,Programs3) :-
+	%%writeln([here2,	caw(Query,PredicateName,Rules,MaxLength2,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,[],_Program21,Programs3,Programs3)]),
+	!.
+
+
+cawa(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4,Ps1,Ps2) :-
+	%%writeln([caw(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,OutputVarList,OutputVars,Program1,Program4)]),
+	%%MaxLength2 is MaxLength - 1,
+	%%writeln(["ml",MaxLength2]),
+	random_member([RuleName,NumInputs,NumOutputs],Rules),
+	%%writeln([member([RuleName,NumInputs,NumOutputs],Rules)]),
+	%%writeln([rule(RuleName,NumInputs,NumOutputs,VarList,VarList2,Rule)]),
+	rule(RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,Rule),
+%%writeln([inputVars1,InputVars1]),
+%%	writeln([rule(RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,Rule)]),
+	append(Program1,[Rule],Program3),
+	%%writeln([inputVars3,InputVars3]),
+	%%InputVars2=InputVars3,
+	%%writeln([program4,Program4]),
+caw(Query,PredicateName,Rules,MaxLength,VarList2,InputVars1,InputVars4,InputVars3,OutputVarList,OutputVars,Program3,Program4,Ps1,Ps2), !.
+
+varnames([],Vars,Vars,Values,Values) :- !.
+varnames(VarList,Vars1,Vars2,Values1,Values2) :-
+	VarList=[Var|Vars3],
+	Var=[VarName,Value],
+	append(Vars1,[VarName],Vars4),
+	append(Values1,[Value],Values3),
+	varnames(Vars3,Vars4,Vars2,Values3,Values2),!.
+
+addrules0(_,_,[],Program,Program) :- !.
+addrules0(VarList,OutputVars1,OutputVars2,Program1,Program2) :-
+	OutputVars2=[OutputVar|OutputVars3],
+	random_member(Var,VarList),
+	random_member(OutputVar,OutputVars1),
+	append(Program1,[[[n,=],[OutputVar,Var]]],Program3),
+	addrules0(VarList,OutputVars1,OutputVars3,Program3,Program2),!.
+
+addrules(_,_,[],PV,PV,Program,Program) :- !.
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+	restlast(VarList,[],_,Var),
+	%%OutputVars2=[OutputVar|OutputVars3],
+	random_member(OutputVar,OutputVars2),
+	delete(OutputVars1,OutputVar,OutputVars3),
+%%	member(Var,VarList),
+	random_member(OutputVar,OutputVars1),
+	append(Program1,[[[n,=],[OutputVar,Var]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars3),
+	addrules2(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2),!.
+
+addrules2(_,_,[],PV,PV,Program,Program) :- !.
+addrules2(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+%%	restlast(VarList,[],_,Var),
+	OutputVars2=[OutputVar|OutputVars3],
+	random_member(Var,VarList),
+	not(member(Var,PenultimateVars1)),
+	random_member(OutputVar,OutputVars1),
+	append(Program1,[[[n,=],[OutputVar,Var]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars3),
+	addrules2(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2),!.
+
+iv1flagdisjunction(A,B,true) :-
+	((A=true)->true; (B=true)),!.
+iv1flagdisjunction(_,_,false) :- !.
+
+
+restlast([],_,_,_) :- fail, !.	
+restlast([Last],Rest,Rest,Last) :-
+	Last=[v,_],!.
+restlast(Last,Rest,Rest,Last) :-
+	length(Last,1),!.
+restlast(Vars1,Rest1,Rest2,Last) :-
+	Vars1=[Var|Vars2],
+	append(Rest1,[Var],Rest3),
+	restlast(Vars2,Rest3,Rest2,Last),!.
+
+
+
+rule(RuleName,1,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+	random_member(Var,InputVars1),
+	rule2(RuleName,Var,VarList,VarList2,Rule,Var1),
+	restlast(InputVars1,[],_,Last), %% Last should be outputs - 2nd last rule?
+	(Var=Last->true;Last=Var1),
+	append(InputVars1,[Var1],InputVars2),!.
+rule(RuleName,1,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        random_member(Var,InputVars1),
+        rule3(RuleName,Var,VarList,VarList2,Rule,Var1,Var2),
+	restlast(InputVars1,[],_,Last),
+	(Var=Last->true;
+	(Last=Var1->true;Last=Var2)),
+	append(InputVars1,[Var1,Var2],InputVars2),!.
+rule(RuleName,2,0,InputVars,InputVars,VarList,VarList,Rule) :-
+%%writeln([rule(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule)]),
+        random_member(Var,InputVars),
+        random_member(Vara,InputVars),
+        rule6(RuleName,Var,Vara,_VarList,_VarList2,Rule),
+	restlast(InputVars,[],_,Last),
+%%writeln([last,Last]),
+	(Var=Last->true;Vara=Last),!.
+rule(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+%%writeln([rule(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule)]),
+        random_member(Var,InputVars1),
+        random_member(Vara,InputVars1),
+        rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1),
+	restlast(InputVars1,[],_,Last),
+%%writeln([last,Last]),
+	((Var=Last->true;Vara=Last)->true;
+	(Last=Var1)),
+%%writeln([var,Var,vara,Vara]),
+	append(InputVars1,[Var1],InputVars2),!.
+rule(RuleName,2,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        random_member(Var,InputVars),
+        random_member(Vara,InputVars),
+        rule5(RuleName,Var,Vara,VarList,VarList2,Rule,Var1,Var2),
+	restlast(InputVars1,[],_,Last),
+	((Var=Last->true;Vara=Last)->true;
+	(Last=Var1->true;Last=Var2)), %% make last var2, use different inputs from previous rule, make this line usea version of previous line as well (args from rule before that) - redo rules based on past programming
+	append(InputVars1,[Var1,Var2],InputVars2),!.
+
+
+rule2(RuleName,Var,VarList,VarList2,Rule,Var1) :-
+	var(VarList,Var1,VarList2),
+	Rule=[RuleName,[Var,Var1]],!.%%,
+	%%member(Var,!.
+
+rule3(RuleName,Var,VarList,VarList3,Rule,Var1,Var2) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Var1,Var2]],!.
+
+rule6(RuleName,Var,Vara,_VarList,_VarList2,Rule) :-
+        Rule=[RuleName,[Var,Vara]],!.
+
+rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1) :-
+        var(VarList,Var1,VarList2),
+        Rule=[RuleName,[Var,Vara,Var1]],!.
+
+%%ae be with predicate support also
+rule5(RuleName,Var,Vara,VarList,VarList3,Rule,Var1,Var2) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Vara,Var1,Var2]],!.
+
+%%var(Item,Var,Vars,Vars) :-
+%%	member([Item,Var],Vars).
+var(Vars1,Var1,Vars2) :-
+	length(Vars1,Vars1Length1),
+	Vars1Length2 is Vars1Length1-1,
+	length(Vars3,Vars1Length2),
+	append(Vars3,[Var2],Vars1),
+	Var2=[v,Var21],
+	char_code(Var21,Var2Code1),
+	Var2Code2 is Var2Code1 + 1,
+	var2(Var2Code2,Var1),
+	append(Vars1,[Var1],Vars2),!.
+
+var2(Code,Var1) :-
+	outputvars(OutputVars),
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Code =< Code2, %% 122
+	char_code(Var11,Code),
+	Var1=[v,Var11],
+	not(member(Var1,OutputVars)),!.
+var2(Var2Code,Code3) :-
+	Var2Code2 is Var2Code + 1,	
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Var2Code2 =< Code2,
+	var2(Var2Code2,Code31),
+	Code3=[v,Code31],!.

Combination-Algorithm-Writer-Multiple-Predicates/remove_duplicate_predicates.pl

@@ -0,0 +1,14 @@
+%% remove_duplicate_predicates
+
+%%remove_duplicate_predicates(Predicates1
+%%	Predicates1=[Predicate2|Predicates3],
+
+%% remvdup([a,a,a,b,b,c],[],A)
+%% A = [a, b, c].
+
+remvdup([],A,A):-!.
+remvdup(A,B,C):-
+	A=[A1|As],
+	delete(As,A1,B2),
+	append(B,[A1],D),
+	remvdup(B2,D,C).

Combination-Algorithm-Writer-Stable/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Lucian Green
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Combination-Algorithm-Writer-Stable/LPI CAW commands workaround.txt

@@ -0,0 +1,9 @@
+LPI CAW commands workaround for single argument commands not working, but no singletons working
+
+_A - enter value in header (one output, so is it, do outputs one at a time)
+
+[] and "" - enter [] or "" somewhere in header and use normal "="
+
+not - can still use except for [], "", etc., see previous line
+
+With no singletons working, CAWP is more stable than CAWMP

Combination-Algorithm-Writer-Stable/README.md

@@ -0,0 +1,71 @@
+# Combination-Algorithm-Writer-Stable
+Combination Algorithm Writer with Predicates Stable (CAWPS)
+
+Please note: This works with the example below, which the CAWMP repository doesn't.
+
+Combination Algorithm Writer is a SWI-Prolog algorithm that finds combinations of given commands that satisfy the given input and output.
+
+It verifies for no singletons.
+
+# Prerequisites
+
+* Please download and install SWI-Prolog for your machine at `https://www.swi-prolog.org/build/`.
+
+# 1. Install manually
+
+Download <a href="http://github.com/luciangreen/Combination-Algorithm-Writer-Stable/">this repository</a>.
+
+# 2. Or Install from List Prolog Package Manager (LPPM)
+
+* Download the <a href="https://github.com/luciangreen/List-Prolog-Package-Manager">LPPM Repository</a>:
+
+```
+mkdir GitHub
+cd GitHub/
+git clone https://github.com/luciangreen/List-Prolog-Package-Manager.git
+cd List-Prolog-Package-Manager
+swipl
+['lppm'].
+lppm_install("luciangreen","Combination-Algorithm-Writer-Stable").
+halt
+```
+
+# Running
+
+* In Shell:
+`cd Combination-Algorithm-Writer-Stable`
+`swipl`
+
+* Load all files in the form:
+```
+['lpi_caw_commands.pl'].
+['listprologinterpreter1listrecursion4copy52'].
+['listprologinterpreter3preds5copy52'].
+['caw5copy11'].
+```
+Running
+
+```
+caw00(off,f,[[+,2,1]],4,8,[[a,1],[b,1],[c,2],[d,1]],[[e,5]],[[[f1,4,1],[a,b,c,d,e],(:-),[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]]],[],P),writeln(P).
+
+[[f1,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]],[f,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,d,g]],[+,[f,g,h]],[=,[e,h]]]]]
+.
+.
+.
+```
+
+```
+caw00(off,reverse,[[head,1,1],[tail,1,1],[wrap,1,1],[append,2,1],[reverse,2,1]],6,8,[[a,[1,2,3]],[b,[]]],[[c,[3,2,1]]],[[[reverse,2,1],[[],a,a]]],[],P),writeln(P).
+
+not finished
+```
+
+Note: Use (:-) instead of :-.
+
+# CAWPS API
+
+* To run CAWPS on a Prolog server:
+* Move `cawps-api.pl` to the root (`/username/` or `~` on a server) of your machine.
+* Re-enter the paths to your Prolog files in it.
+* Enter `[cawps-api.pl]` in SWI-Prolog and `server(8000).`.
+* On a local host access the algorithm at `http://127.0.0.1:8000` and replace 127.0.0.1 with your server address on a server.

Combination-Algorithm-Writer-Stable/caw5copy11.pl

@@ -0,0 +1,386 @@
+:- dynamic debug/1.
+:- dynamic totalvars/1.
+:- dynamic outputvars/1.
+
+:- dynamic test/1.
+
+:-include('../listprologinterpreter/la_strings.pl').
+
+test1(A) :- test(B),A is B+1,retractall(test(_)),assertz(test(A)).
+
+caw00(Debug,PredicateName,Rules1,MaxLength,TotalVars,InputVarList,OutputVarList,Predicates1,Program1,Program2) :-
+	split3(Predicates1,[],Rules2),
+	split2(Predicates1,[],Predicates),
+	%%writeln([Rules2,Predicates]),
+	append(Rules1,Rules2,Rules3),
+
+	retractall(debug(_)),
+    	assertz(debug(Debug)),
+	retractall(totalvars(_)),
+    	assertz(totalvars(TotalVars)),
+
+	retractall(test(_)),
+    	assertz(test(0)),
+	caw0(Predicates,PredicateName,Rules3,MaxLength,InputVarList,OutputVarList,Program1,Program2).
+
+caw0(Predicates,PredicateName,Rules,MaxLength,InputVarList,OutputVarList,Program1,Program2) :-
+	varnames(InputVarList,[],InputVars,[],InputValues),
+	varnames(OutputVarList,[],OutputVars,[],_OutputValues),
+	retractall(outputvars(_)),
+    	assertz(outputvars(OutputVars)),
+append(InputVars,OutputVars,Vars11),
+%%Vars11=InputVars,
+%%Vars12=InputVars,
+	append(InputValues,OutputVars,Vars2),
+	%%append(InputValues,OutputValues,Values),
+	Query=[PredicateName,Vars2],
+	caw(Predicates,Query,PredicateName,Rules,MaxLength,Vars11,InputVars,InputVars,_,OutputVarList,OutputVars,Program1,Program2).
+caw(_,_,_,_,0,_,_,_,_,_,_,_) :- fail, !.
+caw(Predicates,Query,PredicateName,_,_,_VarList,InputVars1,InputVars2,_,OutputVarList,OutputVars,Program1,Program2) :-
+	addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3),
+%%writeln([addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3)]),	
+	%%optimise(Program1,InputVars1,InputVars3,PenultimateVars,Program4), %% IV2->3
+%%writeln([optimise(Program1,InputVars1,InputVars3,PenultimateVars,Program4)]),
+	append(Program1,Program3,Program5),
+	append(InputVars1,OutputVars,Vars2),
+	Program22=[
+        [PredicateName,Vars2,(:-),
+                Program5
+        ]
+        ],
+        
+        	append(Predicates,Program22,Program2),
+
+        (debug(on)->Debug=on;Debug=off),
+%writeln([interpret(Debug,Query,Program2,OutputVarList)]),
+%%writeln(""),
+%trace,
+
+	catch(call_with_time_limit(0.05, 
+		interpret(Debug,Query,Program2,OutputVarList)),
+      time_limit_exceeded,
+      fail),
+      %test1(A),writeln(A),
+	no_singletons(Vars2,Program5),!.
+caw(Predicates,Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4) :-
+%%writeln([caw(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,OutputVarList,OutputVars,Program1,Program4)]),
+	MaxLength2 is MaxLength - 1,
+%%writeln(["ml",MaxLength2]),
+	member([RuleName,NumInputs,NumOutputs],Rules),
+%%writeln([member([RuleName,NumInputs,NumOutputs],Rules)]),
+%%writeln([rule(RuleName,NumInputs,NumOutputs,VarList,VarList2,Rule)]),
+	rule(Program1,RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,Rule),
+%%writeln([rule(RuleName,NumInputs,NumOutputs,InputVars1,InputVars3,VarList,VarList2,Rule)]),
+	append(Program1,[Rule],Program3),
+%%writeln([inputVars3,InputVars3]),
+%%InputVars2=InputVars3,
+%%writeln([program4,Program4]),
+	caw(Predicates,Query,PredicateName,Rules,MaxLength2,VarList2,InputVars1,InputVars4,InputVars3,OutputVarList,OutputVars,Program3,Program4).
+
+varnames([],Vars,Vars,Values,Values) :- !.
+varnames(VarList,Vars1,Vars2,Values1,Values2) :-
+	VarList=[Var|Vars3],
+	Var=[VarName,Value],
+	append(Vars1,[VarName],Vars4),
+	append(Values1,[Value],Values3),
+	varnames(Vars3,Vars4,Vars2,Values3,Values2),!.
+
+addrules(_,_,[],PV,PV,Program,Program) :- !.
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+	OutputVars2=[OutputVar|OutputVars3],
+	member(Var,VarList),
+	member(OutputVar,OutputVars1),
+	append(Program1,[[=,[OutputVar,Var]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars3),
+	addrules(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2).
+
+%% optimise([[append,[a,a,d]],[append,[a,a,e]],[append,[a,a,f]],[append,[a,b,g]]],[g],P).
+
+optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program2) :-
+	findrulesflowingtopv1(Program1,InputVars1,InputVars2,PenultimateVars,[],Rules,true),
+	%%findrulesflowingtopv1a(Program1,_Program32,InputVars1,InputVars2,PenultimateVars,[],_Rules1),
+	intersection(Program1,Rules,Program3),
+	unique1(Program3,[],Program2).
+findrulesflowingtopv1(_,_,_,[],Rules,Rules,false).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	(atom(Var);length(Var,1)),
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars1,Rules1,Rules2,IV1Flag1) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2), 
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars2,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv20(_,[],_InputVars1,_InputVars2,_Var,Rules,Rules,false).
+findrulesflowingtopv20(Program0,Rules4,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rules4=[Rule|Rules],
+	(findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2)->true;(Rules3=Rules1,IV1Flag2=false)),
+	%%delete(Program0,Rule,Program1),
+	findrulesflowingtopv20(Program0,Rules,InputVars1,InputVars2,Var,Rules3,Rules2,IV1Flag3),%%p1->0
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+%%findrulesflowingtopv2(_,[],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	%%(not(intersection(Rulesx,Rules1))-> x
+	%% append, append, unique1
+	%%append(Rules1,[Rule],Rules3);Rules3=Rules1),
+
+	%%member(Var2,Rest),
+	%%member(Var2,InputVars1),
+
+	length(Rest,Length1), Length1>=1,
+	subtract(Rest,InputVars1,IV3s),
+	length(IV3s,Length3),
+	subtract(Rest,IV3s,IV1s),
+	length(IV1s,Length2), Length2>=1,
+	subtract(IV3s,InputVars2,[]),
+
+	IV1Flag2=true,
+
+	%%delete(Program0,Rule,Program1),
+
+	%%(delete(Program0,Rule,Program3),
+	%%iv3s1(IV3s,Program3,IV3s,[]),
+	(Length3>=1->
+	(findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV3s,[],Rules5,IV1Flag3),not(Rules5=[]));
+	(Rules5=[],IV1Flag3=false)),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag4),
+	%%->true; Rules5=[],IV1Flag1=IV1Flag4),
+	
+	((findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV1s,[],Rules6,IV1Flag5), %%iv1s->rest, etc
+	iv1flagdisjunction(IV1Flag4,IV1Flag5,IV1Flag1))->true;(Rules6=[],IV1Flag1=IV1Flag4)),
+
+	append([Rule],Rules1,Rules9),
+	append(Rules9,Rules5,Rules7),
+	append(Rules7,Rules6,Rules8),
+	unique1(Rules8,[],Rules2).
+
+/**
+findrulesflowingtopv2(_Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	(not(member(Rule,Rules1))->
+	append(Rules1,[Rule],Rules2);Rules2=Rules1),
+	subset(Rest,InputVars2),
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+	IV1Flag1=false.
+**/
+/**
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),	
+	%%delete(Program1,[PredicateName,Vars],Program3),
+	%%Program3=Program1,
+	%%append(Rules1,[Rule],Rules3),
+	subset(Rest,InputVars2),
+	
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+%%	delete(Program0,Rule,Program1),
+	IV1Flag2=false,
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Rest,[],Rules4,IV1Flag3),
+	%%not(Rules4=[]),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1),
+	append(Rules1,[Rule],Rules7),
+	append(Rules7,Rules4,Rules8),
+	unique1(Rules8,[],Rules2).
+**/
+/**
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2(Rule,Program0,Program1,_Program2,InputVars1,InputVars,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	%%Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1(Program0,Program1,_Program2,InputVars1,InputVars,Rest,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+**/
+iv1flagdisjunction(A,B,true) :-
+	(A=true); (B=true).
+iv1flagdisjunction(_,_,false).
+/**
+iv3s0([],_,IV3s1,IV3s2).
+iv3s0(IV3s,Program0,IV3s1,IV3s2).
+	IV3s=[IV3|IV3s3],
+	iv3s1(IV3,Program0,IV3s1,IV3s4),
+	iv3s0(IV3s3,Program0,IV3s4,IV3s2).
+iv3s1(_,[],IV3s,IV3s).	
+iv3s1(IV3,Program0,IV3s1,IV3s2) :-
+	Program0=[Rule|Rules],
+	iv3s2(IV3,Rule,IV3s1,IV3s3),
+	iv3s1(IV3,Rules,IV3s3,IV3s2).
+iv3s2(IV3,Rule,IV3s,IV3s1,IV3s2).
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],_Rest,IV3),	
+	delete(IV3s1,IV3,IV3s2).
+findrulesflowingtopv1a(_,_,_,_,[],Rules,Rules).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	atom(Var),
+	findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Vars1,Rules1,Rules2) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv2(Program1,Program3,InputVars1,InputVars2,Var,Rules1,Rules3),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Vars2,Rules3,Rules2).
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv2a([],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2a(Program1,Program2,_InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program2),
+Program2=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules2),
+	subset(Rest,InputVars2)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program3),
+Program3=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	subset(Rest,InputVars2)),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Rest,Rules3,Rules2).
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1a(Program4,Program2,InputVars1,InputVars,Rest,Rules3,Rules2).
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+	**/
+
+restlast([],_,_,_) :- fail, !.	
+restlast([Last],Rest,Rest,Last) :-
+	atom(Last),!.
+restlast(Last,Rest,Rest,Last) :-
+	length(Last,1),!.
+restlast(Vars1,Rest1,Rest2,Last) :-
+	Vars1=[Var|Vars2],
+	append(Rest1,[Var],Rest3),
+	restlast(Vars2,Rest3,Rest2,Last),!.
+
+	
+	rule(Predicates,RuleName,NumInputs,NumOutputs,InputVars20,InputVars4,VarList0,VarList2,Rule) :-
+	
+	%InputVars20=InputVars2,%
+	%VarList0=VarList,
+	%writeln(Predicates),
+	/*
+	%writeln([Predicates,Predicates]),
+	%(not(Predicates=[])->trace;true),
+findall(Rule_vars1,member([_Rule_name,Rule_vars1],Predicates),Rule_vars2),foldr(append,Rule_vars2,Rule_vars3),
+
+% count vars
+	sort(Rule_vars3,K),
+	findall(G,(member(G,K),findall(G,member(G,Rule_vars3),H),length(H,J),J>2),L),
+% remove vars occuring more than twice
+
+(var(InputVars20)->InputVars20=InputVars2;(%trace,
+subtract(InputVars20,L,InputVars2)%,notrace
+)),
+ 
+(var(VarList0)->VarList0=VarList;subtract(VarList0,L,VarList)),
+*/
+
+rule1(RuleName,NumInputs,NumOutputs,InputVars20,InputVars4,VarList0,VarList2,Rule).
+
+
+rule1(RuleName,1,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+	member(Var,InputVars1),
+	rule2(RuleName,Var,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule2(RuleName,Var,VarList,VarList2,Rule,Var1) :-
+	var(VarList,Var1,VarList2),
+	Rule=[RuleName,[Var,Var1]],!.
+
+rule1(RuleName,1,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        rule3(RuleName,Var,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule3(RuleName,Var,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Var1,Var2]],!.
+
+rule1(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        member(Vara,InputVars1),
+        rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1) :-
+        var(VarList,Var1,VarList2),
+        Rule=[RuleName,[Var,Vara,Var1]],!.
+
+rule1(RuleName,2,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars),
+        member(Vara,InputVars),
+        rule5(RuleName,Var,Vara,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule5(RuleName,Var,Vara,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Vara,Var1,Var2]],!.
+
+%%var(Item,Var,Vars,Vars) :-
+%%	member([Item,Var],Vars).
+var(Vars1,Var1,Vars2) :-
+	length(Vars1,Vars1Length1),
+	Vars1Length2 is Vars1Length1-1,
+	length(Vars3,Vars1Length2),
+	append(Vars3,[Var2],Vars1),
+	char_code(Var2,Var2Code1),
+	Var2Code2 is Var2Code1 + 1,
+	var2(Var2Code2,Var1),
+	append(Vars1,[Var1],Vars2),!.
+
+var2(Code,Var1) :-
+	outputvars(OutputVars),
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Code =< Code2, %% 122
+	char_code(Var1,Code),
+	not(member(Var1,OutputVars)),!.
+var2(Var2Code,Code3) :-
+	Var2Code2 is Var2Code + 1,	
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Var2Code2 =< Code2,
+	var2(Var2Code2,Code3),!.
+
+
+no_singletons(Vars1,Program):-
+	findall(DA,(member(C,Program),C=[_E,D],member(DA,D)),Vars2),
+	%%append_list(Vars2,Vars2A),
+	append(Vars1,Vars2,Vars3),
+	findall(Count1,(member(Item,Vars3),aggregate_all(count,(member(Item,Vars3)),Count1),
+	Count1=1),G),G=[].
+
+	split3([],List,List) :- !.
+split3(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[Name,In,Out]|_Rest],
+	append(List1,[[Name,In,Out]],List6),
+	split3(List4,List6,List2),!.
+	
+split2([],List,List) :- !.
+split2(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[Name,_In,_Out]|Rest],
+	append(List1,[[Name|Rest]],List6),
+	split2(List4,List6,List2),!.
+

Combination-Algorithm-Writer-Stable/cawplistprolog.pl

@@ -0,0 +1,5 @@
+:-include('lpi_caw_commands.pl').
+:-include('listprologinterpreter1listrecursion4copy52').
+:-include('listprologinterpreter3preds5copy52').
+:-include('caw5copy11').
+:-include('cawpverify.pl').

Combination-Algorithm-Writer-Stable/cawps-api.pl

@@ -0,0 +1,103 @@
+:- use_module(library(http/thread_httpd)).
+:- use_module(library(http/http_dispatch)).
+:- use_module(library(http/http_error)).
+:- use_module(library(http/html_write)).
+
+% we need this module from the HTTP client library for http_read_data
+:- use_module(library(http/http_client)).
+:- http_handler('/', web_form, []).
+
+:- include('files/Combination-Algorithm-Writer-Stable/listprologinterpreter1listrecursion4copy52.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/listprologinterpreter3preds5copy52.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/caw5copy11.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/lpi_caw_commands.pl').
+
+server(Port) :-
+        http_server(http_dispatch, [port(Port)]).
+
+	/*
+	browse http://127.0.0.1:8000/
+	This demonstrates handling POST requests
+	   */
+
+	   web_form(_Request) :-
+	   	reply_html_page(include('Combination Algorithm Writer Stable'),
+	   	
+			    	    [
+				    	     form([action='/landing', method='POST'], [
+				    	     /**
+					     		p([], [
+									  label([for=debug],'Debug (on/off):'),
+									  		  input([name=debug, type=textarea])
+											  		      ]),
+											  		      **/
+													      		p([], [
+																	  label([for=predicatename],'Predicate Name (e.g. f):'),
+																	  		  input([name=predicatename, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=rules],'Rules to choose from (e.g. [[+,2,1]]):'),
+																	  		  input([name=rules, type=textarea])
+																			  		      ]),
+
+															      		p([], [
+																	  label([for=maxlength],'Max Length of Algorithm Body (e.g. 4):'),
+																	  		  input([name=maxlength, type=textarea])
+																			  		      ]),
+
+																				      		p([], [
+																	  label([for=totalvars],'Total Vars in Predicate (e.g. 8):'),
+																	  		  input([name=totalvars, type=textarea])
+																			  		      ]),
+													      		p([], [
+																	  label([for=inputvarlist],'InputVarList (e.g. [[a,1],[b,1],[c,2],[d,1]]):'),
+																	  		  input([name=inputvarlist, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=outputvarlist],'OutputVarList (e.g. [[e,5]]):'),
+																	  		  input([name=outputvarlist, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=algorithmlibrary],'Algorithm Library (e.g. [[[f1,4,1],[a,b,c,d,e],(:-),[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]]], where 4 is the number of inputs and 1 is the number of outputs):'),
+																	  		  input([name=algorithmlibrary, type=textarea])
+																			  		      ]),
+
+												      		p([], input([name=submit, type=submit, value='Submit'], []))
+																								      ])]).
+
+																								      :- http_handler('/landing', landing_pad, []).
+
+																								      landing_pad(Request) :-
+																								              member(method(post), Request), !,
+																									              http_read_data(Request, Data, []),
+																										              format('Content-type: text/html~n~n', []),
+																											      	format('<p>', []),
+																												        %%portray_clause(Data),
+																												        
+																												        %%term_to_atom(Term,Data),
+									
+										   	%% Predicatename,Rules,Maxlength,Totalvars,Inputvarlist,Outputvarlist,Algorithmlibrary
+																															%%portray_clause(Data),
+			
+															        
+Data=[%%debug='off',%%Debug1,
+predicatename=Predicatename,rules=Rules,maxlength=Maxlength,totalvars=Totalvars,inputvarlist=Inputvarlist,outputvarlist=Outputvarlist,algorithmlibrary=Algorithmlibrary,submit=_],
+
+term_to_atom(Debug1,'off'),
+term_to_atom(Predicatename1,Predicatename),
+term_to_atom(Rules1,Rules),
+term_to_atom(Maxlength1,Maxlength),
+term_to_atom(Totalvars1,Totalvars),
+term_to_atom(Inputvarlist1,Inputvarlist),
+term_to_atom(Outputvarlist1,Outputvarlist),
+term_to_atom(Algorithmlibrary1,Algorithmlibrary),
+
+caw00(Debug1,Predicatename1,Rules1,Maxlength1,Totalvars1,Inputvarlist1,Outputvarlist1,Algorithmlibrary1,[],Result),
+																														%%format('</p><p>========~n', []),
+																															portray_clause(Result),
+																																																															%%writeln1(Data),
+
+format('</p>').

Combination-Algorithm-Writer-Stable/cawpverify.pl

@@ -0,0 +1,51 @@
+%% cawptest(Debug[on/off],Total,Score).
+
+cawptest(Debug,NTotal,Score) :- cawptest(Debug,0,NTotal,0,Score),!.
+cawptest(_Debug,NTotal,NTotal,Score,Score) :- NTotal=1, !.
+cawptest(Debug,NTotal1,NTotal2,Score1,Score2) :-
+	NTotal3 is NTotal1+1,
+	cawptest2(NTotal3,Function,Rules,MaxLength,TotalVars,Specifications,AlgDict,Program1),
+	
+	%%writeln([cawptest2(NTotal3,Specifications,Program1)]),
+	(((%%writeln(caw00(Debug,function0,[],5,TotalVars,Specifications,[],Program1)),
+	caw00(Debug,Function,Rules,MaxLength,TotalVars,Specifications,AlgDict,[],Program1)
+	
+	%%sort(Program1,ProgramA),
+	%%sort(Program2,ProgramA)
+	%%writeln1(Program1),writeln1(Program2)
+	%%Program1=Program2
+	))->(Score3 is Score1+1,writeln([cawptest,NTotal3,passed]));(Score3=Score1,writeln([cawptest,NTotal3,failed]))),
+	writeln(""),
+	cawptest(Debug,NTotal3,NTotal2,Score3,Score2),!.
+
+%% Test individual cases, Debug=trace=on or off, N=case number, Passed=output=result
+
+cawptest1(Debug,N,Passed) :-
+	cawptest2(N,Function,Rules,MaxLength,TotalVars,InputVarList,OutputVarList,AlgDict,Program1),
+	%%writeln1([cawptest2(N,Specifications,Program1)]),
+	%%writeln1(caw00(Debug,Function,Rules,MaxLength,MaxPredicates,TotalVars,Numinputs, Numoutputs,Specifications,AlgDict,[],Program2)),
+
+	(((caw00(Debug,Function,Rules,MaxLength,TotalVars,InputVarList,OutputVarList,AlgDict,[],Program2),
+	%%sort(Program1,ProgramA),
+	%%sort(Program2,ProgramA)
+trace,
+	writeln(Program1),
+	writeln(Program2),Program1=Program2
+	))->(Passed=passed,writeln([cawptest,N,passed]));(Passed=failed,writeln([cawptest,N,failed]))),!.
+
+% ["Mind Reading","mr for time travel 3.txt",0,algorithms,"34. I mind read the correct universe containing all my collections of areas of study, then time travelled to it."]
+
+% The area of study was +++.
+
+cawptest2(1,f,[[+,2,1%% Modes=2 inputs, 1 output
+]],4,
+8,
+    [[a,1],[b,1],[c,2],[d,1]],[[e,5]]
+,
+[
+%[[f1,4,1],[a,b,c,d,e],(:-),[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]]
+], %% Algorithm dictionary
+ %% Result
+        %[f1,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]],
+[[f,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,d,g]],[+,[f,g,h]],[=,[e,h]]]]]
+).

Combination-Algorithm-Writer-Stable/listprologinterpreter1listrecursion4copy52.pl

@@ -0,0 +1,584 @@
+/**:- include('listprologinterpreter3preds5.pl').
+:- include('lpiverify4.pl').
+:- include('caw5 copy 11.pl').
+**/
+:- dynamic debug/1.
+
+/** List Prolog Interpreter **/
+
+interpret(Debug,Query,Functions,Result) :-
+%%writeln([i1]),
+	interpret1(Debug,Query,Functions,Functions,Result),
+	!.
+interpret1(Debug,Query,Functions1,Functions2,Result) :-
+%%writeln([i11]),
+	retractall(debug(_)),
+    	assertz(debug(Debug)),
+        retractall(cut(_)),
+        assertz(cut(off)),
+	member1(Query,Functions1,Functions2,Result).
+%%member1([_,R],_,[],R).
+%%member1(_,_,[],[]).
+member1(_,_,[],_) :- fail.
+member1(Query,Functions,Functions2,Vars8) :-
+%%writeln([m1]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+	(Functions2=[[Function,Arguments2,(:-),Body]|_Functions3]),
+	length(Arguments1,Length),
+	length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!, %%->ca2 
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+                (debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	interpretbody(Functions,Functions2,Vars1,Vars2,Body,true),
+	updatevars(FirstArgs,Vars2,[],Result),
+        %%reverse(Result,[],Vars7),
+	((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+%%writeln(["FirstArgs",FirstArgs,"Vars",Vars2,"Result",Result,"Vars7",Vars7,"Vars72",Vars72,"Var71",Var71,"Vars8",Vars8]),
+%%writeln(["Vars8",Vars8]),
+	findresult3(Arguments1,Vars8,[],Result2)
+%%writeln([findresult3,"Arguments1",Arguments1,"Vars8",Vars8,"Result2",Result2])
+	);(
+%%writeln(here1),
+	Vars8=[],Result2=[])),
+%%writeln(["Arguments1",Arguments1,"Vars2",Vars2,"Result",Result]),
+		(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true))
+	->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2,(:-),_Body]|Functions3], %% make like previous trunk?
+	member11(Query,Functions,Functions2,Vars8))
+	);(turncut(off)%%,Result=[]
+	).
+member11(Query,Functions,Functions2,Result) :-
+%%writeln([m11]),
+%%writeln(["Query",Query,"Functions",Functions,"Functions2",Functions2,"Result",Result]),
+	cut(off)->(
+        (Query=[Function],
+        (Functions2=[[Function,(:-),Body]|_Functions3]),
+                (debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Result=[],
+        interpretbody(Functions,Functions2,[],_Vars2,Body,true),!,
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	%%Functions2=[[Function]|Functions3],
+	member12(Query,Functions,Functions2,Result))
+	);(turncut(off)).
+member12(Query,Functions,Functions2,Vars8) :-
+%%writeln([m12]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!, %% ->ca2
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+	updatevars(FirstArgs,Vars1,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+        );(
+%%writeln(here2),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2]|Functions3],
+	member13(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member13(Query,Functions,Functions2,Result) :-
+%%writeln([m13]),
+	cut(off)->(
+        (Query=[Function],!,
+        (Functions2=[[Function]|_Functions3]),
+        	(debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Result=[],
+        %%interpretbody(Functions,[],_Vars2,Body,true),
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	Functions2=[_Function|Functions3],
+	member1(Query,Functions,Functions3,Result))
+	);(turncut(off)).
+interpret2(Query,Functions1,Functions2,Result) :-
+%%writeln(i2),
+%%writeln(["%%interpret2 Query",Query,"Functions1",Functions1,"Functions2",Functions2]),
+        member2(Query,Functions1,Functions2,Result).
+%%member2([_,R],_,[],R).
+%%member2(_,_,[],[]).
+member2(_,_,[],_) :- fail.
+member2(Query,Functions,Functions2,Vars8) :-
+%%writeln([m2]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2,(:-),Body]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!,
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+                (debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        interpretbody(Functions,Functions2,Vars1,Vars2,Body,true), %%**arg2 change
+%%writeln(["Functions",Functions,"Functions2",Functions2,"Vars1",Vars1,"Vars2",Vars2,"Body",Body]),
+        updatevars(FirstArgs,Vars2,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+%%writeln(["Vars2",Vars2,"Result",Result]),
+        );(
+	writeln(here3),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2,(:-),_Body]|Functions3],
+	member21(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member21(Query,Functions,Functions2,Result) :-
+%%writeln([m21]),
+	cut(off)->(
+        (Query=[Function],
+        (Functions2=[[Function,(:-),Body]|_Functions3]),
+        Vars1=[],
+                (debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        interpretbody(Functions,Functions2,Vars1,_Vars2,Body,true),!, %%**arg2 change
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	%%Functions2=[[Function]|Functions3],
+	member22(Query,Functions,Functions2,Result))
+	);(turncut(off)).
+member22(Query,Functions,Functions2,Vars8) :-
+%%writeln([m22]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!,
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+        updatevars(FirstArgs,Vars1,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+        );(
+%%writeln(here4),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2]|Functions3],
+	member23(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member23(Query,Functions,Functions2,Vars8) :-
+%%writeln([m23]),
+	cut(off)->(
+        (Query=[Function],!,
+        (Functions2=[[Function]|_Functions3]),
+        	(debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Vars8=[],
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	Functions2=[_Function|Functions3],
+	member2(Query,Functions,Functions3,Vars8))
+	);(turncut(off)).
+checkarguments([],[],Vars,Vars,FirstArgs,FirstArgs). 
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%
+%%writeln(1),
+	Arguments1=[Value|Arguments3], %% Value may be a number, string, list or tree
+	expressionnotatom(Value),
+	Arguments2=[Variable2|Arguments4],
+	isvar(Variable2),
+	putvalue(Variable2,Value,Vars1,Vars3),
+	checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs1,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%A
+%%writeln(2),
+        Arguments1=[Variable|Arguments3], %% Value may be a number, string, list or tree
+        isvar(Variable),
+        Arguments2=[Value|Arguments4],
+        expressionnotatom(Value),
+        putvalue(Variable,Value,Vars1,Vars3),
+	append(FirstArgs1,[[Variable,_]],FirstArgs3),
+        checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
+%%writeln(3),
+        Arguments1=[Variable1|Arguments3],
+	isvar(Variable1),
+        Arguments2=[Variable2|Arguments4],
+	isvar(Variable2),
+	(getvalue(Variable2,Value,Vars1)->true;Value=empty),
+        putvalue(Variable2,Value,Vars1,Vars3),
+        append(FirstArgs1,[[Variable1,Variable2]],FirstArgs3),
+        checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
+%%writeln(4),
+        Arguments1=[Value1|Arguments3],
+        expressionnotatom(Value1),
+        Arguments2=[Value1|Arguments4],
+        expressionnotatom(Value1),
+        checkarguments(Arguments3,Arguments4,Vars1,Vars2,FirstArgs1,FirstArgs2).
+
+interpretbody(_Functions1,_Functions2,Vars,Vars,[],true) :- !.
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[Statements1|Statements2],
+        interpretbody(Functions0,Functions,Vars1,Vars3,Statements1,Result2),
+        interpretbody(Functions0,Functions,Vars3,Vars2,Statements2,Result3),
+        %%((Result3=cut)->!;true),
+        logicalconjunction(Result1,Result2,Result3),!.
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[[not,[Statements]]|Statements2],
+	interpretbody(Functions0,Functions,Vars1,Vars3,Statements,Result2),
+        %%((Result2=cut)->!;true),
+        interpretbody(Functions0,Functions,Vars3,Vars2,Statements2,Result3),
+        %%((Result3=cut)->!;true),
+        logicalnot(Result2,Result4),
+	(logicalconjunction(Result1,Result4,Result3)->true;(Result1=false)),!.
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[[Statements1],or,[Statements2]],
+        (interpretbody(Functions0,Functions,Vars1,Vars2,Statements1,Result1);
+	%%,((Value1=cut)->!;true));
+        interpretbody(Functions0,Functions,Vars1,Vars2,Statements2,Result1)),!.
+	%%,((Value=cut)->!;true)).
+	%%(logicaldisjunction(Result1,Value1,Value2)->true;(Result1=false)).
+
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+	Body=[Statement|Statements],
+%%writeln(["Functions0",Functions0,"Functions",Functions,"Statement",Statement,"Vars1",Vars1,"Vars3",Vars3,"Result2",Result2,"Cut",Cut]),
+	interpretstatement1(Functions0,Functions,Statement,Vars1,Vars3,Result2,Cut),
+%%writeln(["here1"]),
+	((not(Cut=cut))->(Functions2=Functions);(turncut(on))), %% cut to interpret1/2 (assertz)
+%%writeln(["here3"]),
+	interpretbody(Functions0,Functions2,Vars3,Vars2,Statements,Result3),
+	%%((Result3=cut)->!;true),
+%%writeln(["here4"]),
+	logicalconjunction(Result1,Result2,Result3),!.
+%%writeln([Result1,Result2,Result3]).
+turncut(State1) :-
+	cut(State2),
+	retract(cut(State2)),
+	assertz(cut(State1)).
+logicaldisjunction(true,Result2,Result3) :-
+        true(Result2);true(Result3).
+logicalconjunction(true,Result2,Result3) :-
+	true(Result2),true(Result3).
+logicalnot(Result1,Result2) :-
+	true(Result1),false(Result2).
+logicalnot(Result1,Result2) :-
+        false(Result1),true(Result2).
+true(true).
+false(false).
+
+%%interpretstatement1(_F0,[],_,Vars,Vars,true,nocut) :- !
+%%writeln("AND HERE!")
+%%	.
+
+interpretstatement1(_F0,_Functions,[cut,[]],Vars,Vars,true,cut) :- !.
+
+interpretstatement1(_F0,_Functions,[atom,[Variable]],Vars,Vars,true,nocut) :-
+	getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[atom,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	atom(Value),
+                (debug(on)->(writeln([exit,[atom,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[string,[Variable]],Vars,Vars,true,nocut) :-
+        getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[string,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        string(Value),
+                (debug(on)->(writeln([exit,[string,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[number,[Variable]],Vars,Vars,true,nocut) :-
+        getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[number,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        number(Value),
+                (debug(on)->(writeln([exit,[number,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[variable,[Variable]],Vars,Vars,true,nocut) :-
+        var(Variable),
+                (debug(on)->(writeln([call,[variable,[Variable]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+                (debug(on)->(writeln([exit,[variable,[Variable]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[Operator,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	isop(Operator),
+	interpretpart(is,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[Operator,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(31),
+        isop(Operator),
+        interpretpart(is,Variable2,Variable1,Vars1,Vars2).
+	
+interpretstatement1(_F0,_Functions,[+,[Variable2,Variable3,Variable1]],Vars1,Vars2,true,nocut) :-
+%%writeln(4),
+        interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+%%interpretstatement1(_F0,_Functions,[Variable2+Variable3,is,Variable1],Vars1,Vars2,true,nocut) :-
+%%writeln(41),
+        %%interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[Variable1,[Variable2,Variable3]]],Vars1,Vars2,true,nocut) :-
+%%writeln(5),
+        interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+%%interpretstatement1(_F0,_Functions,[[Variable2,Variable3]=Variable1],Vars1,Vars2,true,nocut) :-
+%%writeln(51),
+%%        interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[Variable1,[Variable2]]],Vars1,Vars2,true,nocut) :-
+%%writeln(52),
+        interpretpart(bracket1,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[[Variable1],[Variable2]]],Vars1,Vars2,true,nocut) :-
+%%writeln(53),
+        interpretpart(bracket2,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[head,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(6),
+        interpretpart(head,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[tail,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(61),
+        interpretpart(tail,Variable1,Variable2,Vars1,Vars2).
+
+
+interpretstatement1(_F0,_Functions,[member,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(8),
+        interpretpart(member,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[delete,[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+%%writeln(),
+        interpretpart(delete,Variable1,Variable2,Variable3,Vars1,Vars2).
+%%** all in form f,[1,1,etc], including + with 0,1
+
+
+interpretstatement1(_F0,_Functions,[wrap,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln1(52), wrap
+%%writeln([[n,wrap],[Variable1,Variable2]]),
+        interpretpart(bracket1,Variable1,Variable2,Vars1,Vars2).
+
+
+
+interpretstatement1(_F0,_Functions,[append,[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+%%writeln(9),
+        interpretpart(append,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
+%%writeln("h1/10"),
+        Query1=[Function,Arguments],
+%%writeln(["Arguments",Arguments,"Vars1",Vars1]),
+        substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
+%%writeln([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
+        Query2=[Function,Vars3], %% Bodyvars2?
+%%        	debug(on)->writeln([call,[Function,[Vars3]]]),
+%%writeln(["Query2",Query2,"Functions0",Functions0]),
+        interpret2(Query2,Functions0,Functions0,Result1), 
+	updatevars2(FirstArgs,Result1,[],Vars5),
+	updatevars3(Vars1,Vars5,Vars6),
+	reverse(Vars6,[],Vars7),
+	((not(Vars7=[])->
+	%%Vars7=[Var71|Vars72],
+	unique1(Vars7,[],Vars8)
+);(
+writeln(here1),
+	Vars8=[])).
+%%**** reverse and take first instance of each variable.
+	%%findresult3(Arguments,Vars6,[],Result2)
+%%writeln(["FirstArgs",FirstArgs,"Result1",Result1,"Vars5",Vars5,"Vars4",Vars4]),
+%%writeln(["Vars1:",Vars1,"Vars4:",Vars4]),
+%%		debug(on)->writeln([exit,[Function,[Result2]]]).
+interpretstatement1(Functions0,_Functions,Query,Vars,Vars,true) :-
+	Query=[_Function],
+        	debug(on)->writeln([call,[Function]]),
+        interpret2(Query,Functions0,Functions0,_Result1),
+        	debug(on)->writeln([exit,[Function]]).
+
+
+interpretstatement1(_Functions0, _Functions,_Query,_Vars1,_Vars2,false) :-
+	writeln([false]).
+
+interpretstatement2(Value,_Vars,Value) :-
+	(number(Value);atom(Value)).
+interpretstatement2(Variable,Vars1,Value) :-
+	getvalue(Variable,Value,Vars1).
+interpretstatement3(A + B,Vars,Value1) :-
+        interpretstatement2(A,Vars,Value2),
+        interpretstatement2(B,Vars,Value3),
+        Value1 = Value2 + Value3.
+interpretstatement3(Value,_Vars,Value) :-
+	(number(Value);atom(Value)).
+interpretstatement3(Variable,Vars,Value) :-
+        getvalue(Variable,Value,Vars).
+getvalue(Variable,Value,Vars) :-
+        ((not(isvar(Variable)),isvalstrorundef(Value),Variable=Value);
+        (isvar(Variable),isvalstrorundef(Value),getvar(Variable,Value,Vars))).
+putvalue(Variable,Value,Vars1,Vars2) :-
+        ((not(isvar(Variable)),isvalstrorundef(Value),Variable=Value);
+        (isvar(Variable),isvalstrorundef(Value),updatevar(Variable,Value,Vars1,Vars2))),!. 
+getvar(Variable,Value,Vars) :-
+        member([Variable,Value],Vars),
+	not(Value=empty).
+getvar(undef,undef,_Vars) :-
+	!.
+getvar(Variable,empty,Vars) :-
+        not(member([Variable,_Value],Vars));
+	member([Variable,empty],Vars).
+updatevar(undef,_Value,Vars,Vars) :-
+	!.
+updatevar(Variable,Value,Vars1,Vars2) :-
+	((((member([Variable,empty],Vars1),
+	delete(Vars1,[Variable,empty],Vars3),
+	append(Vars3,[[Variable,Value]],Vars2));
+	((not(member([Variable,Value1],Vars1)),
+	((Value1=empty)->true;(Value1=Value)))),
+        append(Vars1,[[Variable,Value]],Vars2));
+	(member([Variable,Value],Vars1),Vars2=Vars1));
+	(undef(Variable),
+	append(Vars1,[[Variable,Value]],Vars2))).
+updatevars(_FirstArgs,[],Vars,Vars).
+updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
+        Vars1=[[Variable1,Value]|Vars4],
+	((member([Variable2,Variable1],FirstArgs), %% removed brackets around firstargs here and 2 line below
+	append(Vars2,[[Variable2,Value]],Vars5));
+	(member([Variable1,_Variable2],FirstArgs),
+	append(Vars2,[[Variable1,Value]],Vars5))),
+	updatevars(FirstArgs,Vars4,Vars5,Vars3),
+	!.
+updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
+	Vars1=[_Vars4|Vars5],
+	updatevars(FirstArgs,Vars5,Vars2,Vars3).
+updatevars2(_FirstArgs,[],Vars,Vars).
+updatevars2(FirstArgs,Vars1,Vars2,Vars3) :-
+        Vars1=[[Variable,Value]|Vars4],
+        (member(Variable,FirstArgs), %% removed brackets around firstargs here and 2 line below, ** vars1 into arg in (10), check cond
+        append(Vars2,[[Variable,Value]],Vars5)),
+        updatevars2(FirstArgs,Vars4,Vars5,Vars3).
+updatevars3(Vars1,[],Vars1).
+updatevars3(Vars1,Vars2,Vars4) :-
+	Vars2=[[Variable,Value]|Vars5],
+	delete(Vars1,[Variable,empty],Vars6),
+	append(Vars6,[[Variable,Value]],Vars7),
+	updatevars3(Vars7,Vars5,Vars4),
+	!.
+updatevars3(Vars1,Vars2,Vars4) :-
+	Vars2=[[Variable,Value]|Vars5],
+	append(Vars1,[[Variable,Value]],Vars6),
+        updatevars3(Vars6,Vars5,Vars4).
+reverse([],List,List).
+reverse(List1,List2,List3) :-
+	List1=[Head|Tail],
+	append([Head],List2,List4),
+	reverse(Tail,List4,List3).
+unique1([],Items,Items).
+unique1([Item|Items1],Items2,Items3) :-
+	delete(Items1,Item,Items4),
+	append(Items2,[Item],Items5),
+	unique1(Items4,Items5,Items3).
+
+isvar(Variable) :-
+	atom(Variable).
+isval(Value) :-
+	number(Value).
+isvalstr(N) :-
+	isval(N);string(N).
+/**isvalstrempty(N) :-
+	isval(N);(string(N);N=empty).**/
+isvalstrempty(N) :-
+	isval(N),!.
+isvalstrempty(N) :-
+	string(N),!.
+isvalstrempty(empty) :- !.
+/**isvalstrempty(N) :-
+	atom(N),fail,!.
+**/
+isvalstrorundef(N) :- 
+	var(N);(not(var(N)),(isval(N);expression(N))).
+undef(N) :-
+	var(N).
+/**
+expression(N) :-
+	isval(N);(string(N);atom(N)),!.
+expression([]).
+expression(empty).
+expression([N]) :-
+	expression(N).
+expression([N|Ns]):-
+	expression(N),expression(Ns).
+**/
+
+expression(empty) :-
+	!.
+expression(N) :-
+	isval(N),!.
+expression(N) :-
+	string(N),!.
+expression(N) :-
+	atom(N),!.
+expression([]) :-
+	!.
+expression(N) :-
+%%	not(atom(N)),
+	length(N,L),L>=2,
+	expression2(N).
+expression2([]).
+expression2([N|Ns]) :-
+	expression3(N),
+	expression2(Ns).
+expression3(N) :-
+	isval(N),!.
+expression3(N) :-
+	string(N),!.
+expression3(N) :-
+	atom(N),!.
+
+expressionnotatom(N) :-
+	isvalstrempty(N),!.
+expressionnotatom(N) :-
+	not(atom(N)),
+	length(N,L),L>=2,
+	expressionnotatom2(N).
+expressionnotatom2([]).
+expressionnotatom2([N|Ns]) :-
+	isvalstrempty(N),	
+	expressionnotatom2(Ns).
+
+substitutevarsA1(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
+	substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2).
+substitutevarsA2([],_Vars1,Vars2,Vars2,FirstArgs,FirstArgs).
+substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
+	Arguments=[Variable|Variables],
+	((getvalue(Variable,Value,Vars1),
+	Value=empty)->
+	((append(Vars2,[Variable],Vars4)),
+	(isvar(Variable)->append(FirstArgs1,[Variable],
+	FirstArgs3);FirstArgs3=FirstArgs1));
+	(getvalue(Variable,Value,Vars1),
+	append(Vars2,[Value],Vars4)),
+	FirstArgs3=FirstArgs1),
+        substitutevarsA2(Variables,Vars1,Vars4,Vars3,FirstArgs3,FirstArgs2).
+
+findresult3([],_Result,Result2,Result2).
+findresult3(Arguments1,Result1,Result2,Result3) :-
+	Arguments1=[Value|Arguments2],
+	expressionnotatom(Value),
+	append(Result2,[Value],Result4),
+        findresult3(Arguments2,Result1,Result4,Result3).
+findresult3(Arguments1,Result1,Result2,Result3) :-
+        Arguments1=[Variable|Arguments2],
+        isvar(Variable),
+	member([Variable,Value],Result1),
+        append(Result2,[Value],Result4),
+        findresult3(Arguments2,Result1,Result4,Result3).
+
+
+

Combination-Algorithm-Writer-Stable/listprologinterpreter3preds5copy52.pl

@@ -0,0 +1,118 @@
+interpretpart(is,Variable1,Value1,Vars1,Vars2) :-
+        getvalue(Value1,Value1A,Vars1),
+	%%isvalstr(Value1),
+	%%isvalstr(Value1A),
+	expression(Value1A),
+        %%val1emptyorvalsequal(Value1A,Value1),
+	%%isval(Value2),
+        putvalue(Variable1,Value1A,Vars1,Vars2),
+		(debug(on)->(writeln([call,[variable,is,Value1A],"Press c."]),(not(get_single_char(97))->true;abort));true),
+		(debug(on)->(writeln([exit,[Variable1,is,Value1A],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        Value1A is Value2 + Value3,
+        val1emptyorvalsequal(Value1,Value1A),
+        putvalue(Variable1,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[variable,is,Value2+Value3],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Value1A,is,Value2+Value3],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        Value1 = [Value2A, Value3A],
+        val1emptyorvalsequal(Value2,Value2A),
+        val1emptyorvalsequal(Value3,Value3A),
+        putvalue(Variable2,Value2A,Vars1,Vars3),
+        putvalue(Variable3,Value3A,Vars3,Vars2),
+        	(debug(on)->(writeln([call,[[Value2A, Value3A],=,[variable1,variable2]],"Press c."]),(not(get_single_char(97))->true;abort));true),        		(debug(on)->(writeln([exit,[[Value2A, Value3A],=,[Value2A, Value3A]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        Value1A = [Value2, Value3],
+        val1emptyorvalsequal(Value1,Value1A),
+        putvalue(Variable1,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[variable,=,[Value2,Value3]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[[Value2,Value3],=,[Value2,Value3]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(bracket1,Variable1,Variable2,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+	Value1A = [Value2],
+        val1emptyorvalsequal(Value1,Value1A),
+        %%val1emptyorvalsequal(Value1A,Value2),
+        putvalue(Variable1,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[variable,=,[Value2]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Variable2,=,[Value2]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(bracket2,Variable1,Variable2,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        Value1A = Value2,
+        val1emptyorvalsequal(Value1,Value1A),
+        %%val1emptyorvalsequal(Value2A,Value1),
+        putvalue(Variable1,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[[variable],=,[Value2]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[[Value2],=,[Value2]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(head,Variable1,Variable2,Vars1,Vars2) :-
+	getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+	Value1=[Value1A|_Rest],
+        val1emptyorvalsequal(Value2,Value1A),
+        putvalue(Variable2,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[head,Value1,variable],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[head,Value1,Value1A],"Press c."]),(not(get_single_char(97))->true;abort));true),	!.
+interpretpart(tail,Variable1,Variable2,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        Value1=[_Head|Value1A],
+	%%removebrackets(Value1A,Value1B), 
+        val1emptyorvalsequal(Value2,Value1A),
+        putvalue(Variable2,Value1A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[tail,Value1,variable],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[tail,Value1,Value1A],"Press c."]),(not(get_single_char(97))->true;abort));true).
+interpretpart(member,Variable1,Variable2,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+	(not(Value1=empty)->(member(Value1,Value2),Vars2=Vars1,
+        	(debug(on)->(writeln([call,[member,Value1,Value2],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[member,Value1,Value2],"Press c."]),(not(get_single_char(97))->true;abort));true));
+	(member(Value3,Value2),
+	putvalue(Variable1,Value3,Vars1,Vars2),
+                (debug(on)->(writeln([call,[member,variable1,Value2],"Press c."]),(not(get_single_char(97))->true;abort));true),
+                (debug(on)->(writeln([exit,[member,Value3,Value2],"Press c."]),(not(get_single_char(97))->true;abort));true))).
+
+interpretpart(delete,Variable1,Variable2,Variable3,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        delete(Value1,Value2,Value3A),
+        val1emptyorvalsequal(Value3,Value3A),
+        putvalue(Variable3,Value3A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[delete,Value1,Value2,variable3],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[delete,Value1,Value2,Value3A],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+
+interpretpart(append,Variable1,Variable2,Variable3,Vars1,Vars2) :-
+        getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars1),
+        append1(Value1,Value2,Value3A),
+        val1emptyorvalsequal(Value3,Value3A),
+        putvalue(Variable3,Value3A,Vars1,Vars2),
+        	(debug(on)->(writeln([call,[append,Value1,Value2,variable3],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[append,Value1,Value2,Value3A],"Press c."]),(not(get_single_char(97))->true;abort));true).
+getvalues(Variable1,Variable2,Value1,Value2,Vars) :-
+        getvalue(Variable1,Value1,Vars),
+        getvalue(Variable2,Value2,Vars).
+getvalues(Variable1,Variable2,Variable3,Value1,Value2,Value3,Vars) :-
+        getvalue(Variable1,Value1,Vars),
+        getvalue(Variable2,Value2,Vars),
+        getvalue(Variable3,Value3,Vars).
+val1emptyorvalsequal(empty,Value) :-
+	not(Value=empty).
+val1emptyorvalsequal(Value,Value) :-
+	not(Value=empty).
+isop(is).
+isop(=).
+append1([],Item,Item) :-
+	!.
+append1(Item1,Item2,Item3) :-
+	((isvalstr(Item1),Item1A=[Item1]);(not(isvalstr(Item1)),Item1A=Item1)),
+        ((isvalstr(Item2),Item2A=[Item2]);(not(isvalstr(Item2)),Item2A=Item2)),
+        %%((isvalstr(Item3),Item3A=[Item3]);(not(isvalstr(Item3)),Item3A=Item3)),
+	append(Item1A,Item2A,Item3).
+/**delete1(Item1,Item2,Item3) :-
+	((isvalstr(Item1),Item1A=[Item1]);(not(isvalstr(Item1)),Item1A=Item1)),
+        ((isvalstr(Item2),Item2A=[Item2]);(not(isvalstr(Item2)),Item2A=Item2)),
+        %%((isvalstr(Item3),Item3A=[Item3]);(not(isvalstr(Item3)),Item3A=Item3)),
+	delete(Item1A,Item2A,Item3).
+**/
+
+removebrackets([[Value]],Value) :-!.
+removebrackets(Value,Value).

Combination-Algorithm-Writer-Stable/lpi_caw_commands.pl

@@ -0,0 +1,39 @@
+interpretstatement1(_F0,_Functions,[[not,Operator],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	isop(Operator),
+	interpretpart(not_is,Variable1,Variable2,Vars1,Vars2),!.
+
+interpretstatement1(_F0,_Functions,[[not,Operator],[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	comparisonoperator(Operator),
+%%writeln1(4),
+        interpretpart(not_iscomparison,Operator,Variable1,Variable2,Vars1,Vars2).
+
+interpretpart(not_is,Variable1,Variable2,Vars1,Vars1) :-
+        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        	not(isempty(Value1)),
+        	not(isempty(Value2)),
+        %%writeln([call,[[not,=],[Value1,Value2]]]),
+        ((not(Value1 = Value2)
+		)->
+      true%%writeln([exit,[[not,=],[Value1,Value2]]])
+;     fail)%%writeln([fail,[[not,=],[Value1,Value2]]]))
+,!.                        	
+
+interpretpart(not_iscomparison,Operator,Variable1,Variable2,Vars1,Vars1) :-        getvalues(Variable1,Variable2,Value1,Value2,Vars1),
+        %%writeln([call,[[not,=],[Value1,Value2]]]),
+	((isval(Value1),
+	isval(Value2),
+	Expression=..[Operator,Value1,Value2],
+        not(Expression))->
+      true%%writeln([exit,[[not,=],[Value1,Value2]]])
+;     fail)%%writeln([fail,[[not,=],[Value1,Value2]]]))
+,!.                        	
+
+isempty(N) :-
+	N=empty.
+
+comparisonoperator(>).
+comparisonoperator(>=).
+comparisonoperator(<).
+comparisonoperator(=<).
+%%comparisonoperator(=).
+comparisonoperator(=\=).

Combination-Algorithm-Writer-with-Predicates/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, Lucian Green
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Combination-Algorithm-Writer-with-Predicates/LPI CAW commands workaround.txt

@@ -0,0 +1,9 @@
+LPI CAW commands workaround for single argument commands not working, but no singletons working
+
+_A - enter value in header (one output, so is it, do outputs one at a time)
+
+[] and "" - enter [] or "" somewhere in header and use normal "="
+
+not - can still use except for [], "", etc., see previous line
+
+With no singletons working, CAWP is more stable than CAWMP

Combination-Algorithm-Writer-with-Predicates/README.md

@@ -0,0 +1,73 @@
+# Combination-Algorithm-Writer-with-Predicates-Stable
+Combination Algorithm Writer with Predicates Stable (CAWPS)
+
+This was copied from CAWPS on 22 3 20, replacing the content of CAWP.
+
+Please note: This works with the example below, which CAWMP doesn't.
+
+Combination Algorithm Writer is a SWI-Prolog algorithm that finds combinations of given commands that satisfy the given input and output.
+
+It verifies for no singletons.
+
+# Prerequisites
+
+* Please download and install SWI-Prolog for your machine at `https://www.swi-prolog.org/build/`.
+
+# 1. Install manually
+
+Download <a href="http://github.com/luciangreen/Combination-Algorithm-Writer-with-Predicates/">this repository</a>.
+
+# 2. Or Install from List Prolog Package Manager (LPPM)
+
+* Download the <a href="https://github.com/luciangreen/List-Prolog-Package-Manager">LPPM Repository</a>:
+
+```
+mkdir GitHub
+cd GitHub/
+git clone https://github.com/luciangreen/List-Prolog-Package-Manager.git
+cd List-Prolog-Package-Manager
+swipl
+['lppm'].
+lppm_install("luciangreen","Combination-Algorithm-Writer-with-Predicates").
+halt
+```
+
+# Running
+
+* In Shell:
+`cd Combination-Algorithm-Writer-with-Predicates`
+`swipl`
+
+* Load all files in the form:
+```
+['lpi_caw_commands.pl'].
+['listprologinterpreter1listrecursion4copy52'].
+['listprologinterpreter3preds5copy52'].
+['caw5copy11'].
+```
+Running
+
+```
+caw00(off,f,[[+,2,1]],4,8,[[a,1],[b,1],[c,2],[d,1]],[[e,5]],[[[f1,4,1],[a,b,c,d,e],(:-),[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]]],[],P),writeln(P).
+
+[[f1,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]],[f,[a,b,c,d,e],:-,[[+,[a,b,f]],[+,[c,d,g]],[+,[f,g,h]],[=,[e,h]]]]]
+.
+.
+.
+```
+
+```
+caw00(off,reverse,[[head,1,1],[tail,1,1],[wrap,1,1],[append,2,1],[reverse,2,1]],6,8,[[a,[1,2,3]],[b,[]]],[[c,[3,2,1]]],[[[reverse,2,1],[[],a,a]]],[],P),writeln(P).
+
+not finished
+```
+
+Note: Use (:-) instead of :-.
+
+# CAWPS API
+
+* To run CAWPS on a Prolog server:
+* Move `cawps-api.pl` to the root (`/username/` or `~` on a server) of your machine.
+* Re-enter the paths to your Prolog files in it.
+* Enter `[cawps-api.pl]` in SWI-Prolog and `server(8000).`.
+* On a local host access the algorithm at `http://127.0.0.1:8000` and replace 127.0.0.1 with your server address on a server.

Combination-Algorithm-Writer-with-Predicates/caw5copy11.pl

@@ -0,0 +1,351 @@
+:- dynamic debug/1.
+:- dynamic totalvars/1.
+:- dynamic outputvars/1.
+
+caw00(Debug,PredicateName,Rules1,MaxLength,TotalVars,InputVarList,OutputVarList,Predicates1,Program1,Program2) :-
+	split3(Predicates1,[],Rules2),
+	split2(Predicates1,[],Predicates),
+	%%writeln([Rules2,Predicates]),
+	append(Rules1,Rules2,Rules3),
+
+	retractall(debug(_)),
+    	assertz(debug(Debug)),
+	retractall(totalvars(_)),
+    	assertz(totalvars(TotalVars)),
+	caw0(Predicates,PredicateName,Rules3,MaxLength,InputVarList,OutputVarList,Program1,Program2).
+
+caw0(Predicates,PredicateName,Rules,MaxLength,InputVarList,OutputVarList,Program1,Program2) :-
+	varnames(InputVarList,[],InputVars,[],InputValues),
+	varnames(OutputVarList,[],OutputVars,[],_OutputValues),
+	retractall(outputvars(_)),
+    	assertz(outputvars(OutputVars)),
+append(InputVars,OutputVars,Vars11),
+%%Vars11=InputVars,
+%%Vars12=InputVars,
+	append(InputValues,OutputVars,Vars2),
+	%%append(InputValues,OutputValues,Values),
+	Query=[PredicateName,Vars2],
+	caw(Predicates,Query,PredicateName,Rules,MaxLength,Vars11,InputVars,InputVars,_,OutputVarList,OutputVars,Program1,Program2).
+caw(_,_,_,_,0,_,_,_,_,_,_,_) :- fail, !.
+caw(Predicates,Query,PredicateName,_,_,_VarList,InputVars1,InputVars2,_,OutputVarList,OutputVars,Program1,Program2) :-
+	addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3),
+%%writeln([addrules(InputVars2,OutputVars,OutputVars,[],PenultimateVars,[],Program3)]),	
+	%%optimise(Program1,InputVars1,InputVars3,PenultimateVars,Program4), %% IV2->3
+%%writeln([optimise(Program1,InputVars1,InputVars3,PenultimateVars,Program4)]),
+	append(Program1,Program3,Program5),
+	append(InputVars1,OutputVars,Vars2),
+	Program22=[
+        [PredicateName,Vars2,(:-),
+                Program5
+        ]
+        ],
+        
+        	append(Predicates,Program22,Program2),
+
+        (debug(on)->Debug=on;Debug=off),
+%%writeln([interpret(Debug,Query,Program2,OutputVarList)]),
+%%writeln(""),
+	catch(call_with_time_limit(0.05, 
+		interpret(Debug,Query,Program2,OutputVarList)),
+      time_limit_exceeded,
+      fail),
+	no_singletons(Vars2,Program5),!.
+caw(Predicates,Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,InputVars3,OutputVarList,OutputVars,Program1,Program4) :-
+%%writeln([caw(Query,PredicateName,Rules,MaxLength,VarList,InputVars1,InputVars2,OutputVarList,OutputVars,Program1,Program4)]),
+	MaxLength2 is MaxLength - 1,
+%%writeln(["ml",MaxLength2]),
+	member([RuleName,NumInputs,NumOutputs],Rules),
+%%writeln([member([RuleName,NumInputs,NumOutputs],Rules)]),
+%%writeln([rule(RuleName,NumInputs,NumOutputs,VarList,VarList2,Rule)]),
+	rule(RuleName,NumInputs,NumOutputs,InputVars2,InputVars4,VarList,VarList2,Rule),
+%%writeln([rule(RuleName,NumInputs,NumOutputs,InputVars1,InputVars3,VarList,VarList2,Rule)]),
+	append(Program1,[Rule],Program3),
+%%writeln([inputVars3,InputVars3]),
+%%InputVars2=InputVars3,
+%%writeln([program4,Program4]),
+	caw(Predicates,Query,PredicateName,Rules,MaxLength2,VarList2,InputVars1,InputVars4,InputVars3,OutputVarList,OutputVars,Program3,Program4).
+
+varnames([],Vars,Vars,Values,Values) :- !.
+varnames(VarList,Vars1,Vars2,Values1,Values2) :-
+	VarList=[Var|Vars3],
+	Var=[VarName,Value],
+	append(Vars1,[VarName],Vars4),
+	append(Values1,[Value],Values3),
+	varnames(Vars3,Vars4,Vars2,Values3,Values2),!.
+
+addrules(_,_,[],PV,PV,Program,Program) :- !.
+addrules(VarList,OutputVars1,OutputVars2,PenultimateVars1,PenultimateVars2,Program1,Program2) :-
+	OutputVars2=[OutputVar|OutputVars3],
+	member(Var,VarList),
+	member(OutputVar,OutputVars1),
+	append(Program1,[[=,[OutputVar,Var]]],Program3),
+	append(PenultimateVars1,[Var],PenultimateVars3),
+	addrules(VarList,OutputVars1,OutputVars3,PenultimateVars3,PenultimateVars2,Program3,Program2).
+
+%% optimise([[append,[a,a,d]],[append,[a,a,e]],[append,[a,a,f]],[append,[a,b,g]]],[g],P).
+
+optimise(Program1,InputVars1,InputVars2,PenultimateVars,Program2) :-
+	findrulesflowingtopv1(Program1,InputVars1,InputVars2,PenultimateVars,[],Rules,true),
+	%%findrulesflowingtopv1a(Program1,_Program32,InputVars1,InputVars2,PenultimateVars,[],_Rules1),
+	intersection(Program1,Rules,Program3),
+	unique1(Program3,[],Program2).
+findrulesflowingtopv1(_,_,_,[],Rules,Rules,false).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	(atom(Var);length(Var,1)),
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1).
+findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars1,Rules1,Rules2,IV1Flag1) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv20(Program0,Program0,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2), 
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Vars2,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv20(_,[],_InputVars1,_InputVars2,_Var,Rules,Rules,false).
+findrulesflowingtopv20(Program0,Rules4,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rules4=[Rule|Rules],
+	(findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules3,IV1Flag2)->true;(Rules3=Rules1,IV1Flag2=false)),
+	%%delete(Program0,Rule,Program1),
+	findrulesflowingtopv20(Program0,Rules,InputVars1,InputVars2,Var,Rules3,Rules2,IV1Flag3),%%p1->0
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+%%findrulesflowingtopv2(_,[],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	%%(not(intersection(Rulesx,Rules1))-> x
+	%% append, append, unique1
+	%%append(Rules1,[Rule],Rules3);Rules3=Rules1),
+
+	%%member(Var2,Rest),
+	%%member(Var2,InputVars1),
+
+	length(Rest,Length1), Length1>=1,
+	subtract(Rest,InputVars1,IV3s),
+	length(IV3s,Length3),
+	subtract(Rest,IV3s,IV1s),
+	length(IV1s,Length2), Length2>=1,
+	subtract(IV3s,InputVars2,[]),
+
+	IV1Flag2=true,
+
+	%%delete(Program0,Rule,Program1),
+
+	%%(delete(Program0,Rule,Program3),
+	%%iv3s1(IV3s,Program3,IV3s,[]),
+	(Length3>=1->
+	(findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV3s,[],Rules5,IV1Flag3),not(Rules5=[]));
+	(Rules5=[],IV1Flag3=false)),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag4),
+	%%->true; Rules5=[],IV1Flag1=IV1Flag4),
+	
+	((findrulesflowingtopv1(Program0,InputVars1,InputVars2,IV1s,[],Rules6,IV1Flag5), %%iv1s->rest, etc
+	iv1flagdisjunction(IV1Flag4,IV1Flag5,IV1Flag1))->true;(Rules6=[],IV1Flag1=IV1Flag4)),
+
+	append([Rule],Rules1,Rules9),
+	append(Rules9,Rules5,Rules7),
+	append(Rules7,Rules6,Rules8),
+	unique1(Rules8,[],Rules2).
+
+/**
+findrulesflowingtopv2(_Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program2),
+	%%Program2=Program1,
+	(not(member(Rule,Rules1))->
+	append(Rules1,[Rule],Rules2);Rules2=Rules1),
+	subset(Rest,InputVars2),
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+	IV1Flag1=false.
+**/
+/**
+findrulesflowingtopv2(Program0,Rule,InputVars1,InputVars2,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),	
+	%%delete(Program1,[PredicateName,Vars],Program3),
+	%%Program3=Program1,
+	%%append(Rules1,[Rule],Rules3),
+	subset(Rest,InputVars2),
+	
+	intersection(Rest,InputVars1,Intersection),
+	length(Intersection,0),
+%%	not((member(Var2,Rest),
+%%	member(Var2,InputVars1))),
+%%	delete(Program0,Rule,Program1),
+	IV1Flag2=false,
+	findrulesflowingtopv1(Program0,InputVars1,InputVars2,Rest,[],Rules4,IV1Flag3),
+	%%not(Rules4=[]),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1),
+	append(Rules1,[Rule],Rules7),
+	append(Rules7,Rules4,Rules8),
+	unique1(Rules8,[],Rules2).
+**/
+/**
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2(Rule,Program0,Program1,_Program2,InputVars1,InputVars,Var,Rules1,Rules2,IV1Flag1) :-
+	Rule=[PredicateName,Vars],
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	%%Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1(Program0,Program1,_Program2,InputVars1,InputVars,Rest,Rules3,Rules2,IV1Flag3),
+	iv1flagdisjunction(IV1Flag2,IV1Flag3,IV1Flag1).
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+**/
+iv1flagdisjunction(A,B,true) :-
+	(A=true); (B=true).
+iv1flagdisjunction(_,_,false).
+/**
+iv3s0([],_,IV3s1,IV3s2).
+iv3s0(IV3s,Program0,IV3s1,IV3s2).
+	IV3s=[IV3|IV3s3],
+	iv3s1(IV3,Program0,IV3s1,IV3s4),
+	iv3s0(IV3s3,Program0,IV3s4,IV3s2).
+iv3s1(_,[],IV3s,IV3s).	
+iv3s1(IV3,Program0,IV3s1,IV3s2) :-
+	Program0=[Rule|Rules],
+	iv3s2(IV3,Rule,IV3s1,IV3s3),
+	iv3s1(IV3,Rules,IV3s3,IV3s2).
+iv3s2(IV3,Rule,IV3s,IV3s1,IV3s2).
+	Rule=[_PredicateName,Vars],
+	restlast(Vars,[],_Rest,IV3),	
+	delete(IV3s1,IV3,IV3s2).
+findrulesflowingtopv1a(_,_,_,_,[],Rules,Rules).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	atom(Var),
+	findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2).
+findrulesflowingtopv1a(Program1,Program2,InputVars1,InputVars2,Vars1,Rules1,Rules2) :-
+	Vars1=[Var|Vars2],
+	findrulesflowingtopv2(Program1,Program3,InputVars1,InputVars2,Var,Rules1,Rules3),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Vars2,Rules3,Rules2).
+%%findrulesflowingtopv2([],Program,Program,_,_,Rules,Rules).
+findrulesflowingtopv2a([],[],_,_,_,Rules,Rules).
+findrulesflowingtopv2a(Program1,Program2,_InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program2),
+Program2=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules2),
+	subset(Rest,InputVars2)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars2,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	(
+%%delete(Program1,[PredicateName,Vars],Program3),
+Program3=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	subset(Rest,InputVars2)),
+	findrulesflowingtopv1a(Program3,Program2,InputVars1,InputVars2,Rest,Rules3,Rules2).
+%%->true;(Program2=Program1,Rules2=Rules1)).
+findrulesflowingtopv2a(Program1,Program2,InputVars1,InputVars,Var,Rules1,Rules2) :-
+	member([PredicateName,Vars],Program1),
+	restlast(Vars,[],Rest,Var),
+	%%delete(Program1,[PredicateName,Vars],Program4),
+	Program4=Program1,
+	append(Rules1,[[PredicateName,Vars]],Rules3),
+	findrulesflowingtopv1a(Program4,Program2,InputVars1,InputVars,Rest,Rules3,Rules2).
+	%%findrulesflowingtopv2(Program5,Program2,Rest,Rules3,Rules2).
+	**/
+
+restlast([],_,_,_) :- fail, !.	
+restlast([Last],Rest,Rest,Last) :-
+	atom(Last),!.
+restlast(Last,Rest,Rest,Last) :-
+	length(Last,1),!.
+restlast(Vars1,Rest1,Rest2,Last) :-
+	Vars1=[Var|Vars2],
+	append(Rest1,[Var],Rest3),
+	restlast(Vars2,Rest3,Rest2,Last),!.
+
+	
+
+
+rule(RuleName,1,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+	member(Var,InputVars1),
+	rule2(RuleName,Var,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule2(RuleName,Var,VarList,VarList2,Rule,Var1) :-
+	var(VarList,Var1,VarList2),
+	Rule=[RuleName,[Var,Var1]],!.
+
+rule(RuleName,1,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        rule3(RuleName,Var,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule3(RuleName,Var,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Var1,Var2]],!.
+
+rule(RuleName,2,1,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars1),
+        member(Vara,InputVars1),
+        rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1),
+	append(InputVars1,[Var1],InputVars2).
+rule4(RuleName,Var,Vara,VarList,VarList2,Rule,Var1) :-
+        var(VarList,Var1,VarList2),
+        Rule=[RuleName,[Var,Vara,Var1]],!.
+
+rule(RuleName,2,2,InputVars1,InputVars2,VarList,VarList2,Rule) :-
+        member(Var,InputVars),
+        member(Vara,InputVars),
+        rule5(RuleName,Var,Vara,VarList,VarList2,Rule,Vars),
+	append(InputVars1,Vars,InputVars2).
+rule5(RuleName,Var,Vara,VarList,VarList3,Rule,[Var1,Var2]) :-
+        var(VarList,Var1,VarList2),
+        var(VarList2,Var2,VarList3),
+        Rule=[RuleName,[Var,Vara,Var1,Var2]],!.
+
+%%var(Item,Var,Vars,Vars) :-
+%%	member([Item,Var],Vars).
+var(Vars1,Var1,Vars2) :-
+	length(Vars1,Vars1Length1),
+	Vars1Length2 is Vars1Length1-1,
+	length(Vars3,Vars1Length2),
+	append(Vars3,[Var2],Vars1),
+	char_code(Var2,Var2Code1),
+	Var2Code2 is Var2Code1 + 1,
+	var2(Var2Code2,Var1),
+	append(Vars1,[Var1],Vars2),!.
+
+var2(Code,Var1) :-
+	outputvars(OutputVars),
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Code =< Code2, %% 122
+	char_code(Var1,Code),
+	not(member(Var1,OutputVars)),!.
+var2(Var2Code,Code3) :-
+	Var2Code2 is Var2Code + 1,	
+	totalvars(TotalVars),
+	Code2 is 96+TotalVars,
+	Var2Code2 =< Code2,
+	var2(Var2Code2,Code3),!.
+
+
+no_singletons(Vars1,Program):-
+	findall(DA,(member(C,Program),C=[_E,D],member(DA,D)),Vars2),
+	%%append_list(Vars2,Vars2A),
+	append(Vars1,Vars2,Vars3),
+	findall(Count1,(member(Item,Vars3),aggregate_all(count,(member(Item,Vars3)),Count1),
+	Count1=1),G),G=[].
+
+	split3([],List,List) :- !.
+split3(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[Name,In,Out]|_Rest],
+	append(List1,[[Name,In,Out]],List6),
+	split3(List4,List6,List2),!.
+	
+split2([],List,List) :- !.
+split2(Predicates1,List1,List2) :-
+	Predicates1=[Item1|List4],
+	Item1=	[[Name,_In,_Out]|Rest],
+	append(List1,[[Name|Rest]],List6),
+	split2(List4,List6,List2),!.
+

Combination-Algorithm-Writer-with-Predicates/cawps-api.pl

@@ -0,0 +1,103 @@
+:- use_module(library(http/thread_httpd)).
+:- use_module(library(http/http_dispatch)).
+:- use_module(library(http/http_error)).
+:- use_module(library(http/html_write)).
+
+% we need this module from the HTTP client library for http_read_data
+:- use_module(library(http/http_client)).
+:- http_handler('/', web_form, []).
+
+:- include('files/Combination-Algorithm-Writer-Stable/listprologinterpreter1listrecursion4copy52.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/listprologinterpreter3preds5copy52.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/caw5copy11.pl').
+:- include('files/Combination-Algorithm-Writer-Stable/lpi_caw_commands.pl').
+
+server(Port) :-
+        http_server(http_dispatch, [port(Port)]).
+
+	/*
+	browse http://127.0.0.1:8000/
+	This demonstrates handling POST requests
+	   */
+
+	   web_form(_Request) :-
+	   	reply_html_page(include('Combination Algorithm Writer Stable'),
+	   	
+			    	    [
+				    	     form([action='/landing', method='POST'], [
+				    	     /**
+					     		p([], [
+									  label([for=debug],'Debug (on/off):'),
+									  		  input([name=debug, type=textarea])
+											  		      ]),
+											  		      **/
+													      		p([], [
+																	  label([for=predicatename],'Predicate Name (e.g. f):'),
+																	  		  input([name=predicatename, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=rules],'Rules to choose from (e.g. [[+,2,1]]):'),
+																	  		  input([name=rules, type=textarea])
+																			  		      ]),
+
+															      		p([], [
+																	  label([for=maxlength],'Max Length of Algorithm Body (e.g. 4):'),
+																	  		  input([name=maxlength, type=textarea])
+																			  		      ]),
+
+																				      		p([], [
+																	  label([for=totalvars],'Total Vars in Predicate (e.g. 8):'),
+																	  		  input([name=totalvars, type=textarea])
+																			  		      ]),
+													      		p([], [
+																	  label([for=inputvarlist],'InputVarList (e.g. [[a,1],[b,1],[c,2],[d,1]]):'),
+																	  		  input([name=inputvarlist, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=outputvarlist],'OutputVarList (e.g. [[e,5]]):'),
+																	  		  input([name=outputvarlist, type=textarea])
+																			  		      ]),
+
+													      		p([], [
+																	  label([for=algorithmlibrary],'Algorithm Library (e.g. [[[f1,4,1],[a,b,c,d,e],(:-),[[+,[a,b,f]],[+,[c,f,g]],[+,[d,g,h]],[=,[e,h]]]]], where 4 is the number of inputs and 1 is the number of outputs):'),
+																	  		  input([name=algorithmlibrary, type=textarea])
+																			  		      ]),
+
+												      		p([], input([name=submit, type=submit, value='Submit'], []))
+																								      ])]).
+
+																								      :- http_handler('/landing', landing_pad, []).
+
+																								      landing_pad(Request) :-
+																								              member(method(post), Request), !,
+																									              http_read_data(Request, Data, []),
+																										              format('Content-type: text/html~n~n', []),
+																											      	format('<p>', []),
+																												        %%portray_clause(Data),
+																												        
+																												        %%term_to_atom(Term,Data),
+									
+										   	%% Predicatename,Rules,Maxlength,Totalvars,Inputvarlist,Outputvarlist,Algorithmlibrary
+																															%%portray_clause(Data),
+			
+															        
+Data=[%%debug='off',%%Debug1,
+predicatename=Predicatename,rules=Rules,maxlength=Maxlength,totalvars=Totalvars,inputvarlist=Inputvarlist,outputvarlist=Outputvarlist,algorithmlibrary=Algorithmlibrary,submit=_],
+
+term_to_atom(Debug1,'off'),
+term_to_atom(Predicatename1,Predicatename),
+term_to_atom(Rules1,Rules),
+term_to_atom(Maxlength1,Maxlength),
+term_to_atom(Totalvars1,Totalvars),
+term_to_atom(Inputvarlist1,Inputvarlist),
+term_to_atom(Outputvarlist1,Outputvarlist),
+term_to_atom(Algorithmlibrary1,Algorithmlibrary),
+
+caw00(Debug1,Predicatename1,Rules1,Maxlength1,Totalvars1,Inputvarlist1,Outputvarlist1,Algorithmlibrary1,[],Result),
+																														%%format('</p><p>========~n', []),
+																															portray_clause(Result),
+																																																															%%writeln1(Data),
+
+format('</p>').

Combination-Algorithm-Writer-with-Predicates/listprologinterpreter1listrecursion4copy52.pl

@@ -0,0 +1,576 @@
+/**:- include('listprologinterpreter3preds5.pl').
+:- include('lpiverify4.pl').
+:- include('caw5 copy 11.pl').
+**/
+:- dynamic debug/1.
+
+/** List Prolog Interpreter **/
+
+interpret(Debug,Query,Functions,Result) :-
+%%writeln([i1]),
+	interpret1(Debug,Query,Functions,Functions,Result),
+	!.
+interpret1(Debug,Query,Functions1,Functions2,Result) :-
+%%writeln([i11]),
+	retractall(debug(_)),
+    	assertz(debug(Debug)),
+        retractall(cut(_)),
+        assertz(cut(off)),
+	member1(Query,Functions1,Functions2,Result).
+%%member1([_,R],_,[],R).
+%%member1(_,_,[],[]).
+member1(_,_,[],_) :- fail.
+member1(Query,Functions,Functions2,Vars8) :-
+%%writeln([m1]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+	(Functions2=[[Function,Arguments2,(:-),Body]|_Functions3]),
+	length(Arguments1,Length),
+	length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!, %%->ca2 
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+                (debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	interpretbody(Functions,Functions2,Vars1,Vars2,Body,true),
+	updatevars(FirstArgs,Vars2,[],Result),
+        %%reverse(Result,[],Vars7),
+	((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+%%writeln(["FirstArgs",FirstArgs,"Vars",Vars2,"Result",Result,"Vars7",Vars7,"Vars72",Vars72,"Var71",Var71,"Vars8",Vars8]),
+%%writeln(["Vars8",Vars8]),
+	findresult3(Arguments1,Vars8,[],Result2)
+%%writeln([findresult3,"Arguments1",Arguments1,"Vars8",Vars8,"Result2",Result2])
+	);(
+%%writeln(here1),
+	Vars8=[],Result2=[])),
+%%writeln(["Arguments1",Arguments1,"Vars2",Vars2,"Result",Result]),
+		(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true))
+	->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2,(:-),_Body]|Functions3], %% make like previous trunk?
+	member11(Query,Functions,Functions2,Vars8))
+	);(turncut(off)%%,Result=[]
+	).
+member11(Query,Functions,Functions2,Result) :-
+%%writeln([m11]),
+%%writeln(["Query",Query,"Functions",Functions,"Functions2",Functions2,"Result",Result]),
+	cut(off)->(
+        (Query=[Function],
+        (Functions2=[[Function,(:-),Body]|_Functions3]),
+                (debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Result=[],
+        interpretbody(Functions,Functions2,[],_Vars2,Body,true),!,
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	%%Functions2=[[Function]|Functions3],
+	member12(Query,Functions,Functions2,Result))
+	);(turncut(off)).
+member12(Query,Functions,Functions2,Vars8) :-
+%%writeln([m12]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!, %% ->ca2
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+	updatevars(FirstArgs,Vars1,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+        );(
+%%writeln(here2),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2]|Functions3],
+	member13(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member13(Query,Functions,Functions2,Result) :-
+%%writeln([m13]),
+	cut(off)->(
+        (Query=[Function],!,
+        (Functions2=[[Function]|_Functions3]),
+        	(debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Result=[],
+        %%interpretbody(Functions,[],_Vars2,Body,true),
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	Functions2=[_Function|Functions3],
+	member1(Query,Functions,Functions3,Result))
+	);(turncut(off)).
+interpret2(Query,Functions1,Functions2,Result) :-
+%%writeln(i2),
+%%writeln(["%%interpret2 Query",Query,"Functions1",Functions1,"Functions2",Functions2]),
+        member2(Query,Functions1,Functions2,Result).
+%%member2([_,R],_,[],R).
+%%member2(_,_,[],[]).
+member2(_,_,[],_) :- fail.
+member2(Query,Functions,Functions2,Vars8) :-
+%%writeln([m2]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2,(:-),Body]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!,
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+                (debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        interpretbody(Functions,Functions2,Vars1,Vars2,Body,true), %%**arg2 change
+%%writeln(["Functions",Functions,"Functions2",Functions2,"Vars1",Vars1,"Vars2",Vars2,"Body",Body]),
+        updatevars(FirstArgs,Vars2,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+%%writeln(["Vars2",Vars2,"Result",Result]),
+        );(
+	writeln(here3),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2,(:-),_Body]|Functions3],
+	member21(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member21(Query,Functions,Functions2,Result) :-
+%%writeln([m21]),
+	cut(off)->(
+        (Query=[Function],
+        (Functions2=[[Function,(:-),Body]|_Functions3]),
+        Vars1=[],
+                (debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        interpretbody(Functions,Functions2,Vars1,_Vars2,Body,true),!, %%**arg2 change
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	%%Functions2=[[Function]|Functions3],
+	member22(Query,Functions,Functions2,Result))
+	);(turncut(off)).
+member22(Query,Functions,Functions2,Vars8) :-
+%%writeln([m22]),
+	cut(off)->(
+        (Query=[Function,Arguments1],
+        (Functions2=[[Function,Arguments2]|_Functions3]),
+        length(Arguments1,Length),
+        length(Arguments2,Length),
+        checkarguments(Arguments1,Arguments2,[],Vars1,[],FirstArgs),!,
+%%writeln([checkarguments,"Arguments1",Arguments1,"Arguments2",Arguments2,"Vars1",Vars1,"FirstArgs",FirstArgs]),
+        updatevars(FirstArgs,Vars1,[],Result),
+        %%reverse(Result,[],Vars7),
+        ((not(Result=[])->
+        %%Result=[Var71|Vars72],
+        unique1(Result,[],Vars8),
+        findresult3(Arguments1,Vars8,[],Result2)
+        );(
+%%writeln(here4),
+	Vars8=[],Result2=[])),
+        	(debug(on)->(writeln([call,[Function,Arguments1],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        	(debug(on)->(writeln([exit,[Function,Result2],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function,_Arguments1],
+	%%Functions2=[[Function,_Arguments2]|Functions3],
+	member23(Query,Functions,Functions2,Vars8))
+	);(turncut(off)).
+member23(Query,Functions,Functions2,Vars8) :-
+%%writeln([m23]),
+	cut(off)->(
+        (Query=[Function],!,
+        (Functions2=[[Function]|_Functions3]),
+        	(debug(on)->(writeln([call,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	Vars8=[],
+        	(debug(on)->(writeln([exit,[Function],"Press c."]),(not(get_single_char(97))->true;abort));true)
+	)->true;
+	(%%Query=[Function],
+	Functions2=[_Function|Functions3],
+	member2(Query,Functions,Functions3,Vars8))
+	);(turncut(off)).
+checkarguments([],[],Vars,Vars,FirstArgs,FirstArgs). 
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%
+%%writeln(1),
+	Arguments1=[Value|Arguments3], %% Value may be a number, string, list or tree
+	expressionnotatom(Value),
+	Arguments2=[Variable2|Arguments4],
+	isvar(Variable2),
+	putvalue(Variable2,Value,Vars1,Vars3),
+	checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs1,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :- %%A
+%%writeln(2),
+        Arguments1=[Variable|Arguments3], %% Value may be a number, string, list or tree
+        isvar(Variable),
+        Arguments2=[Value|Arguments4],
+        expressionnotatom(Value),
+        putvalue(Variable,Value,Vars1,Vars3),
+	append(FirstArgs1,[[Variable,_]],FirstArgs3),
+        checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
+%%writeln(3),
+        Arguments1=[Variable1|Arguments3],
+	isvar(Variable1),
+        Arguments2=[Variable2|Arguments4],
+	isvar(Variable2),
+	(getvalue(Variable2,Value,Vars1)->true;Value=empty),
+        putvalue(Variable2,Value,Vars1,Vars3),
+        append(FirstArgs1,[[Variable1,Variable2]],FirstArgs3),
+        checkarguments(Arguments3,Arguments4,Vars3,Vars2,FirstArgs3,FirstArgs2).
+checkarguments(Arguments1,Arguments2,Vars1,Vars2,FirstArgs1,FirstArgs2) :-
+%%writeln(4),
+        Arguments1=[Value1|Arguments3],
+        expressionnotatom(Value1),
+        Arguments2=[Value1|Arguments4],
+        expressionnotatom(Value1),
+        checkarguments(Arguments3,Arguments4,Vars1,Vars2,FirstArgs1,FirstArgs2).
+
+interpretbody(_Functions1,_Functions2,Vars,Vars,[],true) :- !.
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[Statements1|Statements2],
+        interpretbody(Functions0,Functions,Vars1,Vars3,Statements1,Result2),
+        interpretbody(Functions0,Functions,Vars3,Vars2,Statements2,Result3),
+        %%((Result3=cut)->!;true),
+        logicalconjunction(Result1,Result2,Result3),!.
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[[not,[Statements]]|Statements2],
+	interpretbody(Functions0,Functions,Vars1,Vars3,Statements,Result2),
+        %%((Result2=cut)->!;true),
+        interpretbody(Functions0,Functions,Vars3,Vars2,Statements2,Result3),
+        %%((Result3=cut)->!;true),
+        logicalnot(Result2,Result4),
+	(logicalconjunction(Result1,Result4,Result3)->true;(Result1=false)),!.
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+        Body=[[Statements1],or,[Statements2]],
+        (interpretbody(Functions0,Functions,Vars1,Vars2,Statements1,Result1);
+	%%,((Value1=cut)->!;true));
+        interpretbody(Functions0,Functions,Vars1,Vars2,Statements2,Result1)),!.
+	%%,((Value=cut)->!;true)).
+	%%(logicaldisjunction(Result1,Value1,Value2)->true;(Result1=false)).
+
+
+interpretbody(Functions0,Functions,Vars1,Vars2,Body,Result1) :-
+	Body=[Statement|Statements],
+%%writeln(["Functions0",Functions0,"Functions",Functions,"Statement",Statement,"Vars1",Vars1,"Vars3",Vars3,"Result2",Result2,"Cut",Cut]),
+	interpretstatement1(Functions0,Functions,Statement,Vars1,Vars3,Result2,Cut),
+%%writeln(["here1"]),
+	((not(Cut=cut))->(Functions2=Functions);(turncut(on))), %% cut to interpret1/2 (assertz)
+%%writeln(["here3"]),
+	interpretbody(Functions0,Functions2,Vars3,Vars2,Statements,Result3),
+	%%((Result3=cut)->!;true),
+%%writeln(["here4"]),
+	logicalconjunction(Result1,Result2,Result3),!.
+%%writeln([Result1,Result2,Result3]).
+turncut(State1) :-
+	cut(State2),
+	retract(cut(State2)),
+	assertz(cut(State1)).
+logicaldisjunction(true,Result2,Result3) :-
+        true(Result2);true(Result3).
+logicalconjunction(true,Result2,Result3) :-
+	true(Result2),true(Result3).
+logicalnot(Result1,Result2) :-
+	true(Result1),false(Result2).
+logicalnot(Result1,Result2) :-
+        false(Result1),true(Result2).
+true(true).
+false(false).
+
+%%interpretstatement1(_F0,[],_,Vars,Vars,true,nocut) :- !
+%%writeln("AND HERE!")
+%%	.
+
+interpretstatement1(_F0,_Functions,[cut,[]],Vars,Vars,true,cut) :- !.
+
+interpretstatement1(_F0,_Functions,[atom,[Variable]],Vars,Vars,true,nocut) :-
+	getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[atom,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+	atom(Value),
+                (debug(on)->(writeln([exit,[atom,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[string,[Variable]],Vars,Vars,true,nocut) :-
+        getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[string,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        string(Value),
+                (debug(on)->(writeln([exit,[string,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[number,[Variable]],Vars,Vars,true,nocut) :-
+        getvalue(Variable,Value,Vars),
+                (debug(on)->(writeln([call,[number,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+        number(Value),
+                (debug(on)->(writeln([exit,[number,[Value]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[variable,[Variable]],Vars,Vars,true,nocut) :-
+        var(Variable),
+                (debug(on)->(writeln([call,[variable,[Variable]],"Press c."]),(not(get_single_char(97))->true;abort));true),
+                (debug(on)->(writeln([exit,[variable,[Variable]],"Press c."]),(not(get_single_char(97))->true;abort));true).
+
+interpretstatement1(_F0,_Functions,[Operator,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+	isop(Operator),
+	interpretpart(is,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[Operator,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(31),
+        isop(Operator),
+        interpretpart(is,Variable2,Variable1,Vars1,Vars2).
+	
+interpretstatement1(_F0,_Functions,[+,[Variable2,Variable3,Variable1]],Vars1,Vars2,true,nocut) :-
+%%writeln(4),
+        interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+%%interpretstatement1(_F0,_Functions,[Variable2+Variable3,is,Variable1],Vars1,Vars2,true,nocut) :-
+%%writeln(41),
+        %%interpretpart(isplus,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[Variable1,[Variable2,Variable3]]],Vars1,Vars2,true,nocut) :-
+%%writeln(5),
+        interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+%%interpretstatement1(_F0,_Functions,[[Variable2,Variable3]=Variable1],Vars1,Vars2,true,nocut) :-
+%%writeln(51),
+%%        interpretpart(match,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[Variable1,[Variable2]]],Vars1,Vars2,true,nocut) :-
+%%writeln(52),
+        interpretpart(bracket1,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[=,[[Variable1],[Variable2]]],Vars1,Vars2,true,nocut) :-
+%%writeln(53),
+        interpretpart(bracket2,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[head,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(6),
+        interpretpart(head,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[tail,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(61),
+        interpretpart(tail,Variable1,Variable2,Vars1,Vars2).
+
+
+interpretstatement1(_F0,_Functions,[member,[Variable1,Variable2]],Vars1,Vars2,true,nocut) :-
+%%writeln(8),
+        interpretpart(member,Variable1,Variable2,Vars1,Vars2).
+
+interpretstatement1(_F0,_Functions,[delete,[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+%%writeln(),
+        interpretpart(delete,Variable1,Variable2,Variable3,Vars1,Vars2).
+%%** all in form f,[1,1,etc], including + with 0,1
+
+interpretstatement1(_F0,_Functions,[append,[Variable1,Variable2,Variable3]],Vars1,Vars2,true,nocut) :-
+%%writeln(9),
+        interpretpart(append,Variable1,Variable2,Variable3,Vars1,Vars2).
+
+interpretstatement1(Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
+%%writeln("h1/10"),
+        Query1=[Function,Arguments],
+%%writeln(["Arguments",Arguments,"Vars1",Vars1]),
+        substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs), %%% var to value, after updatevars:  more vars to values, and select argument vars from latest vars
+%%writeln([substitutevarsA1,arguments,Arguments,vars1,Vars1,vars3,Vars3,firstargs,FirstArgs]),
+        Query2=[Function,Vars3], %% Bodyvars2?
+%%        	debug(on)->writeln([call,[Function,[Vars3]]]),
+%%writeln(["Query2",Query2,"Functions0",Functions0]),
+        interpret2(Query2,Functions0,Functions0,Result1), 
+	updatevars2(FirstArgs,Result1,[],Vars5),
+	updatevars3(Vars1,Vars5,Vars6),
+	reverse(Vars6,[],Vars7),
+	((not(Vars7=[])->
+	%%Vars7=[Var71|Vars72],
+	unique1(Vars7,[],Vars8)
+);(
+writeln(here1),
+	Vars8=[])).
+%%**** reverse and take first instance of each variable.
+	%%findresult3(Arguments,Vars6,[],Result2)
+%%writeln(["FirstArgs",FirstArgs,"Result1",Result1,"Vars5",Vars5,"Vars4",Vars4]),
+%%writeln(["Vars1:",Vars1,"Vars4:",Vars4]),
+%%		debug(on)->writeln([exit,[Function,[Result2]]]).
+interpretstatement1(Functions0,_Functions,Query,Vars,Vars,true) :-
+	Query=[_Function],
+        	debug(on)->writeln([call,[Function]]),
+        interpret2(Query,Functions0,Functions0,_Result1),
+        	debug(on)->writeln([exit,[Function]]).
+
+
+interpretstatement1(_Functions0, _Functions,_Query,_Vars1,_Vars2,false) :-
+	writeln([false]).
+
+interpretstatement2(Value,_Vars,Value) :-
+	(number(Value);atom(Value)).
+interpretstatement2(Variable,Vars1,Value) :-
+	getvalue(Variable,Value,Vars1).
+interpretstatement3(A + B,Vars,Value1) :-
+        interpretstatement2(A,Vars,Value2),
+        interpretstatement2(B,Vars,Value3),
+        Value1 = Value2 + Value3.
+interpretstatement3(Value,_Vars,Value) :-
+	(number(Value);atom(Value)).
+interpretstatement3(Variable,Vars,Value) :-
+        getvalue(Variable,Value,Vars).
+getvalue(Variable,Value,Vars) :-
+        ((not(isvar(Variable)),isvalstrorundef(Value),Variable=Value);
+        (isvar(Variable),isvalstrorundef(Value),getvar(Variable,Value,Vars))).
+putvalue(Variable,Value,Vars1,Vars2) :-
+        ((not(isvar(Variable)),isvalstrorundef(Value),Variable=Value);
+        (isvar(Variable),isvalstrorundef(Value),updatevar(Variable,Value,Vars1,Vars2))),!. 
+getvar(Variable,Value,Vars) :-
+        member([Variable,Value],Vars),
+	not(Value=empty).
+getvar(undef,undef,_Vars) :-
+	!.
+getvar(Variable,empty,Vars) :-
+        not(member([Variable,_Value],Vars));
+	member([Variable,empty],Vars).
+updatevar(undef,_Value,Vars,Vars) :-
+	!.
+updatevar(Variable,Value,Vars1,Vars2) :-
+	((((member([Variable,empty],Vars1),
+	delete(Vars1,[Variable,empty],Vars3),
+	append(Vars3,[[Variable,Value]],Vars2));
+	((not(member([Variable,Value1],Vars1)),
+	((Value1=empty)->true;(Value1=Value)))),
+        append(Vars1,[[Variable,Value]],Vars2));
+	(member([Variable,Value],Vars1),Vars2=Vars1));
+	(undef(Variable),
+	append(Vars1,[[Variable,Value]],Vars2))).
+updatevars(_FirstArgs,[],Vars,Vars).
+updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
+        Vars1=[[Variable1,Value]|Vars4],
+	((member([Variable2,Variable1],FirstArgs), %% removed brackets around firstargs here and 2 line below
+	append(Vars2,[[Variable2,Value]],Vars5));
+	(member([Variable1,_Variable2],FirstArgs),
+	append(Vars2,[[Variable1,Value]],Vars5))),
+	updatevars(FirstArgs,Vars4,Vars5,Vars3),
+	!.
+updatevars(FirstArgs,Vars1,Vars2,Vars3) :-
+	Vars1=[_Vars4|Vars5],
+	updatevars(FirstArgs,Vars5,Vars2,Vars3).
+updatevars2(_FirstArgs,[],Vars,Vars).
+updatevars2(FirstArgs,Vars1,Vars2,Vars3) :-
+        Vars1=[[Variable,Value]|Vars4],
+        (member(Variable,FirstArgs), %% removed brackets around firstargs here and 2 line below, ** vars1 into arg in (10), check cond
+        append(Vars2,[[Variable,Value]],Vars5)),
+        updatevars2(FirstArgs,Vars4,Vars5,Vars3).
+updatevars3(Vars1,[],Vars1).
+updatevars3(Vars1,Vars2,Vars4) :-
+	Vars2=[[Variable,Value]|Vars5],
+	delete(Vars1,[Variable,empty],Vars6),
+	append(Vars6,[[Variable,Value]],Vars7),
+	updatevars3(Vars7,Vars5,Vars4),
+	!.
+updatevars3(Vars1,Vars2,Vars4) :-
+	Vars2=[[Variable,Value]|Vars5],
+	append(Vars1,[[Variable,Value]],Vars6),
+        updatevars3(Vars6,Vars5,Vars4).
+reverse([],List,List).
+reverse(List1,List2,List3) :-
+	List1=[Head|Tail],
+	append([Head],List2,List4),
+	reverse(Tail,List4,List3).
+unique1([],Items,Items).
+unique1([Item|Items1],Items2,Items3) :-
+	delete(Items1,Item,Items4),
+	append(Items2,[Item],Items5),
+	unique1(Items4,Items5,Items3).
+
+isvar(Variable) :-
+	atom(Variable).
+isval(Value) :-
+	number(Value).
+isvalstr(N) :-
+	isval(N);string(N).
+/**isvalstrempty(N) :-
+	isval(N);(string(N);N=empty).**/
+isvalstrempty(N) :-
+	isval(N),!.
+isvalstrempty(N) :-
+	string(N),!.
+isvalstrempty(empty) :- !.
+/**isvalstrempty(N) :-
+	atom(N),fail,!.
+**/
+isvalstrorundef(N) :- 
+	var(N);(not(var(N)),(isval(N);expression(N))).
+undef(N) :-
+	var(N).
+/**
+expression(N) :-
+	isval(N);(string(N);atom(N)),!.
+expression([]).
+expression(empty).
+expression([N]) :-
+	expression(N).
+expression([N|Ns]):-
+	expression(N),expression(Ns).
+**/
+
+expression(empty) :-
+	!.
+expression(N) :-
+	isval(N),!.
+expression(N) :-
+	string(N),!.
+expression(N) :-
+	atom(N),!.
+expression([]) :-
+	!.
+expression(N) :-
+%%	not(atom(N)),
+	length(N,L),L>=2,
+	expression2(N).
+expression2([]).
+expression2([N|Ns]) :-
+	expression3(N),
+	expression2(Ns).
+expression3(N) :-
+	isval(N),!.
+expression3(N) :-
+	string(N),!.
+expression3(N) :-
+	atom(N),!.
+
+expressionnotatom(N) :-
+	isvalstrempty(N),!.
+expressionnotatom(N) :-
+	not(atom(N)),
+	length(N,L),L>=2,
+	expressionnotatom2(N).
+expressionnotatom2([]).
+expressionnotatom2([N|Ns]) :-
+	isvalstrempty(N),	
+	expressionnotatom2(Ns).
+
+substitutevarsA1(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
+	substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2).
+substitutevarsA2([],_Vars1,Vars2,Vars2,FirstArgs,FirstArgs).
+substitutevarsA2(Arguments,Vars1,Vars2,Vars3,FirstArgs1,FirstArgs2) :-
+	Arguments=[Variable|Variables],
+	((getvalue(Variable,Value,Vars1),
+	Value=empty)->
+	((append(Vars2,[Variable],Vars4)),
+	(isvar(Variable)->append(FirstArgs1,[Variable],
+	FirstArgs3);FirstArgs3=FirstArgs1));
+	(getvalue(Variable,Value,Vars1),
+	append(Vars2,[Value],Vars4)),
+	FirstArgs3=FirstArgs1),
+        substitutevarsA2(Variables,Vars1,Vars4,Vars3,FirstArgs3,FirstArgs2).
+
+findresult3([],_Result,Result2,Result2).
+findresult3(Arguments1,Result1,Result2,Result3) :-
+	Arguments1=[Value|Arguments2],
+	expressionnotatom(Value),
+	append(Result2,[Value],Result4),
+        findresult3(Arguments2,Result1,Result4,Result3).
+findresult3(Arguments1,Result1,Result2,Result3) :-
+        Arguments1=[Variable|Arguments2],
+        isvar(Variable),
+	member([Variable,Value],Result1),
+        append(Result2,[Value],Result4),
+        findresult3(Arguments2,Result1,Result4,Result3).
+
+
+