(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