notes-cog-ai-cogArch-cogArchIdeas

an autoassociative memory structure in which the pattern being associated is an 'animation', similar to an animated gif. The structure of the animation is a connected network of nodes connected to each other with arcs. Each node has a dynamic nature, and together, they change and interact in one or more repetitive patterns (possibly the network is just a computational structure that can do lots of things, rather than just being capable of a single execution path/animation).

So, for example, one pattern might be a network of four nodes connected together in some topology, where the first node is blinking on and off, the second node is blinking on, on, on, off, etc.

so, the animation pattern as a whole is sort of like a rubino machine, in that it is a memory that stores signals, but at higher level

when you do an autoassociative query, your brain tries to find other networks whose nodes do similar things at similar times in the animation.

The links in the network represent associations between concepts.

These may be formed in at least two ways. (1) when you think about one of these structures/patterns/'animations', it is placed in the global workspace and broadcast widely throughout the brain. Other nodes and animations which have similar dynamics then recognize the similarity link themselves to the animation being broadcast. (2) a similar process, but unconscious, for a week or so after learning or thinking hard about the animation. So, to some extent the autoassociative queries can be precomputed.

how are these associative links between nodes traversed? 'code' running in a thought might use something like 'indirect addressing' to effectively follow pointers (links) from the node it's looking at to another nodes. These links may come in multiple 'flavors', e.g. sometimes you may want to say, 'i want the REFERENT OF this link' rather than always just getting the link target.

note to self: see also notes on 'custom multiple flavors of indirect addressing' in jasperBrainNotes1.

