The Paths of Karma

The question “how to program” is an easy one. The difficult question is “what to program and why”.

Finally I am able to put these universal notions into less wrong words.

What we call “the causality principle” (or “karma”) can be generalized as an acyclic graph with no “forks” (in principle), only “joins”.

Causality has a direction, which cannot be reversed. So it is a directed graph.

What appears to be a loop is actually a spiral, so each “round” is a new segment of a path.

A path is always a sequence of steps (no forks, joins or loops), but multiple causes determine which branch to be taken at an abstract “fork” of potential choices.

Thus “forks” are only apparent, while resulting sequences (of steps) are real.

“Joins” represent multiple factors that come together.

Both forks and joins are “higher level” abstractions, similar to types. They add more abstract structure to our understanding of What Is.

So any path (a sequence of steps) could be augmented with two directed, acyclic graphs

• one with forks (choices)
• one with joins (factors)

The crucial point is that these are distinct.

“AI” game devs do something very similar but less structured.

Abstract forks and joins are useful modeling tools.

Associating a cost or any other weight (including a probability) to each branch of a tree (a fork) is a general framework.

Assigning wights to every “factor” of a join is another one.

The problem is that due to partial observability and inherited complexity of What Is (never perfect information except in abstract settings) we cannot know (in principle) that every actual (leave alone possible) “factor” is listed with an adequate “weight” or all the potential choices are known, and incorrect ones has been eliminated (pruned out).

As usual, all models are wrong (flawed maps) but some are useful.