An AGI program cannot be a programming environment where specific combinations of keywords, variable values and grammar correspond with specific output values (of meaning or action) on a one to one basis. This goes for the application of numerical processes as well. This correspondence would represent a correspondence of data object to reference or a correspondence of application of method to reference.
So the AGI program has to be able to do some learning for itself. On the other hand we want to allow programmers to use these kinds of methods if they choose. To put this in AI terms, we want the program to be able to make some good guesses. If you understand what I am getting at then you might also see that this seems to suggest that the earliest AI models were on the right track to AGI. For example, an AGI program might derive a conclusion based on categorization of type and knowledge that a variable or a reference belonged to that category. However, the program would have to make some conclusions based on incomplete knowledge. So it might, for example, make a conclusion based on an analogous method suggested by a similar application of the method using other members of the categories that the references belonged to. (From familiar category to novel specific). Similarly a conclusion based on a numerical method would be acceptable so long as the application of the numerical method is not fully defined for all or nearly all methods and situations. The rule that some references must have a one to many correspondence seems to suggest that the program has to be capable of making mistakes and since it has to do some learning for itself it has to be capable of learning from its mistakes. It would be possible to design some unique programming environments. One of them might involve gradual shaping. Again, shaping is an important part of education so it is something that we would not want to exclude. However, if the program allows the programmer-user to shape the relationships between combinations of categories, variables, grammars and output so that all or nearly all of the combinations of output have a one to one correspondence to reference then it may turn out that the program was a programming environment. Some programmers could actually design something like this to fool us. So the program has to exhibit the ability to learn for itself, and it has to have the ability to learn from its mistakes. The insistence that the program has some ambiguity of reference (or whatever abstract term should be used to cover the possibility of a one to many reference or application of method) is an acknowledgement of the nature of the problem. This rule is based on the opinion that an AGI program has to use a component system to attain greater knowledge. As the program acquires references these references will be used in many different ways. This is true for any kind of data environment/modality. Lets suppose that someone was trying to fool us with his novel programming program which used shaping to shape all data references to specific kinds of outputs for specific combinations of reference and grammar. As long as someone who knew how to use the program was using it he could get the program to work for some of the problems that he was challenged with. When naive users tried it however, they would not be able to get it to work. On the other hand if other users tried any kind of AGI program, they might try their best to screw it up and since we are still working on such a primitive level, they would be able to succeed. So the best compromise is to ask the programmer to show that his AGI program could deal with ambiguity. Suppose that the program used references of different levels of generality. This would arise based on learning from similar situations. Then a reference (of some level of generality) would refer to different objects in different situations. (Or different contexts for the same object. And categorical conclusions would be applied to different objects or even different kinds of objects). The insistence that an AGI test designed for a simple AGI program had to work with ambiguous references is merely an acknowledgement of the nature of the problem and the fact that a programming environment where a programmer user solved all the problems that were encountered isn't AGI. Jim Bromer ------------------------------------------- AGI Archives: https://www.listbox.com/member/archive/303/=now RSS Feed: https://www.listbox.com/member/archive/rss/303/21088071-c97d2393 Modify Your Subscription: https://www.listbox.com/member/?member_id=21088071&id_secret=21088071-2484a968 Powered by Listbox: http://www.listbox.com
