(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