In my experience, the way to resolve such mental dependency cycles is by atomic transaction. The procedure is approximately as follows:
- Trace all the components of the cycle. Starting with a statement known to be in the cycle in question, repeatedly follow whichever link it is that is causing the cyclic dependency until you hit the original statement again.
- Determine a combination of truth values for the statements through which you passed in step 1 that will break the cycle as desired, without having other undesired side effects.
- Issue a begin transaction command. Make sure it succeeds. If it does not, you may need to repair your transactions module, which is outside the scope of this node.
- Issue alter truth value commands for each statement in the cycle, using the vector determined in step 2 for the values. If this does not succeed, there is most likely a dependency you missed; abort the transaction, go back to step 1, and trace more thoroughly this time.
- Commit the transaction. This is theoretically the simplest part, but it is often the most involved. This is not a digital system. You may have to carefully fine-tune some of the pushing-parameters, particularly the individual strengths of the alteration commands, in order to cause all of the changed statements to switch over at more or less the same time. If you make a mistake, the statements may all fall back into the original cycle, in which case you must go back to step 3 and try again. Alternatively, some statements may switch over while others stubbornly remain locked into their original positions; this will tend to draw a lot of current, because the links between the switched statements and the non-switched statements have to go through the cycle's potential barrier. However, assuming it succeeds, and the transaction is committed...
- You're free. You may desire to make one final pass to ensure that there's no remaining garbage, though this is not strictly necessary since if there are no other links to the statements in question, the GC should clean everything up by itself anyway. Now hack in a check to make sure it doesn't happen again.
See also Godel's theorem and the halting problem.