It’s easy for a logic reasoning system to cascade into a combinatorial explosion O(n!) where each time the system is evaluated more and more rules must be evaluated. So how do you get similar results in constant time O(C) or linear time O(n)?
1. Truncation with randomization
If you don’t want to process an infinity of things, just don’t! Just process a random relevant handful of them. Incrementally, over time, it will work itself out. This also promises a ready mechanism for attention: we can modulate attention by reducing or increasing the number of rules processed per time cycle for a ruleset.
2. Indexes and relevance
If we’re not doing all of the rules ever time, then probably best to do the most representative ones. With indexes with can test whether symbols included in the current pool are included in the evaluated rule, and thereby greatly narrow what we are looking at. Only a very small subset will concern us compared to all. With relevance by learning, we can also evaluate within those qualifying rules, which are more qualifying than others. And so we can use them to get more votes for our random sample of applications. The net result is a fixed order of magnitude of processing requirements with increasing emulation toward full processing.
3. Modularization
Both by modularizing inputs and outputs, and modularizing the discover and import of implications and expectations, we can soft restrict what is available within each specialization of module. This is done in a structural - not adaptive way. Here we define the finite areas of expertise and how they relate to each other. The learning occurs within the modules, but we set up the module data plumbing.
Even if it’s possible to know it, it’s not necessary to know everything in every context. So why not let different modules take different perspectives, and earn and bring in their own implications by context. The global sets of associations and implications can be cached at multiple levels of remove.
Thus, with these techniques, we are able to process an arbitrary level of complexity in constant time.
