By causal direction (X causes Y) I mean that in the induced graph of the structural causal model, X appears before Y. The graph induced by a structural causal model has an edge from X to Y if there is a structural equation Y = F(U_i, X, ... ).

It refers to Example 9.3 and the associated lemmas.

This example is a general rephrasing of Example 1 of finite factored sets in terms of random variables and structural causal models.

Example 9.3

We observe two nonconstant, (real valued) random variables $V_1$ and $V_2$. We assume that they are part of an unobserved true underlying causal model (𝑈, 𝑉 , 𝐹, ℙ), where 𝑉 = $(V_i{)}_{i\in I}$ and {1, 2} ⊆ 𝐼. We only observe the distribution of 𝑉 . Let $Z≔V_1+V_2$. Suppose that $V_1{⫫}_{P}Z$. Furthermore, we assume that ℙ is in ‘general position’. This means that this independence is not due to the specific choice of ℙ. Formally, $V_1{⫫}_{P}Z$ for all causal models (𝑈, 𝑉 , 𝐹, 𝑃) s.t. 𝑃 ∼ ℙ.

It says that any structural causal model that models the independence of $V_1$ and Z structurally (it is not a coincidence of precise numerical values of ℙ), then in this structural causal model has $V_1\to V_2$, i.e. in the graph induced by the causal model through it's equation, $V_1$ always is an ancestor of $V_2$ .

It is correct, but I agree the reasoning is not written out properly. I'll write y for $y^{\ast }$

We are in the case $g\left(x\right)>x^2$. So if $g\left(y\right)>=y^2$, then $g\left(x\right)+g\left(y\right)>x^2+y^2>=2xy$, where the last inequality is true because it's equivalent to $(x-y{)}^2>=0$. So we have $g\left(x\right)+g\left(y\right)>2xy$, which is a contradiction to the choice of y.

A direct application would need that you have an uncountable variable. You might want to do this if you have enough evidence to say this confidently. As a simple example imagine a real-valued graph where all your data points lie almost on the identity diagonal. You might then want to infer a variable which is the identity.

As a more general application, we want to model infinities because the world is probably infinite in some aspects. We then want a theorem that tells us, that even if the underlying model is infinite, if you have enough data points then you are close enough, like with the Strong law of Large numbers, for example.

Here, we need to find a variable W such that 

1. P(W|X,Y) is deterministic, because X and Y already fully describe our sample space. This means P(W|X,Y) is either 0 or 1
2. Z and W are independent
3. X and W are dependent
4. Y and W are dependent

I think your arguments in Section 3 to rule out Graph 3 can't be correct if you accept Graph 2.

To see this, note that there is a symmetry between $X$ and $Z$. Namely, if we use FFS temporal inference, then we know that $X$ and $Z$ are both before $Y$ (and $\neg Y$ ).(here we even have $P(X=x,Z=z)=P(X=z,Z=x)$, so they are entirely exchangeable).

Therefore, if you accept Graph 2 then we can clearly switch $X$ and $Z$ in Graph 2 and obtain a solution for Graph 3. Also, note that in these solutions $X=\neg W$ or $Z=\neg W$, so if we see variables as their information content, as in FFS, this is Graph 1 in disguise.

Also in Graph 2 there is a typo P(W=0|Z=0) instead of P(Z=0|W=0)

Two features are orthogonal if their $L_2$ norm is zero

Just as a side note about terminology: It is a bit imprecise that you use innerproduct and norm interchangeably.

Innerproduct is the function $<.,.>:H\times H\to R$ and the norm is $||.||:H\to R,x\mapsto \sqrt{<x,x>}$

The internals of a system of course determine its functional behavior. But there might be different systems that differ only in what they actually do. E.g. different sort algorithms all end up with a sorted list but sort it differently. Likewise, a pathfinding algorithm like Dijkstra is different than checking every possible path and picking the best one. 

Looking only at functional behavior strips you of your ability to make predictions. You only know what has already happened. You can't generalize to new inputs.

This is the actual crux of why we care about the internals. We don't know the functional behavior of a NN except by executing it (There are some Interpretability tools but not sufficiently so). We want to understand what a NN will do before executing it.

Let's put this in the context of an AGI: We have a giant model which is executed on multiple GPUs. Ideally, we want to know that it won't kill us without trying to run it. If we would have a method to find 'search processes' and similar things going on in its brain, then we could see if it searches for things like 'how can I disempower humanity?'.

This is not what I meant (I've edited the post to make that clearer). I am looking for a way to naturally express that a result of a computation changes how the computation progresses. In a*(b+c) + (1-a)*(b-c) you compute both (b+c)and (b-c) . This is not what actually happens in the program.

The curried node is an interesting idea but breaks down if we move away from this toy example. If both branches contain subgraphs with a different amount of nodes and different connections between them then currying does not work (or is very unnatural).

(Currying is a nice idea so yes)

Turing completeness regards only the functional behavior of a class of computational systems. I want to look at the internals, what the system is actually doing, and find abstractions in there: Modularity, search processes, and steering mechanisms for instance.

So it’s not about finding yet another framework whose expressiveness is equivalent to Turing completeness. It’s about finding a framework to express the actual computation.