# Formalizing Causality (CA) via Network Structure and Influence Propagation ## 1. Objective: Explicitly Modeling Directed Influence Previous nodes ([[releases/archive/Information Ontology 1/0095_IO_State_Formalism]], [[releases/archive/Information Ontology 1/0096_IO_Formal_Transition_KM]]) developed a formal state representation and transition rule incorporating Η, Θ, K, and M. However, **Causality (CA)** [[releases/archive/Information Ontology 1/0008_Define_Causality_CA]] – the principle of directed dependency between state changes over Sequence (S) – was only implicitly represented by the dependence of `State(S+1)` on `State(S)`. To make CA explicit and allow for non-local influences or varying causal strengths, we need a representation of the **causal network structure** itself and rules for how influence propagates and modifies transition probabilities. This node proposes such a formalism, drawing on network/graph theory [[releases/archive/Information Ontology 1/0019_IO_Mathematical_Formalisms]] and mechanisms discussed in [[releases/archive/Information Ontology 1/0072_IO_Causality_Mechanisms]]. ## 2. Proposed Formalism: Dynamic Directed Weighted Graph Represent the IO system as a **dynamic directed graph** `G = (V, E)`: * **Nodes `V`:** Represent informational loci `i`. Each node `i` has a state `State(i, S) = { ε(i, S), κΘ(i, S) }` as defined in [[releases/archive/Information Ontology 1/0095_IO_State_Formalism]]. * **Directed Edges `E`:** An edge `e = (j → i)` represents a potential **causal influence** from node `j` to node `i`. The existence of an edge implies that the state of `j` at step `S` can influence the transition probability or target state of `i` at step `S+1`. * **Edge Weights `w(j → i, S)`:** Each edge has a dynamic weight `w ≥ 0` representing the **strength of the causal influence**. Higher weight means stronger influence. * **Network Dynamics:** Both node states and the edge structure/weights can evolve over Sequence (S). ## 3. Incorporating CA into the State Transition Rule The state transition rule from [[releases/archive/Information Ontology 1/0096_IO_Formal_Transition_KM]] needs modification to incorporate influence from incoming causal edges. **Modification Idea:** The probability of change `P_change(i, S)` and/or the target state determination for node `i` should be influenced not just by immediate neighbors (as used for K and M previously), but by the states `ε(j, S)` of all nodes `j` that have a causal edge pointing to `i` (`j → i`), weighted by the causal strength `w(j → i, S)`. **Example Modification (Influencing Change Probability):** Let `CausalInput(i, S) = Σ_{j | (j → i) ∈ E} w(j → i, S) * ε(j, S)` (Weighted sum of causal inputs). The probability of change could become: `P_change(i, S) = f_H(...) * f_Θ(...) * f_K(...) * f_{CA}(CausalInput(i, S))` Where `f_{CA}` is a function modulating the probability based on the total causal input. This allows past events across the network (not just immediate neighbors) to influence current transitions according to the established causal pathways. **Example Modification (Influencing Mimicry Target):** The calculation of `N_0` and `N_1` (neighbor states for M bias) in [[releases/archive/Information Ontology 1/0096_IO_Formal_Transition_KM]] could be replaced by a weighted calculation using incoming causal edges: `Weighted_N_0 = Σ_{j | (j → i) ∈ E, ε(j,S)=0} w(j → i, S)` `Weighted_N_1 = Σ_{j | (j → i) ∈ E, ε(j,S)=1} w(j → i, S)` These weighted counts would then be used in the `P(target=...)` calculation, making the mimetic bias depend on causally connected nodes, weighted by influence strength. *(Note: These are examples; the specific functional forms `f_{CA}` or the exact way weighted inputs combine require further theoretical development or fitting to desired emergent behavior.)* ## 4. Dynamic Edge Weights: Incorporating Theta (Θ) into CA Causality is not static; pathways are reinforced by use. This is where **Theta (Θ)** [[releases/archive/Information Ontology 1/0015_Define_Repetition_Theta]] interacts directly with CA [[releases/archive/Information Ontology 1/0069_IO_Theta_Mechanisms]]. * **Theta Reinforcement Rule for Edges:** The weight `w(j → i, S)` should increase if the causal link proves "successful" or is frequently active. * *Mechanism Example:* If node `j` being in state `ε(j, S)` contributes significantly (e.g., via the `f_{CA}` term or M bias) to node `i` transitioning to a specific state `ε(i, S+1)` that is subsequently stable (high `Θ_val(i, S+2)`), then the weight `w(j → i)` could be increased at step `S+2`. * `w(j → i, S+1) = w(j → i, S) + Δw_inc * ReinforcementSignal(i, S+1)` * `ReinforcementSignal` could depend on the correlation between `ε(j, S)` and `ε(i, S+1)` and/or the resulting stability `Θ_val(i, S+1)`. * **Decay/Pruning:** Edge weights could decay slowly over time if the causal link is not reinforced, potentially being pruned if the weight falls below a threshold. `w(j → i, S+1) = w(j → i, S) * (1 - decay_rate)` (if not reinforced). This dynamic weighting allows the causal network structure itself to adapt and learn based on the history of interactions, embodying Θ's role in stabilizing successful pathways. ## 5. Emergent Locality and Non-Locality [[releases/archive/Information Ontology 1/0016_Define_Adjacency_Locality]], [[releases/archive/Information Ontology 1/0066_IO_Locality_NonLocality]] This formalism can naturally accommodate both local and non-local causality: * **Local CA:** Edges primarily exist between nodes that are "close" in the emergent spatial structure (defined perhaps by short paths of strong `w` edges). Influence propagates step-by-step. * **Non-Local CA (Entanglement):** Represented by specific edges `(j → i)` that exist even when `i` and `j` are distant in the emergent spatial sense. These edges might have specific properties (e.g., fixed maximum weight, mediating instantaneous influence on transition *probabilities* rather than propagating signals). ## 6. Advantages of this Formalism * **Explicit Causality:** Makes causal links and their strengths explicit parts of the model. * **Dynamic Structure:** Allows the causal network to evolve and adapt (learning). * **Integrates Θ:** Provides a mechanism for Theta to reinforce causal pathways. * **Handles Locality/Non-Locality:** Can represent both local influence propagation and non-local correlations. * **Foundation for Complex Dynamics:** Enables modeling of feedback loops, information flow, and complex network effects. ## 7. Challenges and Next Steps * **Defining Weight Dynamics:** Specifying the precise rules for edge weight updates (Θ reinforcement) and decay requires careful consideration and likely tuning. * **Computational Cost:** Simulating large dynamic graphs with evolving weights can be computationally intensive. * **Initialization:** How is the initial causal network structure determined? * **Next Steps:** * Implement this dynamic graph structure in a simulation environment. * Integrate the modified transition rules (incorporating `CausalInput` or weighted M bias) with the state update rules from [[releases/archive/Information Ontology 1/0096_IO_Formal_Transition_KM]]. * Define and test specific Θ reinforcement rules for edge weights. * Explore the emergence of stable causal structures and information propagation patterns. ## 8. Conclusion: Causality as an Evolving Network Process This node proposes formalizing Causality (CA) in Information Dynamics using a **dynamic, directed, weighted graph**. Nodes represent informational loci with κ/ε/Θ states, while weighted directed edges represent causal influence pathways. The strength of these pathways evolves over Sequence (S) based on usage and success, mediated by Theta (Θ). This structure allows the state transition rules to explicitly incorporate influence from causally connected nodes (both local and potentially non-local), weighted by the strength of the connection. This formalism provides a richer, more explicit representation of causal structure and its evolution compared to implicit nearest-neighbor rules, offering a promising avenue for modeling complex emergent phenomena, learning, and adaptation within the IO framework.