This is the current formulation of my AI. Several things must be realized:
First, this is only the pattern-finding portion of my AI. The point here is to be able to potentially recognize any pattern in data (though in practice any implementation is limited). A "full mind" would also need deduction based on these patterns to be intelligent, and would need goals to act on in order to use this intelligence.
1. Data is made up of atoms in datastructures.
2. An atom is a sensory object that may have one or more variables.
3. These variables can take a certain number of states (be it a finite number, or a workably infinite number in which a new state can be created at whim, based on a relation to existing states).
4. A particular type of atom is defined by a particular set of variable states.
5. Datastructures are relations between many such instances of atoms. Atoms may be strung in a line, placed on a grid, or put an any order generally, depending on the nature of the data. It does not matter if these relations are temporal, spatial, or more abstract: the structure is simply adapted as necessary. There may also be a total lack of structure; atoms or larger structures can be an unordered set, rather than a spatially or temporally ordered one.
6. The variables of a particular set of data include the variables of the elements (the "atomic variables", so to speak), and any patterns that the data fits into. (Since all patterns that may describe the data are not known, this second type of variable must be added as it is spotted.)
7. A static pattern type is defined by a set of variables in data; an occurrence of such a type is the realization of those values in the data. (Most commonly, these variables are atomic, so that the static pattern is a string of atoms that can be found in the data in many places; a word that can be found repeatedly in text, for example. New static patterns can be found by searching the datastructure for repeated strings of values, be they in the atoms themselves or in more abstract regions.)
8. A variable pattern type is a set of such static patterns; any one of the possible value combinations will do to identify the pattern as belonging to the variable type. (A good example of a useful variable pattern is a set of static patterns that behave in nearly the same way, appearing in the same contexts; they are put together as a single variable pattern, allowing these several static patterns to be recognized as functionally the same thing. The variable pattern can be thought of as an uncertain value; a set of possibilities. Predictions can then be made as to what set a thing will be drawn from, when exact predictions could not be made, et cetera. Even if exact predictions can be made, though, the variable pattern can still be used; the domain and range of a function, for example, can also be thought of as variable patterns.) Any set of patterns may be used as a variable pattern; this means that a constant pattern can always be looked at in terms of where else it has appeared.
9. The set of instances of a pattern is an unordered set. (The only relations between instances are any that existed in the data, and equality of the defining variables of the pattern type.) This set, being a datastructure, is searched for patterns as well.
10. Any values not set by the pattern definition are variable patterns, containing the set of all values that have occurred in that slot as their set of values. (This includes both concrete variables and abstract variables in the data.)
11. Sub-types are constructed by setting more variables. Once this is done, more variable types may be created by listing all the values that still occur in the yet-open variable slots, despite the field being narrowed down. (The variable pattern consisting of all subtypes of a certain static pattern is equivalent to that static pattern.)
12. A function is constructed as a list of possible fixed values for one variable in a type, and the related values for another variable of the type. If fixing one variable decreases the options in another, then a correlation has been found; one variable is a function of another, carrying great deductive advantage. (This method of patternfinding in uncertainty, defined in 11 and 12 for finding functions in types, could actually be used for any comparable data situation.)
13. Patterns in functions may be found, as well. The method here is the same as in data, but focusing on describing functions in terms of simpler functions. (Simple functions are remembered as static patterns that can appear in data of certain types.) A pattern may be looked for between a particular input and its output, or, alternatively, between the outputs themselves.
14. The variables of an item include all places where that item has appeared. This includes all functions in which it has appeared. This allows expressions to be created which stand for certain values, but as functions of other values; 144, for example, could be remembered as the square of twelve, rather than as itself. (Expression-creation is an important way to represent a function in terms of simpler functions; if a pattern cannot be found for the unmodified items, perhaps a pattern can be found in their expressions (for example, each might be the square of the next-higher prime number than the last; in such a case, no simple direct relationship between the squares exists, but the pattern is much more obvious if they are all expressed as squares of some number, rather than as just bare numbers). This is essentially the same activity as finding some pattern in the variables of a list of items.)
15. Such expressions, if used as general rules, may describe an infinity. Because a pattern can be described by an expression rather than memorized, and a description is a pattern which can hold true for an infinite number of cases, a pattern may (in effect) be infinite, and still held in the simulated mind, if its (infinite) behavior can be described (finitely). This means that spaces need not be defined only as discrete data structures (as they are in #5); continuous spaces may be imagined, which contain an infinite number of points in a finite space (as is described in geometry). Such spaces are defined by the simple idea that a new point may be between any two points. This is a finite definition which holds true for an infinite number of cases. The same method may be used to define infinity ("bigger that any number" holds true for an infinite number of cases), infinitesimal ("smaller than any positive number" holds), repeating decimals ("three in all decimal places," for example), and other structures. This method is also related to "mathematical induction" and "recursive definition". (In truth, I am not entirely sure how a computer could do this.)
16. In addition to looking for patterns in raw data and in subtypes and in functions, patterns between types may be found, as well. First off, since the definition of a static type is essentially arbitrary (that is, simply memorized), we may look for patterns in it in terms of smaller elements, to find its pattern. With language, this is equivalent to splitting a word into clearly defined syllables in one's mind only after learning the word. The syllables are there implicitly, but not recognized. Also, patterns behind other variables than internal structure should be looked at; to continue the same example, this would be like trying to figure out why the syllables create a word of that meaning, based on their meaning in similar words.
17. Patterns behind patterns, as such, may lead to another very important abstraction: numbers. If several patterns exist that could be described by numbers (that is, types for doubles and triples of a few different patterns), then these patterns will be related in the fact that larger patterns of the same type contain eachother. If this relation could be seen as a pattern (perhaps that's a stretch), then the fact of it could be first established separately for a few cases (one apple/two apple/three apple -> any number apple, plus one lemon/two/three -> any number lemon), then these separate types of numbers could be consolidated into one invariant type: the number (assuming that this pattern could be seen as the same in the multiple cases). In truth, I suppose I don't think humans invent numbers in this way (as babies or whathaveyou), but that numbers are inborn; but even so, they are still constructed from more basic ideas.