%% test functions, write functions in another program - in reverse, where the program is tested in lpi %% verify(Arguments,Types,Subtypes,Functioncalls,Functions) %% verify Arguments given Types, Subtypes, Functioncalls and Functions %% verify([1,"a",[1,"a"],[1,[2,3]],[1,[2,"a"]]], %% two uses %% verify([[[1,[2]],[3,[2]]],[[1,3]]],[[number,[numbers]],[[repeat,anynumber,[[structure]]]],[[repeat,anynumber,[[number,number]]]]],[[structure,[[number,[numbers]]]],[numbers,[repeat,anynumber,number]]],1 3 varnames -separate second instance on from first -[repeat,anynumber,_] needs extra brackets when not in same list v -extra brackets needed for structure above v -to help students, replace parts of the input with the types, then insert variable names into those -functions to take each member of list, test that 2 of the numbers from each of the instances of the var are the same, returns all of the 2 numbers corresponding to these same numbers, like a database query - the functions are too easy/not focused enough on the individual variables ?x they will write the functions themselves - the assignments to just write pf queries in the end may be too easy/not demanding enough -x they have written pf, the functions in pf for each program - can they just write the whole program without pf x the exercise is to write pf for speed and resource reuse - why log each change (new function) to pf in a unique bu - to record it has been written to be used, to eliminate similarity between students - skip verifying the input, just write the code - however, can write a program to translate input/output into pf query, requiring ff-like testing of functions - this means the programmer must write the translator and pf, not the program - ff ? acceptable because is a brute-force algorithm, however can group functions into selection, formula and list building - functions will be tried one by one - connections between functions are 1. selection 2. formula 3. repeat step 2 to build list - everyone will build their portfolio of programs - in response to question, can't you just give the i,o as the assignment, it will be awarded 0 marks - what about sentence in two uses? - save i,o, translator, pf query, pf and program per program - later: details and comments - the assignment is to write program finder and its query for a program to write it - small groups of programs will be assessable - a program finder for program finder and lpi will take the pf query with i,o of e.g. program finder and will use a program finder with the appropriate functions to test and write - input is not differentiated from output x it is * - program finder can multiple 2 uses 19.3.18 - hand sensor with cam philosophy algorithm game tests understanding of i,o - hand sensor with cam cost? x - the prolog game to teach the algorithm to children just uses i,o in hierarchical format - game init data to teach theory, ask questions (e.g. with keyboard for music comp) and model input/output, alg checks output contains same answers in required output, notifies of incorrect parts of answers e.g. a in [a,b] if it is a list of tuples, otherwise a,- or a and b in [a,b,c] if some wrong, game is for all students to teach them how the algorithm works - translate into hand motion program x game from philosophy program - heuristics in translator - e.g. it decides on a set number of items/items per set if they are always the same - we should not read/delete algorithms based on mindreading customers afterwards, should offer own ideas before payment, not use ideas others have thought of with that person, may have to read them to adjust them based on their comments in representations - connections are small changes e.g. decomposition where two uses is because of future because two uses contains one use - why do we need each part of pf in assessment? - i can come to a new algorithm based on my own preferences - db ff x finds the relationships bw vars - replace in pf for each formula, but why were these parts of lists in a var chosen (U to v and intersection to ^, resolution in logic) it finds patterns by match or maths among all instances of sets of subvariables - how will it determine a certain set of variables has a property - using a system and all possible functions- can this be reduced?- only find rels i>o or i>i (could be verify) or o>o (otherwise), [only search for maths if patterns fail] - anything in the same argument won't be outputted to the same argument, i need replace with multiple levels per variable, record place of sub var in var -[make up var struct from i,o, incl patterns, from which can find some of program - where will function calls placed in program - between right recursion points- where are predicates split - at recursion points - also need programs that output comma delimited output], is it optimised? - Not yet must run sequence of programs to find program, then modify pf query to be more specific and run again * Two uses Replace with inputs including [a,[b,c]] Replace returns comma delimited output Two uses pots finds two uses (objects) in a “diagram” (list of lists) - why do the possible outputted pf queries, programs, etc need to be comma delimited, not nondeterministically outputted? - to process pf queries, check which is 100% - finds all pf queries and corresponding programs, outputs first program with 100% accuracy - the program is necessary to read to analyse (improve pf) - translator finds the program - what if there are multiple interpretations of a pf query? x it has already found it - there is no pf, just translator - does the program seem expanded or of pf - auto detect ideas -> alg - how will it find all pf queries/programs - it will match with i,o, and will stop applying functions at a certain depth - aside: can optimise chains of functions, e.g. with database ff - why is pf query necessary Additional var types Graphics with objects depicted Music with notes of octave corresponding to parts of the body at different heights Everything typed by ()