Consider writing a program with types and semi-colons. Now, instead of giving variables a deterministic input you randomly sample from the allowed values of that type. And instead of `;` meaning, "advance one statement" it means "advance to some random statement later on in the program".

So: fn example(x: int) = print("A", x); print("B", x); print("C", x)

Is evaluated `example(63) // C63,A63,B63` on one run, and example(21), etc. on another.

This is something like the notion of "program" (or "reasoning") which stochastic AI provides, though its a little worse than this, since programs can be composed (ie., you can cut-and-paste lines of code and theyre still valid) -- where as the latent representations of "programs" as weights do not compose.

So what i mean by "deductive" constraints is that the AI system works like an actual program: there is a single correct output for a given input, and this output obtains deterministically: `int` means "an int", `;` means `next statement".

In these terms, what I mean by "causal" is that the program has a different execution flow for a variety of inputs, and that if you hit a certain input necessarily certain execution-flows are inaccessible, and other ones activated.

Again analogously, what I mean by "act according to a goal" is that of a family of all available such programs: P1..Pn, there is a metaprogram G which selects the program based on the input, and recurses to select another based on the output: so G(..G(G(P1..Pn), P2).. where G models preferences/desires/the-environment and so on.

In these very rough and approximate terms it may be more obvious why deductive/causal/intentional behaviour from a stochastic system is not reliably produced by it (ie., why a stochastic-; doesnt get you a determinsitic-;). By making the program extremely complex you can get kinda reliable deductive behaviour (consider eg., many print(A), many print(B), many print(C) -- so that its rare it jumps out-of-order). However, you pile on more deductive constraints you make out-of-order jumps / stochastic-behaviour exponentially more fragile.

Consider trying to get many families of deterministic execution flows (ie., programs which model hypothetical actions) from a wide variety of inputs with a "stochastic semi-colon" -- the text of this program would be exponentially larger than one with a deterministic semi-colon --- and would not be reliable!