the Rubino machine stores continuous periodic functions. But we may also store and/ordiscrete firing sequences in discrete time, by storing the nodes, which are each little turingish machines (mb discretize time for the 'continuous' fns too? first byte (well, arbitrarily large int) is # of time segments in the following represntation? hmm)

perhaps instead of broadcasting the structure itself, one just broadcasts the activities of the nodes. Other parts of the brain receiving this broadcast then are left to re-infer (induce) the causal structure (and hence to guess a new network structure) on their own. This leads to diversity of representation. This provides one way to avoid 'cortical neurl form', that is, a common semantics for signals throughout the cortext. Instead, in this model, parts of the brain don't have to understand each other, they just try to predict each other.

In other words, these broadcasts of patterns have the semantics, "Here's what i am thinking right now. If you are a model with an inferred causal structure that produces data similar to this one, then please link yourself/your model to me."

such predictive models could also be composed into a hierarchy, with more general concepts further up the hierarchy.

goal-seeking can be imposed on this purely predictive architecture by getting it to prefer to imagine animations which hypothetically result in pleasurable outcomes. This will cause a form of 'shaping' training. This would explain why we like even to think about and imagine pleasurable outcomes.

if each module must listen to a broadcast of all attribute values of each item in working memory, then we can opportunistically find creative connections between things.

another way to put this: extend the notion from fourier analysis of multiplying by a e^(i pi x), that is, by a thing that goes around in circles, to arbitrary sequences/state machine simulatiors. Hyperlink them together. So what we have now is a network of individual recognizers/state machine simulators.

see also [1] for more.

todo make my neuro paper based on this stuff:


my friend DR and i were talking about number theory and he said something like 'i have various data structures that i work in terms of, one of them is that integers are (multi)sets of primes, multiplication is set union, etc'; which is one way to look at the (impact of the) unique-prime factorization theorem.

this maybe provides a clue to my quest for a way to make a theorem discovery algorithm that contains an analog of 'intutions' and/or 'analogies'; because i bet that P != NP, in which case theorem-proving is hard, so why can humans prove theorems? One answer is that they can't, we have a bunch of people sorta-randomly searching proof space and sometimes they discover a proof and our body of mathematics is determined by which proofs we've happened to find so far. But another answer, which i prefer, is that most of those hard 3-SAT problems are at a boundary when the ratio of variables to clauses is just right and looked at as 'queries' they look like unstructured nonsense (high information/white noise), and similarly i suspect that most hard-to-prove theorems will be random facts that don't seem particularly important or interesting; by contrast, i suspect that the set of INTERESTING theorems might be easier to prove on average (maybe not in the worst case, though, which is what P vs NP is about anyways? not sure what the average-time results are though for NP-complete, maybe there is a theorem that if P != NP then avg time isn't much better than worst; but i am saying it won't matter because here we are taking a weighted average, weighted by interestingness, and i conjecture that will give us a different result). I suspect that interesting theorems will be easier to prove because the reason we think they are interesting is because they correspond to a simple statement about something that we have an intution about, and the intuition (or perhaps just that the fact that it is something that we can have an intuition about) forces a simple structure on the domain which reduces search complexity.

So i have a quest to make a theorem discovery algorithm that makes use of 'intutions' and/or 'analogies'. One thing i've heard of along these lines in existing work is something which can construct simple examples in some domain of the logical statements it is trying to prove, and then check if the statement if true for the examples.

ANYWAY, the point here is that this idea of a 'data structure' of integers as a multiset of primes suggests another thing to do. Merely finding and checking examples seems unsatisfactory because we feel that when we are proving a theorem, the use of intuition is not merely to construct a few toy examples and then say, "uh, this MIGHT be right, i guess it's worth an exhaustive search in proof space to try and find the proof. Rather, we feel that our use of the intuition sometimes DIRECTLY leads us the proof, that once we use the intution to find the right understanding, we just need to translate it into a proof. So what we want is to create some NECESSARY correspondence between the structure of the 'intuitive' concrete domain and the logic of the proof. And these ideas of 'data structures' seem like a piece of that puzzle.

It also gives me another idea. Another thing sorely lacking from AI is the ability to think 'fluidly' like humans, eg the way we sort of understand language even when it is imprecise. Another inspiration is that recently, there were some announcements of Go playing programs that do pretty well using Monte Carlo Tree Search in combination with some other stuff. Among other things, Monte Carlo Tree Search makes the lookahead search done by the Go AI more efficient by more efficiently guiding the search to explore potentially fruitful areas of the search space. Another inspiration it that above, i talk of a sort of spreading activation network of simulations/periodic functions.

The second idea is that we define an 'activation level' or probability metric etc over the items in some concrete 'intuitive' domain; various different 'nodes' add activation to various different items (the set of items that can be activated is the same for all nodes though). The trick is that different intuitions and reasoning styles can share the same concrete domain (there can be more than one concrete domain that corresponds to a single theorem, though). So the activations in the concrete domain are (in) the (domain of) 'ground truth', in this way giving some degree of 'interoperability' between the various nodes/reasoning styles because they are (potentially) activating the same set(s) of items.

---

generalize limit order books and trading bots to a cognitive architecture.

generalize tuple spaces to contain not just data but also executable programs which can react to incoming events.

The idea is that there is an 'order book' which is a list/database of 'resting orders'. These 'resting orders' serve as both storage for state (like rows in a database), as events (an incoming order is like an event), and as event listeners (an order resting in the book can react to incoming orders by executing some program).

Orders include queries that determine against which other orders they can 'match'. When a new order arrives, it queries the existing orders, and the query might 'match' against one or more existing orders. If it matches an existing order, a handler in the new order is called, with the existing order provided as an argument, and has a change to execute some program.

If the new order does not cease to exist after it matches (or fails to match), and is added as a resting order to the order book, then the other orders in the book run their query against the new order to see if they match against it. If they do, then their handler(s) are called.

The queries are in an O(n) query language (meaning that the time and space complexity of executing the query is linear in the size of the other order against which it is testing for a match). This query language can be a graph regex, or more generally, it could just be a program defining the function doesOtherOrderMatchQuery, where the program must not contain backwards jumps, however the language does include primitives map/reduce/scan to iterate over parts of the other order.

The correspondant of limit order book 'last price' is the last matched pair of orders. The correspondant of limit order book 'bid/ask' is a mechanism to compute a reduction ('reduce') over all resting orders and present the result as a piece of state data (which is itself just a form of order).

---