Can P1 write to P2, or are we just manipulating the state of P1 so that it avoids conflicting productions?

>>> Benjamin

Yes, rules in P1 can write to P2 and vice-versa.

If it helps, you can think of P1 as an agent, P2 as its environment, and the eg K8/0 transfered from P2 to P1 as something akin to the energy needed by P1 to act and survive. But this reading of the abstract mathematical system is just a reading and may merely confuse.the task of designing MECE

I forgot to specifiy that both P1 and P2 are finite...

Just a heuristic. If we are allowed to have multiple rules with the same condition, you can simply setup rules R/t => S_i/u_i that together trigger a rule S_1/u_1 &...& S_m/u_m=> K8/0 in P2 for all rules S=>R/t that write to the working memory of P1. The issue would be conflicting writes to the S_i that might occur because of inconsistent conditions of these rules in P2, and in this case you would need to ignore some rules of P2. Does this work?

>> Ben Keller

“If we are allowed to have multiple rules with the same condition, you can simply setup rules R/t => S_i/u_i that together trigger a rule S_1/u_1 &...& S_m/u_m=> K8/0 in P2 for all rules S=>R/t that write to the working memory of P1. The issue would be conflicting writes to the S_i that might occur because of inconsistent conditions of these rules in P2, and in this case you would need to ignore some rules of P2”

YES, this is roughly the road I have been trying to follow for MECE. Two possible next steps:

(A)   It seems that MECE needs to set rules in P1 designed to block “clobbering” (via writing to P2) (NB “clobbering” you call “conflicting writes”)

NB Multiple rules with the same condition ok, but No ignoring of rules in P2!

(B)The time has maybe come to move to the Mark 2 version of the problem in which the set of rules that MECE can add to P1 is restricted to an arbitrary finite set of rules, Z.

With (A) and (B) things seem to get more tricky and I can’t yet see clear – hence Question upload…

By "ignoring" the rules of P2, I meant algorithmically. In other words, not adding new rules that would trigger their conditions. Though, clobbering that doesn't block any of the rules should be equivalent to not enabling some of them.

I would imagine that (A) has some analog in mutual exclusion where there is a transferrable result. 

For (B), we can figure out what rules should enable or block/delay, what happens when you do a maximal selection of useful rules? It is not clear to me that you can make things worse by adding one of these rules.

Not sure about this. Doesn't the "usefulness" of a rule of P1 depend upon the (in general highly dynamic) content of the wm of P2? So the "right" choice of rules to execute in P1 varies with time and is complex.

Or am I seeing complications that don't exist...?

Well, certainly it is about manipulating the state of P1 and P2, and it may not be generally possible. And, that would be about as complicated as it gets.

I think you can get a little closer by looking at when mutual clobbering occurs. The question is whether the underlying state structure of the rules of P2 allows you to try to force mutually clobbering rules into separate phases of operation. I can see how this might be done with the kind of enabling rules we were talking about earlier, but it requires that the rules of P2 be related so that we can put the relevant parts of P2's wm into a state that would trigger one rule while triggering a rule that precedes the other (causing a delay). 

I'm going to bet that the technical answer to your question is that it is not possible to find an algorithm (a terminating procedure with guarantee) that works for all problems.

Another relevant point, I think, is that since everything is finite, MECE can merely perform an exhaustive search of all possible rule set additions to P1, trial them itself, and simply return the winner. Of course this makes MECE look more like an AI learning program than an algorithm in a formal sense.

So you lose your bet?

The foregoing observation suggests to me that the problem specification needs to be extended to:  specify a MECE that EFFICIENTLY finds an optimal rule set to be added to P1.

I was probably adding some constraint that you hadn't made. Maybe that you can make an improvement.

Two possibilities for MECE seem to have emerged: (i) a dumb EXHAUSTIVE SEARCH which systematically tries out every possible set of additional rules for P1 (without reference to the actual structure of P2) and returns whatever rule set performs best – this will be computationally feasible only for finite and very small “toy” systems and it will not be clear HOW the optimal rule set  does whatever it does -- and (ii) a CLEVER and relatively efficient MECE algorithm which does examine the structure of P2 and which sets effective rules in P1 accordingly.

As yet we have only (good!) insights for the CLEVER algorithm. It’s not certain that such an algorithm will always succeed.

To be continued…

CONTINUING the search for an optimal algorithm MECE (see original question and consequent discussion)

I have uploaded with this answer a C program which runs [in Microsoft Developer Studio] a decidedly non-optimal MECE in a simple test arrangement comprising an interacting pair of production systems. I have uploaded also the corresponding output file.

The code is commented but ragged, primitive and quite possibly a touch bugged. It has been adapted from more general code (which amongst other things randomly generates a multiple-agent system with agents that are production systems) and this will be evident.   I offer the code merely as perhaps thought-provoking.

NO ONE SHOULD RELY ON THIS CODE FOR ANY PURPOSE except to read it for additional insight into the question posed!

The version of MECE implemented (as “Variant 2”) uses recursion to backward chain through the rules (called “derivation rules” or just “derivations” in the program) and retains all the rules from the additional randomly generated set of rules Z (called Q in the program)  that contribute to the desired multiple writes to P1 (P1 is called Ag1 in the program) discarding other rules.

Note that working memory elements are (confusingly!) called “exass”.

Incompatibilities between working memory elements (e.g. a variable cannot be in the wm both with the value 3 and the value 7) are handled by the use of “conflict sets”. However, Variant 2 of MECE pays no attention to the impact of conflicts and their resolution.

Variant 3 of MECE, now to be implemented, must surely pay attention to conflicts. HOW??

Any ideas as to the design of MECE Variant 3 will be most welcome!