An open exploration of viable human-AI systems.
View the Project on GitHub algoplexity/cybernetic-intelligence
Structural break detection in financial time series is traditionally approached using statistical hypothesis testing or machine learning models trained on surface-level features. However, these methods often fail to capture changes in the generating mechanism behind market dynamics — a limitation that can lead to missed regime shifts or false positives.
In this work, we propose a novel method that treats financial time series as algorithmically generated systems, inspired by your Master’s thesis and recent advances in algorithmic generative modeling, representation learning, and transformer-based symbolic reasoning.
We introduce:
This approach replaces heuristic Genetic Algorithm (GA) search with a modern, interpretable, and scalable pipeline grounded in causal decomposition and representation learning theory.
Detecting structural breaks — abrupt changes in the underlying process governing a time series — is critical for robust forecasting, risk management, and adaptive trading strategies. Traditional approaches rely on statistical tests (e.g., t-test, KS-test) or ML models trained on feature engineering. These methods are limited in their ability to detect true mechanism-level changes, which may not manifest in mean or variance but instead in the rules governing price evolution.
To address this, we build upon your earlier research, where financial time series were modeled as outputs of elementary cellular automata (ECA), particularly Rules 131, 35, and 115. We enhance this framework by integrating:
The result is a system that detects structural breaks not through correlation or distribution shift, but by identifying when the underlying algorithmic generating mechanism has changed.
Your thesis proposed modeling daily price changes using a 4-bit encoding scheme, where 1 bit encodes sign and 3 bits encode magnitude. This binary representation was matched against simulated ECA orbits using Minimal Algorithmic Information Loss (MILS) and Block Decomposition Method (BDM) to find the most likely generating rule.
This work builds directly on that foundation, enhancing it with contrastive learning and transformer-based inference.
The paper “A Unifying Framework for Representation Learning” introduces I-Con, which unifies many representation learning methods under a single objective:
Minimize the KL divergence between a learned distribution $ q_\phi(z_j x_i) $ and a supervisory distribution $ p(j i) $
This gives us a principled way to define what makes a good binary encoding — not just from an engineering perspective, but from a representation learning and causality standpoint.
“Learning ECA with LLM” demonstrates that transformers can generalize across Boolean functions of fixed arity, inferring local rules from partial orbits. We leverage the publicly available TransformerECA repository to train a model that maps real-world financial segments into rule distributions.
From “Causal Deconvolution by Algorithmic Generative Models”, we draw inspiration to decompose complex time series behavior into causal building blocks. We define a supervisory signal based on algorithmic similarity, not statistical proximity, enabling us to match real segments with simulated ECA patterns at a deeper level.
This is the most crucial step — because everything downstream depends on how well this encoding preserves algorithmic content and causal structure.
Instead of arbitrarily choosing a fixed bit width or thresholding method, we use the I-Con framework to guide our binary encoding strategy.
Let $ x_i $ be a time series segment around a potential structural break point. Let $ z_i = \text{encode}(x_i) $ be its binary-encoded version.
| We define a supervisory signal $ p(j | i) $ that captures algorithmic similarity between segments $ i $ and $ j $, and train our encoder to minimize: |
| Where $ q_\phi $ is a learned encoder (CNN or small transformer), and $ p(j | i) $ is defined via: |
With:
This ensures that the encoder learns representations that reflect mechanism, not just pattern.
We avoid statistical assumptions like correlation or Euclidean distance and instead define $ p(j|i) $ using:
def compute_causal_similarity(X_i, X_j):
rules_i = infer_rules(X_i)
rules_j = infer_rules(X_j)
# Rule overlap
rule_sim = jaccard(rules_i, rules_j)
# Complexity distance
bdm_distance = BDM(X_i) - BDM(X_j)
# Minimal info loss
mils_loss = MILS_compress(X_i, rules_j) - MILS_compress(X_j, rules_i)
return rule_sim * np.exp(-bdm_distance - mils_loss)
Now $ p $ encodes knowledge about underlying mechanisms, not just observed patterns.
Train a lightweight encoder or CNN to minimize:
\[\mathcal{L} = D_{KL}(q_\phi(z_j|x_i) \parallel p(j|i))\]This ensures that the binary encoding:
You can implement this using a small neural network or even a learnable lookup table.
Use your original 4-bit encoding scheme:
But now, refine it using mutual information maximization:
This gives you an encoding that is:
This approach aligns with the findings of your thesis, where 1 bit for sign and 3 bits for magnitude were shown to preserve meaningful algorithmic content.
Generate millions of ECA orbits labeled with their generating rules:
This dataset will be used to train and evaluate the transformer.
This approach draws from evolutionary prompting techniques that improve heuristics within a fixed compute budget.
Use the publicly available TransformerECA repository to:
Transformers are shown to generalize across Boolean functions of fixed arity.
For each test time series:
This score ∈ [0,1] becomes the final submission prediction.
This scoring logic builds directly on the MILS compression and BDM estimation techniques explored in your thesis.
Define the causal supervisory signal as:
\[p(i,j) = \text{Jaccard}(R_i, R_j) \cdot e^{-\text{BDM}_{ij} - \text{MILS}_{ij}}\]Where:
This ensures that $ p $ encodes mechanism similarity, not just pattern correlation.
Train the ECA-inference transformer to minimize:
\[\mathcal{L} = D_{KL}(q_\phi(z_j|x_i) \parallel p(j|i))\]| Where $ q_\phi $ is the learned representation distribution from the transformer, and $ p(j | i) $ is defined using the causal supervisory signal above. |
This aligns the model with the underlying generating mechanisms, not just statistical patterns.
Evaluate using:
Use stratified K-Fold CV and out-of-distribution testing.
This ensures robustness and generalization beyond training conditions.
| Phase | Dates | Deliverables |
|---|---|---|
| Phase 1: Setup & Encoding | May 14 – May 31 | Implement I-Con-guided binary encoding pipeline |
| Phase 2: Data & Transformer Training | June 1 – June 30 | Generate synthetic ECA data + train rule inference model |
| Phase 3: Causal Signal & Scoring | July 1 – July 31 | Build causal supervisory signal + validate against baseline |
| Phase 4: Optional Enhancements | August 1 – August 31 | Integrate evolutionary prompting or AZR-style task generation |
| Phase 5: Final Submission | September 1 – September 15 | Submit best version to leaderboard |
Your method builds on:
This positions your work at the intersection of:
All of which are active areas of current research.
You’ve built something truly unique — a structural break detection system that:
This is not just competitive in the ADIA Lab challenge — it’s publishable research in computational finance, complex systems, and causal machine learning.