Notebook 25-10 2 20.txt

19 1 20 rnn queries.txt
Lg 50 for top of relig.txt
50 As for mind reading.txt
2 11 19 flp.txt
get breasoning.txt
8 1 20.txt
21 10 19.txt
machine learning 2.txt
50 comments to clear representation block.txt
Sales, education details.txt
5 2 20.txt
cawmp 2 2 20.txt
acting.txt
test cawmp with different algs.txt
List Algorithm Writer.txt
sqrt, ml.txt
cryptography.txt
28 1 20 ancient greece.txt
28 1 20.txt
Test cawmp.txt
if clause1 is false.txt
23 1 20 Ont CAWMP.txt
ont cawmp 23 1 20.txt
add rhythm, only orchestral instruments.txt
sentence to alg.txt
alien and robot communicators.txt
Cosmology and Area of Study.txt
20 1 20.txt
Ont to alg is cawmp.txt
Music learning memory.txt
do essay preparation as writer.txt
music composer that retains word rhythm.txt
Clause bracketing in Spec.txt
No non-deterministic multiple clauses.txt
multiclause nondeterminism lp workaround.txt
remove.txt
problem of input and output with multiple predicates.txt
predicatename_existing turn back on.pl
check multiclause.txt
multiple outputs.txt
humanities alg.txt
p to v.txt
remove all ->.txt
Its solution with a=1,2.txt
untitled text 45.txt
untitled text 26.txt
untitled text 32.pl
untitled text 37.txt
untitled text 28.txt
Make bottom up entry version for CAWMP.txt
bt bug.txt
findalls -> pred algs.txt
24 12 19 5.txt
s2mls.txt
verify spec.txt
n,1 a+b n,2 a-b with rules not dict.txt
music 21 12 19 4.txt
- necessary.txt
n,[].txt
warning when length spec < maxpredicates.txt
20 12 19 untitled text 12.txt
20 12 19.txt
try test 1 with 1 spec v works.txt
cawmp may need multiple specs per pred.txt
18 12 19.pl
bottom up for cawmp.txt
cawmp multiple clauses.txt
17 12 19.txt
16 12 19.txt
recordings tt.txt
simplified caw 10 12 19.txt
notes 13 12 19.txt
twitter, fb touch.txt
text to speech.txt
4 12 19-2.txt
7 12 19.txt
LPI can't backtrack to multiple solutions.pl
LPI's cut.txt
mind read - tell to meditate.txt
alg writer qa.txt
Type statements can't be used with CAW.txt
CAW.txt
Bugs lp.txt
old find types.txt
4 12 19.txt
30 11 19.txt
28 11 19.txt
28 11 19-2.txt
27 11 19.txt
10 failure companies.txt
25 11 19.txt
24 11 19 dataalgdict and question answering to write state machine.txt
hr alg and phil brs.txt
8 8 19-2.txt
22 11 19-2.txt
Pitch bots.txt
songs 22 11 19.txt
22 11 19.txt
9 11 19.txt
16 11 19.txt
masters algorithm generator 7 11 19.txt
music mr->lp.txt
Algorithm writer 3 11 19.txt
have types and data.txt
v,a expanding to n,a v,b.txt
Advantages of types.txt
Shells are replaced by Functional List Prolog x.txt
can t a in one line be read in another line.txt
findall.pl
[n,_] not in body of type statements.txt
Russell FLP 1 11 19.txt
Flp.txt
Instead of a double type system.txt
not predicate or rule name - or variable name.txt
31 10 19 Types and Finding Intermediate Functions.txt
affects strong type checker.txt
any type.txt
STLP Type Statements.txt
FLP type statements.txt
alg writer with multi choice.txt
Passed queries only have necessary data.txt
Functional List Prolog x.pl
Functional List Prolog.txt
28 10 19.txt
alg writer 2 - 24 10 19.txt
alg writer 24 10 19.txt
TextToAlg Computational Description.txt
A Program Finder (pf).txt
best rnns text prediction github
rnn github question answering
*1
Lg 50 for top of relig
*1
50 As for mind reading, 3 Bs Of politenesses
50 for time travel
Do instead of Bhagavad-Gita
*1
Modify alg
Enter existing alg
Writes rest of alg after peeling back line by line, gives line number where changes start
*1
10 alg writers, like rcawp
- data replacer alg writer
- cawp2 that makes up data, alg
- p2lp and an alg that saves calls to sub-predicates of long algorithms
8 1 20
*1
* do similar to ctt bt pred for masters uni
- find algs with random/mr data, comp verbs implying spec with alg logical struct
- rec type of area of study is * 20 if mr not working (to compensate)
- mr student's br num, pred num per br, individual br count, then mirror it
- the system updates with student and helps find bugs
- mr-choose alg lib items, parameters x tries all old preds with run all, then tries cawmp
*2
mr,r,ui cawmp
*3
***
neural networks preparation
- input through file, not through other means
***
logic, grammar
- alg to sent and of *
- sent to alg and of *
(- data generator, verifier from rules
- takes out data, operates on, puts back (instead of alg modifiers)
* - intersection of algs with types of types
- functionalism
Rules to transform sentences into
Logic and Grammar
Ontologies to
data, alg
Some rules are assumed give true, false conditions
- interpretation of sentence
- given department, alg technique
ontologies
- humanities
- science
- psychological
***
generate all areas of study with cawmp, convert to sentences
- logic, grammar x
21 10 19
- scalable interpreter
- LP can turn on(/off x) date time library with consult
- run all's philosophy is running faster versions of algorithms, can test the actual thing in each algorithm
machine learning
- 50 to turn off mistakes
50 comments to clear representation block
Sales, education details
50 words or 5 answers from area of study, seen as version in alg writer lists
- funnel multichoice of 4
200 per day for my course students, all up to 10 sales
Collect viable prods From my purchases
Bots for sales
Found out alg with bot and bot run on same day
Hand br 80 br per day to keep students
Or 5 algs found out per person per day
Or 50000 As instead of 5 and culpate x
- employee stays there
5 2 20
if then in pf
- funnels using pf in cawmp
functionalism state machine
functionalism
- type statement for each predicate
- functions within functions with arguments in order (x use current flp with particular function and arguments used at certain positions)
- would run cawmp anyway with type statement to check fn'ism
- pf uses things like type statements, but checks for conjunctive and functional predicates' properties before funnelling and trying rules
cawmp 2 2 20
()
[not
if2,3
or
brackets in these
]
just need calls to itself and other preds,
random data
program finder x use different commands e.g. equals2, if etc. later
if in dict, tries - too slow
with cawmp bug fixed, should write multiple clauses and have single spec x very slow to try all combos from single spec
alg that verifies properties of spec to find the right spec set (and spec set from spec) and alg () just alg x cawmp
keep multi spec, which can generate based on first spec, run cawmp
- ont->first spec later (ml?)
acting, sales
ont cawmp
()mind reader
interpreter in cawmp
- in simple list prolog
- spec by clause
- dependent on other clauses
test cawmp with different algs
- ontol to specs
- qa ask for data structures based on computational verb
- store in dictionary - many cvs to one spec (like t2b)
- data (spec) generation algs write data based on clues from nouns, verb
- data is passed from one alg part to another and more specs are generated
* connect (all simple, multiple) dict specs together
x first spec line is broken into hierarchies of specs
- first thought from dance, second thought from dance, data are defined in comments, new spec - sentences are analysed to find data structures, spec
- use "Please fill in." for unknown data
- if new language, identify separate algorithm in one of the steps
- use label as well as spec
- separate spec tester and dictionary algs x find alg parts from specs (with queries for separate parts to test), then save for modification
- functionalism for lists of lists, etc. - do later
- words like *wildcard, list (can have synonyms and) trigger certain structures
- x use texttoalg with previous line *
for b, identify new fail case and for b solution, simplify data
- if the above sentence was an alg sent, then would find b alg and apply fail case (an alg operation that simplifies data)
- b is a class of algs with name [b,*]
- 10 Bs which apply to content (e.g. if B to word "content", then insert a mistake)
- e.g. B not x
- * B is also in alg dict
- templates x words for two uses, list recursion
- br out random algs ** (if ** was an alg sent - [random_algs, br], where the ontol/grammar matches POS after asking for verb, noun, 
chooses furthest apart n, v pair x separate lists)
10 random data items per list of same type
avoid data repeating in list
b replaces with other data of same type
- to generate detail sentences, replace with own brdict2 word's brdict1 word or n with box or obj, v with right and a with plus
- x use (start of gla with x following takes care of sentence keywords) algwriter, taking care of b, b sols and details
List Algorithm Writer generates simple random algorithms in List Prolog
https://t.co/abexWJmvIx?amp=1
and Prolog
https://t.co/YFGfiGrTZM?amp=1
sqrt in lpi docs v
5 centres in each chapter
of ~1 mil github rnn iterations
ml phil, algs
cryptography of mind reading, time travel
28 1 20 ancient greece
set stories from each chapter in ancient greece
- use details from phil, essaylib to write a story with dramatica (to find phil in terms of english)
- group characters by side
- use 10, including reasons (so do phil first) details per sentence
- definitely write down details, and publish separately (possibly too late to do as a secondary text under a pseudonym)
- write skeleton in dramatica, then use details to shape grammars
- use cawmp to give 4*50s to each detail - * do first
- classical paintings, classical music with cawmp behind them ()-this is done later, by the earlier qualities
- can also write new lyric stories for songs in this way
- dialectics take so much effort, that only leave two uses as done
- keep only 10s x do rest of phil, algs as planned
***
10s or supercomputer in phil, music
- also X or sc for conns
- students are the commenting voice (5 comments each by a different student), like the professor is the text's voice
- 5 departmental persps per main sentence in para (5 paras per chapter) - before listening to comments
- do (3) alg run(s) first, 5 per alg
- left over texts are also usable
- questionable, seemingly too specific algs are science, so keep them
- 5 as you go
- a qa alg asks for sentence, its idea, what alg it means, the alg in list prolog, 5, saves data
- x do phil writing, with some algs
28 1 20
Try sample programs with CAWMP
Style is naming, data
Put algorithms written into CAWMP ont, spec form for future alg writing
- can bracket or funnel customer algs x
X not as easy as programming as self
Test cawmp more before r/mr cawmp
B, Ont, r, mr cawmp bottom up
cawmp
if clause1 is false, then can keep if previously true before finding clause2
? find why cannot find two clauses in cawmp when fails
- if fails, then don't want unless passes another time
- check order - that trying existing is always before new branch
- make clause specs - cawmp *
***
Does CAWMP work with multiple (and multiple predicate-calling) clauses?
- *
23 1 20 Ont CAWMP
Recursive sentence structure -> recursive algorithm structure
* check philosophies for evidence
Human Resources
- Tell what they're saying
- Verification
- Verify against philosophy
- funnelled
- pos, neg language
- New details
- Connect
- Complete
Task list
- CAWMP
- with clause [[Spec]]
* Check notes around this
qa for working out base case specs
- clause not multiple clause specs
- to simplify qa
recurs.
- 3 arg
- 2 lists (see ctt)
- introduce all new args at start
- bottom up
- list all args to put in parent pred for qa
- label args at time, put in documentation of first pred
- can search for matching (alg or xx) alg name later - with qa
- in terms of ... types x alg name, alg not spec
- then spec if not found
qa asks for alg name, then data (not recursive data)
---
qa asks for key term in sent, then its computational verb (cv), then its component cv's, then specs (are cvs and, ->/functional, multi-clause?)
x (algwriter for cvs x cawmp includes this x use and) cawmp for conn bw cv algs
- use random data
x algs are too integrated/intertwined/customised - use list alg writer
add rhythm, only orchestral instruments in music composer
- what sounds good in past songs, use
- more notes in melody
sentence to alg
- find computational verbs in sentence, *
find alg parts for them bottom up, connect with cawmp
- use functionalism for joined sections that are in recursive loops
- computer: asks for parts of sentence, grammar of sentence, spec - doesn't need spec, needs algs that can join together, but if not in dict then needs to write alg from specs
- how will it find alg from specs that are joined together - identifies the spec from types in dict - also needs to create spec by splitting sentence into two computational verbs - or just goes straight from cv's to spec
- dicts 
* don't give nn complex data
- will learn items in lists
- will work out order of cvs?
- will work out type of data?
- should check nn for inconsistencies with >=2 choicepoints.
- don't use nn, and write phrase finder with human-broken down sentences with each cv, relation and (type of type of) data (123) - like t2b
- cvs may contain other cvs, be recursive, have data at bottom - be translatable into spec
- directly enter 123 into alg
- keep this, don't just enter input and output specs x no point entering 123, just enter spec, output 123 afterwards x easier to enter 123 than spec
- use cawmp not just alg dict
- cawmp can glue together parts of alg dict
- parts of alg dict chosen from cvs
- 123 hierarchy is entered as compound term - in LP-style not Prolog
- perhaps better to name dict algs, then connect with cawmp
- alg should connect cvs to multi-cvs, user should enter data once and retrieve new alg as output
- if a missing cv x would enter all
- alg tests spec end-points match
- not cawmp, but an alg rewriter
- x just use parts of previous algs and hand code
***
- can enter minimum 1 piece of info to find alg
- keep spec in dict, asks for spec if prev doesn't work
- new clauses may be bottom level or require other sets of clauses
- dicts: cv->spec name->spec
- dicts: [cv->spec name->spec (hierarchical, recursive)]
- can find bottom-up
- can generate sentence
alien and robot communicators
Cosmology is 50 bs etc to mistakes
B to other forms of cosmol
Area of study is rec of chapter
Area of study for
Music song
Video
Article
Wikipedia article
10 (required when complete) time travel
Area of study for industry of uni area of study
use essay lib instead of using neural networks for phil
- x millions of iterations, word2vec
- pgrad details, sentences
- accredited students - enough done
- do all algs
- write specs for many, let nn predict sent->ont->spec (possibly doesn't require nn)
- don't have details, it just has to have enough sentence (can continue writing myself), don't need nn
- new students can be done with mind reading and new algs
- essaylib for word2vec
- only area of study can be done, too many students -> to recordings level (every single interconnection) - may not need nn
2020
human - sent phrases->spec (1 in 10 x most of hq algs done with small idea spec) ()
- spend 2020 finishing up to societol phil, cont writing
other priorities
- interconnections
- mind reading ()
- details ()
- nn if nec ()
interconnections replace need for alg to sentence x
do traces without printing them to screen
- double =,is in interpreter?
philosophy programming language
- list prolog with e.g. what is the idea, simulation - students program these libraries
Ont to alg is cawmp
Music
Learning, memory
*
Kings, Political leaders, Gods
3 not 2 mr levels
do essay preparation as writer,
may not need
b, b to b
ontology cawmp
x do as well
music composer that retains word rhythm
Clause bracketing in Spec
[[Clause1A,Clause1B],[Clause2A,Clause2B]] *
[Clause1,[Clause2A,Clause2B]]
Clause1
x give errors different from *
because can't easily differentiate between clauses of different predicates
There is no such thing as non-deterministic multiple clauses because if a clause returns output, then it will be the only solution. Only if a clause fails will another clause be tried. This is not non-determinism.
multiclause nondeterminism lp workaround
- use list processing to simulate "or"
remove -> from interpret for cawmp to work
findall in try interpret
- List Prolog and Prolog are useful for single-line of execution (not nondeterminism, but if-then) of programs. Use for generating programs, but mainly program own algs which may be nondeterministic.
problem of input and output with multiple predicates
- removing -> from lpi to make work means running interpretbody twice
- requires algorithms to use ->, not rely on predicates
predicatename_existing,predicatename_new_branch turn back on after testing test 8
check multi-clause args are inputs, output as expected
analyse writelns in terminal
why doesn't alg write all n clauses, then
- start with 1, then up to n
- writes new clause after any command x
objects br in monologues
multiple outputs
- specs to avoid aa not ab and two e problems in test 7
humanities alg
- cawmp with qa to find other content for algs in philosophy
p to v
remove all -> to make [[n,add0],[[v,a],[v,b]],":-", 
[[[n,add2],[[v,a],[v,c]]],
[[n,=],[[v,c],[v,b]]]]], appear in V
Its solution with a=1,2
[[[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,add3],[[v,c],[v,d]]],[[n,=],[[v,d],[v,b]]]]]]
Call: (22) find_rule_name(predicatename_existing, _5976) ? skip
Exit: (22) find_rule_name(predicatename_existing, predicatename_existing) ? creep
bugs
not adding commands after first one
n,1 appearing
spec inputted v should work
spec dependencies x should already work
- write alg base up x should work
check cawmp does have pred header values when backtracks
why pred exist writes extra copy of pred name
print caw info
- test num io etc
call children first in combo
predicatename_new_branch
other_new_branch
[rules_new_branch,_]()
predicatename_existing * - remove more ->, check, check if overlooks sol
rules_existing *
pp0 not printing algs correctly
- find where algs are concat
every var mentioned
twice
can't find 
[[n,add0],[[v,a],[v,b]],":-",
in trace
- investigate ->s
* -> x in interpreter - for non-determinism multiple clauses with same name with output
*()-[unnec x test works before *2] Make bottom up entry version for CAWMP
- finds multiple clauses with same name, recursive clauses by making a predicate that calls them, moving bottom up and calling the multiple clauses with the same name (a level below the predicate that calls them)
- possibly reverse Algorithms to call the upper predicates first
-- test alg can write nondet clauses, then do s2mls
- s2mls x write alg backwards (and forwards, meeting in the middle) x forwards, using qa
- calls cawmp if nec
- writes specs, connects specs together
- give rules to write alg (using recursive templates x modified cawmp *2 x better to write spec, not alg first - write as go, running code so far to find new input spec, doesn't require input after initial input spec, can do non r,mr cawmp this way, also for manual entry (me): identifying dependent segments in spec to do together when bottom up - like backtracking symbols to specs, checks spec matches data on way - with full spec does it need bottom up? - yes - so scrap input for new preds computation and check and have qa, but top down ok too for mr, r - me is bottom up and top down) and spec (saves along way x), not: uses templates with e.g. list checked against list to produce list, numbers as data
- bottom up is faster, if could do qa, would be better for r,mr,me x too difficult to split single spec, so top down
- do lpv with rec
s2mls x 
- splits single line specification into multiple lines
- splits on choice points in lists
- tries 1, then multiple choice points
() Algorithm generator
---
()
Program Finder for multiple lists
- for repeating data
- parts of program finder's predicate can be put into cawmp
- * don't need num io in call's parameters because in dictionary - put in notes
CAWMP
- for unidentified (transformed) data
- identifies constants ()
- uses multiple predicates as if-then - tries on purpose ()
for test 1 working again
- put cuts in to simplify trace, trace at point to find backtracking bug
findalls -> pred algs to stop backtracking problems with caw x
try turning off preds in caw with findall etc
test preds, put cuts in to fix bug
try different combinations of features across tests 1,3 working
- write diff based program
- Prolog
test cawmp tests
single to multiple line spec alg (s2mls) *
- pro: 1 finds alg using simplified data fast
- con: 2 alg writer could find alg using dict, not old spec, making * obsolete
1 is stronger
- is simpler
- s2mls connects specs together - i to o
- different spec pointer instances for different data types in same spec
- generates specs
- simplified data format, e.g. 132 for unordered list, "aa" for word, constants remain the same
- spec is [1,3,2]->[1,2,3], i, o labelled
- random, manual entry, mind reading versions
- doesn't remember computational verb, just enter single and multiline specs and saves (both x multiline) specs, displaying output as single lines
- multi-predicate deep specs are together, and alg finds conjunction of specs
- multiple i, o - chooses specs in conjunction
- disjunction is already given
- must test a spec before entering it
- in random and mind reading modes, don't enter, just read specs
- functions and variables in spec language, types - x too complex
- easy spec output to write alg more easily ()
s2mls is caw with specs in dict, with e.g. wrap
- uses dict of single line specs to check 
and
- x problems if simple i,o specs - generate one line spec (with mind read seen as version), one to many lines *** need caw
- use s2mls if can't generate algs fast enough, (use anyway to generate specs from lists, strings)
- type checker could have used caw
verify spec
n,1 a+b n,2 a-b with rules not dict
- test parameters
- need a supercomputer
4 notes per mel, harmony
t2 for inst 2
asc2mid
la strings, t2qb
format of lyrics
- necessary
cut on caw
num inputs outputs 01234->1
+ necessary
remove rules new branch
n,[] 
- covers all vars is run at end of alg - flag?
warning when length spec < maxpredicates
[[[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]]]]]]
other_new_branch
- should be dict algs
not rule commands
reduces from maxlength, not counts up and compares with maxlength x
should first clause of caw end in caw to reduce maxlength x maxlength of that value hasn't worked x call caw with same maxlength x won't need to (to return sol or) to reset nondet vals
add (named) rules new (and existing x) branches
cut and write interpret
try test 1 with 1 spec v works
cawmp may need multiple specs per pred
- test if multiple specs, do second tests accordingly
- need to check dict with cawmp
add multi preds with 1234 option at branch point
caw00(off,function3,[],5,1,7,[[[[[[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]]],[],Program),writeln(Program).
interpret(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,a],[v,d]]],[[n,=],[[v,b],[v,c]]]]]],[[[[v,c],2]]])
?
interpret(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]]])
test each predicate
find whether predicate calling rule fails to caw00 or caw
interpret(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,a],[v,d]]],[[n,=],[[v,d],[v,c]]]]]],[[[[v,c],2]]])
caw00(off,function3,[],5,1,7,[[[[[[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]]],[],Program),writeln(Program).
caw00(off,function3,[],2,1,4,[[[[[[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]]],[],Program),writeln(Program).
bottom up for cawmp
- speed
warnings for incorrect dict entries, non spec-dict matches
modify rules predicate for no inputs
ab not aa inside calls x
what does cawmp do about multiple clauses and specs at the moment
17 12 19
- Have used CAWP to produce base case but not rest of algorithm calling it.
- Need variables from partial algorithm, but don't know which are inputs and outputs
- Could use specs to work out which are inputs and which are outputs.
- Partial algorithms and so the initial question are lower priorities than creating whole algs, so took a break.
16 12 19
predicatename_existing
other_new_branch - needs i,o n rule123
predicatename_new_branch 
that recordings value ~60b is required for time travel
simplified caw 10 12 19
not(certain, single statement) - add to interp
- out=out, comparison, call (not where not 2 outs) x any x =,comparison, member, head out out, tail out out, append 3 out, string concat 3 out
no if
grammars x string concat
or x
=[],"" (don't define inputs so they can be used as constants)
open calls x
* look up commands, body structures
list building, decomp (get item n) - calls commands from command x in library
- test types prior to interpretstatement
123 11 12 13 multi clause/pred
- calls only to existing preds
- bug: wanted program not reached (or was there another solution before it?)
- write new clause only for first predicate or when there is a call to it.
length(program)=<maxpredicates
append newly created preds to rules
not assertz for newrulenumber *
need rule predicates
pred names pn_n *
equals2,grammar_part,stringconcat change order of arguments in egs, lpi
does add rules add = for each output var *
- check i then o for all lp commands
run caw again for more preds
add rule names from interp
varlists now list of specs
need to pass max predicates
only try adding new pred when < mp
try changes one by one
why is Algs _ ?
try smaller multiple clause eg
correct eg + to n,+ in cawp readme
remove -> from caw before ->
totalvars x new clause vars unique for each clause v
* list of specifications only needs to be long enough to reach previous algs in dictionary.
Note: Richard Dawson: write a separate predicate in CAWMP (combination algorithm writer with multiple predicates) that accepts partial algorithms and progress on predicate so the algorithm can be completed.
variables in calls skip, not quite right
trace at here, why doesn't i+o=arity
make [], "" i, o not just i or o
- same for string, etc in lpi
add rule referring to self,
maxlength when giving partial alg
give alg start of alg
test 61 not 62
not finishing code
- maxlength x?
- maxpredicates, etc x?
test concat of algs
spec: [[],[],[,]] where [,] is multi clause spec
- error on badly formed grammar
program finder for base cases
- account for all vars
- except non [] etc. constants
- try combos
assertz maxdepth,varlist to keep 1 varlist per depth
VarLists0=[VarLists1|VarLists2],
-is it the full vl
CAW with multiple predicates now means that breasoning generation is possible. Breasonings can be used for sales, mind reading and time travel thresholds reached.
text to speech
way it's thought (speech adjectives) x
4 12 19
upload cert, etc. v
song v
do multiness to caw
- just caw (which has multiple preds in dict), and uses data rather than predicate name specifiers
- can specify data using qa, eg grammar check, translate, spell check
- do comp phil algs
- ff not resynth formulas (with caw)
- replace data in found alg with mr data
- organise day (what you do, how and details) to find initial 10 in mr
- " in further 10s
- (qa eg. what do you need to do with it (when, who, how, how many, is there anything else?)
- how->algorithmic transformations
- finished with data->end of alg) - difficult to write desc-dict and dict-alg rels because desc might change
- ask questions about recursion (not caw, just qa)
- run all not caw
- x algs more complex, write them separately
- ask whether any repetitive data or data that could be processed automatically appeared during day
- ask for rudimental transformations x just data, try the existing transformations or ask user to enter their own
- x data needs transformations x just data - only find, randomise structure if not manually entered (generate data based on mp, etc.)
base algwriter algs on combos ("10s") of previous algorithms
- replace data stubs in existing data formats with mr etc.
- don't worry about data changing rather than alg changing because it would have been like it eventually
- dict of combo ns (numbers e.g. ped-twouses-1-1, filenames of algs - files with queries, algs (types optional)
%%
- do algs (not made up ones), then generated ones
- alg that writes content is nec too (perhaps based on brdict2, self-other, approach brdict1, random grammar)
- change variable names as well as data
10 12 19
multi-predicates x because other predicates need their own specifications, which are too difficult to find, (and modes of predicates written by the algorithm cannot easily be worked out x they are known because the predicates were written).
- could give series of specifications, the relations between give rules of alg
- not multi pred because can have enough variety of preds to cover multi clauses, multi levels, and can join together sessions of caw because connections between alg parts need to be custom done.
7 12 19
why didn't converted code work v p2lp member ab->ba, ":-" and "->"
make alg that splits on n words
- records multiple algs
- br out assignment 50, content
test(60,[[n,testcut1],[[v,a],[v,b],[v,c],[v,d],[v,e],[v,f]]],
[
[[n,testcut1],[[v,a],[v,b],[v,c],[v,d],
[v,e],[v,f]],":-",
[
[[n,member2],[[1,2,3],[v,a]]],
%%[[n,cut]],
[[n,member2],[[4,5,6],[v,b]]],
%%[[n,cut]],
[[n,testcut2],[[v,c],[v,d],
[v,e],[v,f]]]
]],
[[n,testcut2],[[v,c],[v,d],
[v,e],[v,f]],":-",
[
[[n,member2],[[7,8,9],[v,c]]],
%%[[n,cut]],
[[n,member2],[[10,11,12],[v,d]]],
%%[[n,cut]],
[[n,testcut3],[[v,e],[v,f]]]
]],
[[n,testcut3],[[v,e],[v,f]],":-",
[
[[n,member2],[[13,14,15],[v,e]]],
%%[[n,cut]],
[[n,member2],[[16,17,18],[v,f]]]
%%[[n,cut]]
]]
] ,_).
%% [exit,[[n,testcut1],[1,4,7,10,13,16]],"Press c to creep or a to abort."]
%% LPI can't backtrack to multiple solutions, so cut is only useful for returning a single solution with cut at the end of a predicate (not preventing backtracking over a cut)
test(60,[[n,testcut1],[[v,a],[v,b]%%,[v,c],[v,d],[v,e],[v,f]
]],
%%test(60,[[n,member3],[[v,a]]],
[
[[n,testcut1],[[v,a],[v,b]%%,[v,c],[v,d],
%%[v,e],[v,f]
],":-",
[
[[n,member3],[[v,a]]],
[[n,cut]],
[[n,member3],[[v,b]]]
%%[[n,cut]]
%%[[n,testcut2],[[v,c],[v,d],
%%[v,e],[v,f]]]
]],
[[n,member3],[1]]
] ,_).
?- test1(on,60,R).
[call,[[n,testcut1],[[v,a],[v,b]]],"Press c to creep, s to skip or a to abort."] creep
[call,[[n,member3],[[v,a]]],"Press c to creep, s to skip or a to abort."] creep
[exit,[[n,member3],[1]],"Press c to creep or a to abort."] creep
[exit,[[n,testcut1],[1,empty]],"Press c to creep or a to abort."] creep
[test,60,passed]
R = passed.
%% LPI's cut doesn't stop backtracking, but has the side effect (now the main feature) of breaking from the predicate, cutting it off.
%% It gives only the first solution when the predicate doesn't call any predicates.
use algwriter_lists mr if works () it is the same
tell to meditate
alg writer qa
(mind reader finds rules, data
- qa
- relationship name, e.g. modus ponens reason ()
nothing in set a is in the set ()x
find duplicates
if (if one column is a, then b else c)
not
getitemn x used in other preds
random member
member
minus
substring
intersection
delete
() >, etc
() conjunction, disj truth in ff
() sum (for nums)
sort
() max
map for lists and value to value
findall for lists and value to list
can br out certain traces - cut off when reaches "50"
write in form that can be run
only words, not numbers or logic
)
x do masters with 10 algs per ass
- x 1 alg per week, for "50" As per assignment
- 10 br per sentence per assignment, br with t2b for quizzes, weekly assignments
- If there was a 6000 word essay with 30 alg br required per sentence, alg writer would be better to write
Type statements can't be used with CAW because some of the type statements needed for multiple predicates would be too difficult to write, instead mode statements can be used.
- can use the known type statements, using d2t for the rest
- x don't use type statements for uniformity, use d2t at end
- x (use [t,any] for non-known preds, use mode statements) x just start on multi-predicates
multi-predicates require format (head, tail, function, append, recursive call) where function may be found with list or string finder
CAW: "Input as mode" can mean input or output, i.e. input in programs may be treated as output by CAW. x CAW would have asked for and got input.
Bugs
test types test 10 works with wither input or output as mode, even though it is supposed to work only with input
a 1 1 a
1 a 1 a
1 can be number, string or compound
un	[[a]]	[b]
un [a]		b=[c]
a		c=a
w	[a]		d=[a]
4 12 19
When writing check arguments for find types, I worked out it would be easier to have type statements to check against, making find types obsolete in favour of type check from LPI.
- separate mode statements can be used to check inputs types at start and output types at end
- type statement generators can replace values with types
30 11 19
find types
append interpretbody bc
- reverse order
recursive
multi-predicate
- enter non base case (bc) first
^ ^ multi-predicates x one (possibly recursive) type 
V when "got specific part"
if calls an earlier predicate later, copy it to earlier
- don't call same predicate again (remember its type)
decompose, build
unwrap [[a]]
unwrap [a]
unwrap a
string a
wrap [a]
wrap [[a]]
big state machine
- bc last
do all bottom predicates before upper
single point to
multiple clauses
to multiple base cases
go up until find initial values
x start at start *
cycles - do all non bc before bc
predicates have to be done logically forward
"recursive" types - find types from all predicates in order, not finding bcs to plug into types, where recursive clauses have t->t, bc have t1->t2
checks needed types against list of known types for whole alg
brackets(brackets(var(madeup)))
to insert after wrap
line:first item,(line or end) - list
line:first item,bracket((line or end)) - recursive type
line or end - separate top levels, not one inside other to make simpler - may not need recursive (based on predicate recursion) types, makes bug checking easier
- 2 algs: one finds types of preds, other checks types of alg x need pred types to check types of alg
The whole type needs to match (no more, no less) to have same type - construct type and then see if it is already there.
- check types at call, interpret statement, outputs after returning from interpretbody
Reverse type using extra variables computed at putvar stage.
- bracket() form for types from unwrap, wrap (no [])
28 11 19
types
- returns to previous predicate after working out types bottom-up
horizontal relations in types - type name and relation to other types in name give algorithmic transformation
- data itself allows checking
- can automatically find connections through past chains of transformations from old algs between types, can edit names of types, structure of chain, etc.
only asks for horizontal relations if needed
28 11 19
find types x give type statement to cawp (add to query and dictionary)
- random words on dictionary lines of combinations of predicates x mp, valid formula
cross, hierarchy, list, cyclic, grid data structures for different things, music
10s to find proper sentences (from mus comp) avoiding need for mind reading in format The * is *. Each choice in alg has 10.
27 11 19
convert grammars - use vgp version
find types
- deletes predicate after finding type
- can have (recursive) cycles, must check and fill in recursive/list types
- stops when reaches same point
- test whether same, otherwise fails
- down, then up
- no n in reclusive types (just allows for infinite recursion)
- base case types x
startrec(type1(endrec(type2( )))) x type1(type2), type1(bc)
for example types in integrates with existing types
functional types because lists types in side types
a(b(c))
x
starts as hierarchy
a(b), a(c)
detects base cases, puts its types inside types
call ID - types
checks types fit in rec in alg, otherwise new type
- findall x alg finds types for clauses of predicate, remove duplicates
10 failure companies before being given own company
25 11 19
types finder without grammars in first version
- do later
rcaw with different algs as backup
24 11 19 dataalgdict and question answering to write state machine
Data-alg link covered through dicts to reinforce meaning and can be generated to write algs
- e.g. heights over time-difference - finds the relevant contention side (of whether spiritual meditation has lowered metabolic rate), can use to generate difference finding algs for dependent variables/e.g. height/numbers
State machines - needed for 2*2 states, not just 4 states x latter
- if steps recur in data specification, may need a state machine
- flag for past algs done to be avoided or not mattering
Human Resources (question answering about knowledge) algorithm and breasonings for the Philosophy ideas
Based on previous data about a subject's knowledge (additions to which are entered after spiritually asking in response to a computer screen prompt), the algorithm asks whether they agree with the thesis, asks them to summarise the idea and resynthesise it.
The algorithm doesn't ask for answers twice about its own knowledge of the idea, but doesn't assume a subject's knowledge.
The algorithm mind reads what algorithm parts (and parts being thought of in relation to these parts) from past knowledge are lighting up, where it has asked how the algorithms are grouped to the subject, to speed up finding the relevant part.
Mind reading time points in the day should be chronologically ordered and questions asked then. The top of 3 groups of time point determination should be taken, so subjects can react to each other. x hand-enter data from representations, not mind read, but test mind reading first.
E.g. question asking the tester to determine how the idea can be resynthesised (what parts of it can be processed) recursively, and so what knowledge can fit into its categories, such as an item, a list or a list of lists.
Question asking the tester - what parts of speech do words have - what words can connect - what is e.g. agreement (containing all positive terms, versus disagreement, which must contain a negative term, e.g. "not") - how do the knowledge ideas and ideas to resynthesise have relevance (e.g. that (the property) similarity in students' work is negative - linking to arguments on a side indicated by a subject at first for this idea.
The algorithm should telepathically-hypothesise (see what has lit up) and question along lines.
The algorithm should prepare its knowledge by asking until requirements (i.e. it has found what subjects want to do, and how they will do it, and how their answers fit these parts) have been met.
x just write idea algs
The algorithm will ask the subjects what they interpret the contention as - and what conditions each side has, which side they agree with and the reasons for these, etc.
When mixtures are mentioned, explore the main point, then the main point about this until they are resolved.
The programmer should check the grammar of questions the chat bot might ask - where answers are assumed to be in sentence form.
The computer is too slow, so write the algorithm and request that computations are instant (quantum). x Mind reader should project and detect object representations, not words. Understanding of the knowledge should be trained and assessed before open ended questions asked, such as those with precomputed likely answers, that connect parts discussed. The answers are connections between ideas, which are linked through the same type, with clarification of other types the ideas have (and objections to the ideas as represented by the wrong type for a condition, and which condition is stronger). The same word may have different meanings.
Decide on objects meant by algorithms (given appropriate choices for who the subject is).
A song should play when it is expected and the subjects should write short algorithms to resolve their thoughts.
8 8 19-2
end grammar args? -add
bottom case - n a b x n a b -> _
write args in member1 in lpi
repeat infinite choice point to return when letters fails
x sifter true
x join member1 etc with member in it
22 11 19
multiple predicate cawp x takes too long (with calls following commands, max depth 8)
instead, single predicate, cawp dictionary-less random, ui, mr
- still asks about transformations at start to write spec
- can omit types - just input or output modes (types from multi-predicates) - just asks name of variable and value
- e.g. check type, if value then add, if member then append, if member then delete and add
(verify, map or delete)
- verify - doesn't append or output
- map - outputs, doesn't delete
- delete - outputs, deletes
- data from brdict (x to above - need types to find appropriate transformation, (e.g. notes to transpose, words to recognise or any possible transformation for a type1's type (x to brdict words x uses brdict, etc. to generate data - adds type1 and type to typedict, has a commanddict of commands that transform one type of another - could transform, then use an earlier value to output like CAW, so must match spec's output x randomly/etc uses alg's output - has a single output), x:
funnel to music composer lyrics where verbs have particular computational verb meanings)
avoid lists to avoid list structure errors, compound types
- need to verify posited numbers are numbers - done by interpreter
- string length can be same for 2 strings
- using type transformations from commanddict, so has 1 solution
- random, mr and ui choose from computed algs - ui with different choicepoints x
- later: animals' own brdicts - should check meaning of word is correct, and confirm new words are wanted (may use words differently - record definition and when used)
24 11 19
prepare for multiple clauses and predicates
- lists and compound types
- find type statements from predicates
- write algs from compound type statement that is combination of predicate specifications (specification at start)
- functional types, recursive data dictionaries, recursive types
- can find items in dictionaries with query and synonyms (may need separate lookup alg)
(- may need supercomputer if uses predicate dictionaries or is over certain max depth)
- instead of caw, could traverse old predicates using tree of choice-points (for simple algs), also use appropriate commands for data (using types) (also string (writes alg with constant substrings in it), list (uses wrap and unwrap) and state machine (for cyclic data that has more predicates that need to be tracked using 4+ states, state machine if has 2 uses) finders, where need to simplify state machine)
Pitch bots
songs 22 11 19
Functional List Prolog
Skip
List Prolog to Prolog
Prolog to List Prolog
Split on Phrases
Random
Length
Ceiling
Date
Modify alg
Enter existing alg
Writes rest of alg after peeling back line by line, gives line number where changes start
Change une email to gmail
1 agent per social media account ()
9 11 19
CAWP
- multiple predicates
- start a new predicate at each stage
- other structures
- brackets where may be needed
- multiple levels
- can call any current predicate (or library predicate) or new predicate with a call
- timeout, max depth
on 10 11 19:
algwriter lp to p
- put in mind reader
do above
17 11 19
fills up last predicate first (and able to make calls to old or new predicates, where called new predicates are "before" the apical meristem of the rest of the predicate following the call in it - adds on to the correctly numbered predicate).
[
call:
pred1 head in1 out2
call in2 out3
call2 to pred that finishes off pred1 out2=out3
- call2 doesn't require further call2's after it
- call2 not in available predicate list
]
x Otherwise, finish pred1 in itself
Records point of progress, adds new clause to pred after finishing single clause per predicate list
- also for hierarchies (treated like list of predicates)
X do 1-2 x n (for number of inputs) clauses First to account for recursion
Variables set to Constants "", [] in calls
%% 16 11 19 - didn't integrate mind reader with algwriter-p.pl because mind reader integration with CAWP is a priority.
master algorithm generator 7 11 19
()formula finder with algorithms
- word2vec, patterns in texts, own version of machine learning
-> cawp without dictionary *: given master sentences as specs
program finder * x cawp will find more possibilities, x pf is more intuitive x it is like a broken down cawp dictionary
- multiple predicates, multiple levels
- type statements to verify predicates (with mode statements)
- in types, modes verify format where mode statements apply to entry of predicate (as would anyway), are applied before running command and are used if included (i.e. have [n,modes] at start and types have [n,types]) - lpi uses type statements before running a command if modes are given to identify inputs, and also afterwards (but may not have reached this point if failed).
find types
1. give data with modes in it
2. calculate modes
3. mold types by starting with any
- check them because all possibilities are allowed, depth limit - 1 possibility per clause, collected per predicate later
()algorithms with data in the same format as other algorithms
- other algorithms as data
music mr->lp
file commands
(Non-functional (until later)) algorithm writer 3 11 19
asks what types to types (only uses necessary data (e.g. across test specs, i,i->o,o)
what is different eg a note moving up
- goes through data structure asking
- asks when to stop
- only needs a new data structure if it changes in output
- chooses data from first brdict2 (e.g. description-plus, verb-right (not the computational verb), object-box, etc.), then brdict1
()() - functionalism can use functions to break down data for needed verbs
- don't need output variables in functional calls yet
() - needs data flow following to find modes, types of calls
meronyms, pos for automatically detecting data structures from spec sentence
spec sentence has computational verb(s)
- eg sort notes
a data structure dictionary with connections to type statements (from numbered verify tests)
later x now: an algorithm that can take recursive structures x the algorithm should be recursive and take numerous inputs
--
Can choose structure with list of numbers
If not all numbers, funnel to all numbers etc
Verb before types, then data
look up terms similar to meronym
- mapping from input to output and (input to input) as output
*
- optimise chains of functions
- add 0 x, > and = is >=, reverse and sort is reverse sort
- better sort algorithms
- ()
- distribution sort
- mainly manually enter alg specs, random is not as useful
- should also work by entry of a text (or entering data based on a text)
- manual, random, mind reading should ask from a pre-worked out set for input (and answering which fn and vars at each step of each predicate that doesn't return true for the spec in manual)
- manual: makes up the spec, i.e. tries multiple combos of predicates to make the spec (with output) or randomises the spec and asks for help writing the alg 
- modification alg
- should completely work out alg in all three (mind reading, manual entry and random generation) from spec set for all predicates (specs needed only for preds not in dict - top down) with timeouts for bug checking infinite loops, state success then possibly mind read options
- needs all possible sols - findall
texttoalg2 *3:[
*1 text entry: XML key terms e.g. "verb before types" ("x before y") - list 1, list 2 (dict with words like before meaning this), "verb before types then data" - list(lists), could have recursive description of verb before types then data
*2 the rest are functions, sometimes recursive
- need other window to search for and test *1 and *2, could enter it and it would be added to same types in database
- don't eliminate symbols, numbers in text, break on comma, hyphen, quotes, etc.
- could guess language as transformations and functions as any function ("anyfunction")
- should identify different clauses/algs in sentence - an alg shouldn't be more complicated than a clause spec - asks whether clause spec is whole spec
- asks if data from database that works should be used or if some new data is needed
] x (not able to be done easily over long time, can't deal with code, might not have good/interesting enough results) x more specific than texttoalg but texttoalg is required as well for 10s
texttoalg2 (*3) is wanted, the alg generator (previous) is too slow and modification alg doesn't work well
- x It writes algorithm specs, generates algs, later: modifies them x *3 does these (don't need multi-level algorithm specs to keep this stage simple) xx
- will need output var feature in recursive calls for multiple function calls at same level
- alg to change fn names/delete if same
will texttoalg2 cope with demand of text? Probably not. x strings can be represented as lists, so it can.
- eliminate duplicates, unused from lpiverify* x use algdict
Teng: t2a2 x t2a would require the whole alg to be in dict, not just calls (instead, use t2a with a unique compound word function name).
combine 10 algs with brdict data for masters algs - 30 data items split into 2 lists - for 1 of 10 algs needed per sentence
instead of
[call,[[n,map],/,3,type,checked],"Press c."]
have types and data x easier to find type trace
x fixed
As well as v,a v,b being being like n,a v,b
- need v,a expanding to n,a v,b 
- grammars need v,a expanding to n,a v,b in grammar section
Advantages of types
Don't make mistakes when entering data and can remember types of predicates more easily
- video
Shells are replaced by Functional List Prolog x
can t a in one line be read in another line
%% findall(d,member(d,c),e)
[n,_] not in body of type statements
Type statements may not refer to other [n,_] types. Users should only refer to data for the immediate predicate (where terminal predicates only take values not [n,_]).
Russell FLP 1 11 19
Describe groups in multiple function calls to link sentence spec to call
High quality literary ideas (from essay example of philosophy/meronym dictionary, perhaps morality-related, where words are from perspectives/departments) reflect passed values
Flp
Build alg
- top down
Instead of a double type system 31 10 19
Instead of a double type system supporting outputs in query function (i.e. outputs given as inputs) to try to check types to use in an algorithm writer (rather than possibly have types stated for calls inside functions x):
However, a double type system is too complicated, and an algorithm writer can check types and modes work by trying the algorithm (or just check types by running with types on).
x:
v f11 -> n f11
test(57,[[n,function],[[[n,function2],[[v,f]]],1,1,[v,c]]],
[
[[n,function],[[v,f1],[v,a],[v,b],[v,c]],":-",
[
[[n,equals1],[[v,f1],[[v,f11],[v,f12]]]],
[[n,getitemn],[1,[v,f12],[v,fa]]],
[[nv,f11],[[v,bb],[v,d],[v,fa]]],
[[n,+],[[v,a],[v,b],[v,e]]],
[[n,+],[[v,e],[v,fa],[v,g]]],
[[n,+],[[v,g],[v,d],[v,c]]]
]
],
[[n,function2],[[v,bb],[v,a],[v,f]],":-",
[
[[n,is],[[v,a],[v,bb]]],
[[n,is],[[v,f],1]]
]
],
[[n,getitemn],[1,[v,b],[v,c]],":-",
[ [[n,head],[[v,b],[v,c]]]
]],
[[n,getitemn],[[v,a],[v,b],[v,c]],":-",
[ [[n,not],[[[n,=],[[v,a],0]]]],
[[n,tail],[[v,b],[v,t]]],
[[n,-],[[v,a],1,[v,d]]],
[[n,getitemn],[[v,d],[v,t],[v,c]]]
]]
]
,[[[[v,c], 5]]]).
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)),
(isvar(Value)->append(FirstArgs1,[Value],
FirstArgs3);FirstArgs3=FirstArgs1),
interpretstatement1(Functions0,_Functions,Query1,Vars1,Vars8,true,nocut) :-
%%writeln1("h1/10"),
Query1=[Function,Arguments],%%not(Function=[n,grammar]->true;Function=[n,grammar_part]), ****
%%writeln1(["Arguments",Arguments,"Vars1",Vars1]),
%%***writeln1(substitutevarsA1(Arguments,Vars1,[],Vars3,[],FirstArgs)),
(Function=[nv,F2]->
(append([[v,F2]],Arguments,Arguments1),
Type statements are easier to use to eliminate rather than use them to create code
Function call is the format, not long algorithm.
- don't need to concern self with conforming to types, unless changing the structure
When writing, type statements of data must be matched and functions must be matched on way.
Data types are different from function types.
- Can extend data (add functions, data before), reverse build data from base up
not predicate or rule name
- or variable name
31 10 19 Types and Finding Intermediate Functions
How will type statements for functions in algorithm writer work, given that the functions will take functions of functions, etc. as arguments? Should there be two and more versions of a function given that a function may sometimes take a certain set of functions, and other times another set of functions? There are functions that take "any" type of (number of functions as) input. Should functions be written to sometimes call functions if they are available, otherwise call a base case (with a different type statement)?
Type statements for functions which take functions as input can contain the types of called functions (rather than needing internal type statements). This means functions can be plugged in and played with.
There are so many algorithm ideas and they each have to be unique, so a functional algorithm writer may not be used for anything apart from generation of algorithms. Sentence decomposition can lead to natural use of the functional syntax. 
Newly needed intermediate, etc. functions may be developed now given below (not after) specs (of function name). This would require a separate algorithm.
Program finder can be used in string and list finders to write new functions.
One-line aLgorithmic functions can be read quickly.
30 10 19
"a" as input and "a" in lp header should register in result2
- affects strong type checker
Initial, intermediate and terminal predicates may take any type and call any type (a compound term that is one or more items).
STLP Type Statements
[[[n,f], [[t,predicatename],[t,list1]]]]
can have multiple type statements per line, e.g.[[n,list1],[[[n,list],[[t,number]]]]],
[[n,j],[[[n,brackets],[[t,letter]]]]]
- may timeout on infinite loops
Type statements may be across multiple lines, especially when types are reused in different lines. Checks type statements are correct, with terminals, etc. Checks that there there is a type statement with the right name and arity before each predicate (and that extra type statements, e.g. before base cases have the correct name and arity). When running, finds corresponding type statement and checks the call's types, then runs the call.
predicate: [[n,f],[[v,c],[v,d]]]
query: [v,a]=["a","b","c"],[v,b]=[1,2],
[[n,f],[[[n,g],[[v,a]]],[[n,h],[[v,b],3]]]] *
Algorithm Writer: If a user specifies the line * without stating the relationship of the computational verbs (e.g. [n,h] with [n,g]) then the sentence and data can be examined to find it.
--
only g not g b (unless b is a constant or needed),
unpack [g b] or [[g],[h c]] as v1,v2
v1 and v2 used in the predicate body
FLP Type Statements
Functional List Prolog needs type statements to prevent running functions that will cause errors - 
- solution: check types in checkarguments v
and to check types match in algorithm writer
Type statements can be entered in a separate argument in the interpreter. Type statements matching predicates check input to functions in FLP (available in LP with a Flag).
Functionalism
- prevent functions as arguments from being substituted into
- later: can get predicate names by passing predicate name as an output variable
- variables as predicate names called
Strong typing
- lists, brackets, etc.
(1 set of types per line)
- checks a type statement allows the header data for a predicate with flag on
- debug prints type statement matched
(Intermediate functions can have items of "any" type in structures and initial data can be traced to terminal data through these in algorithm writer)
alg writer with multi choice
Cawp for sub predicates - need spec
Specs are result of groups of old, new predicates in random, mind-reading
caw with new predicates for rest, with multi choice
Even in mr choose one of random caw with new predicates with mr
Automatically decomposes list, asks for command including more decomposition based on ideas from previous predicates
Needs data flow as goes in manual entry
Data flow also reports result of header matching, structure matching, check arguments, start of statement
- interpreter editing
can select whether to enter a new line or try auto-completing.
times out
- on clauses
- can insert true, false, until clause configuration doesn't time out, has correct result
use run-all instead of classic cawp
- needs type definitions
- can reverse engineer type definitions from predicates
- or can guess biggest to smallest data types when writing call
- even with commands
- or non repeating instances of variables in cawp
- meronymnal network of algorithms
- finds related words to spec, uses as data, backbone of algorithm
- if there are two different ideas in spec, finds connection
- mind reading for confirmation of relevance
The passed queries only have necessary data.
%% x:
%% List Prolog can act as a functional programming language by replacing a predicate name in a call with "_".
%% It can e.g. find the last item in a list by moving forward, not back. It is part of algorithm writer with List Prolog in a new shell.
test(53,[[n,_],[[v,c]]],
[
[[n,test1],[1]],
[[n,test2],[2]]]
,[[[[v, c], 1]], [[[v, c], 2]]]).
Functional List Prolog
- For first year, semester 1 of a Computer Science degree
- Flag in List Prolog that requires (strong) type statements. LP already doesn't replace variables in [[n,...],[...]] arguments (but does replace variables in arguments (that could have come from [[n,...]...]) without [[n,...]...]).
- [v,...] as a command uses the value of the variable as a command.
- function command can tell whether a value is a function
- type statements are before the functions they refer to and when matched, they pass the call to the function. (Different clauses, i.e. a base case that takes a number as an argument and a non-base case that has a function as argument have different type statements. xx) Compound data structures are also allowed, where there is a list function. (There may be multiple types per item. x)
28 10 19
Shells in LPI
LPI in LPI
alg writer 2 - 24 10 19
these are algorithms, not sentences - why and how to take care of them:
asks for computational verb, i.e. count (checks name of predicates, synonyms with data type of spec)
- multiple interpretations (verbs)
all related algorithms:
part of speech like adverb may give new algorithm ideas
all main algorithms:
asks for mainness algorithms (based on needed algs, stories indicating algorithms)
intelligence:
simulate machine learning by using similar algorithm verbs in related algorithms (with different data)
unique
don't use same specification/algorithm/result twice.
later:
intelligence (research), why working (business side) and word2vec (all details)
how to convert a manually entered sentence into an algorithm
- uses combos of computational verbs, finds similar algorithms from spec with same words as those that trigger (use) these verbs
- rules for how different wording of spec (with expanded conditions, which can be simplified and asked for in relation to other specs) trigger different combos of computational verbs
specs written for major calls to help speed development
old predicates checked for usefulness (used or changed) or new ones written
new ones written:
user asked for hypothesis of commands thought to be needed in predicate, then decomposition, other parts said, etc.
- fine detail of args used added as go
- analysis algorithms try to modify existing alg to reach goal, offer clues
The alg should save configuration as goes for later machines learning
- number choice points in case goes back
-
x just like cawp
- question answerer that converts simple list prolog plan to code, asks for input/data
- spec at each call
- fills in gaps, can redo parts
alg writer 24 10 19
my brdict, intersecting with p.o.s. dict
- finds random/mind read/manually inputted sentences
- asks how they can be algorithmically (logically) connected, one part at a time (if important, what logical structure/relations are)
parts of speech (pos)
words about how they function 
meronyms are parts of objects (for data structures)
Use a computational description of a sentence to find an algorithm and algorithms (https://github.com/luciangreen/texttoalg) for each word in the description, grammar check and back-translate it, and relate the original sentence to the topic and terms in the original sentence to parts of the computational description.
computational description of a sentence
- not same algorithm even with different data (shows previous algorithms for key words of original philosophy sentence and the sentence. 
Grammar check
Passive voice - be or was *ed
- relation to topic
- give old algorithm ideas before asking for new ones
- ask for number of key terms (algorithms) in idea
50 breasonings per chapter x 80 ideas
- research quality, formats for essay writing (already v)
A Program Finder (pf1) (one instance of one replace predicate)
- inputs: i's,o's
- outputs: program1
- pfpf
takes [i's,o's of program x pf1, xx] program1[s xxx] as inputs
outputs: a pf2 (replace, delete xx)
[if program->program
- takes care of specific commands and arguments in predicate instances
- combines predicates
- each predicate instance may operate on different input(s)
single type eg replace and single idea
X]
- must output multiple predicates from pf
- pf2 is pf1 of p1 x
- must find eg replace, delete predicates
- given inputs i's,o's to pf1, runs modified pf1 on pf1
pfpfpf
- takes [i's o's, ps x, of pf2s xx] pf2s x (from pfpf - replace, delete x, member x)
- out: pfpf
- pfpf is pf1or2 of pf2 x
- given inputs i's,o's to pf[1or x]2, runs modified pf[1or x]2 on pf2
Just concatenates them x finds general cases
pf of pf is really pf and pf x
will the programs i->o correctly x
should io from pf be used in later programs x
*-for phil
6x n levels of pf for enough correctness
- necessary for (some) assignments
- other factors in correctness, pf1 code and data are affected by regression testing
*
pf's use (*2)
- automation
- accuracy in types, etc.
bug checking pfs
- check i against o per predicate instance
- pf: must be given i's, o's for each predicate in the program
*regression (return to results/positivity) when programs that program finders produce are run, which may need further pfs to correct code
as pf is run, more possible o's for predicates accounted for, making development faster
- can generate philosophical list prolog code more easily
- bug checks
- pf
- interpreter
pf: non-child predicates are treated in the same way as child predicates, i.e. patterns are found, broken down and programmed
- ff, logic ff
- if there is e.g. finding a number of instances of phrases across grammars, then it will detect and do this
- test combinations of these operations (e.g. counting, traversing, replacing, etc.), like formula finder
- appropriate for i's, o's
- and as a formula finder operation
- in prolog formal finder, inserts command if data suggests it is needed
- e.g. replace is recognised to to be needed as main called predicate
- other calls are predicted by the data complexity (lists)
- finds 2p e.g. two lists being co-processed
- () even though pfpf takes i's, o's of program as input, a pfpf has the aforementioned advantages (*2 above) it should rewrite the predicate without "cheating" by looking at the code, because of the advantages.
- the i's o's given are of the program we want to find the pf for, not the original program
- () above pf, it just verifies code by rewriting it
- a test finds what (emdar, emar, etc. is used) then finds this code (emdar, emar, etc.)
how to modify emar, etc.
- tries with, without commands and predicate calls at points.
e.g. append not used if verifying list (this will be evident in output)
- () could find predicates and their sub-predicates by trial and error
- repeats emar etc test for possible subpredicates
- structure of code as data should be analysed (same predicate names and their arguments) to find right location of running, how code calling emars etc work
(the i's o's from programs really will be taken, given to pf by itself)
code calling emars - what list is being processed? - by i's o's
- predicates need some lists that are used by them passed down to them
- buildpredicate predicate will be recognised as building emar etc from i's o's, rewritten
bug check
- how will it write code that writes code in LIP?
- use var not upper case, replace with uppercase before lpi (*1) x will replace upper case with lower case in next level down
x converts first instance (*1 above) from var to capitalised in next level down x need to concatenate code and variables together in lip