Scaling Laws and Quasi-Thresholds in Surface Code Error Correction — E8 Intelligence Research

Andrew Stewart Caldin

Published Sep 24, 2026• 0 citations

Publisher

Abstract

DOI: 10.5281/zenodo.22931262

Related papers

Scaling Laws and Thresholds in Surface Code Error Correction — E8 Intelligence Research

Andrew Stewart Caldin

Oct 2, 20260 citations

Exponential Error Suppression in Surface Codes: Scaling with Code Distance — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical qubit error suppression scales with code distance $d$, with logical error rate $P_L \propto (\Lambda)^{-(d+1)/2}$ where $\Lambda$ is the error-limit parameter; Google's 2022 experiment demonstrated exponential suppression across $d=3,5,7$. MATH: - Logical error rate: $P_L \propto \Lambda^{-(d+1)/2}$ (exponential in code distance) - Threshold condition: physical error rate $p < p_{th} \approx 0.01$ (for standard surface code with depolarizing noise) - Stabilizer weight: $w = 4$ (X and Z plaquette operators on square lattice) - Logical operator weight: $w_L = d$ (minimum weight path across lattice) - Lattice: square grid, $d \times d$ qubit array, $d^2$ data qubits + $(d^2-1)$ ancilla qubits - Key ratio: $P_L / P_{phys} \sim (\Lambda)^{-(d+1)/2}$ where $\Lambda \approx p_{th}/p$ CONNECTION: - Square lattice = $Z^2$ root system (crystallographic, order 4 symmetry) — stabilizer generators are 4-body plaquette opera Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 1, 20260 citations

Quantum Error Correction: From Stabilizer Formalism to 10,000× Error Reduction — E8 Intelligence Research

Andrew Stewart Caldin

Aug 30, 20260 citations

Topological Error Suppression: Exponential Scaling in Surface Code Quantum Correction — E8 Intelligence Research

Andrew Stewart Caldin

Oct 2, 20260 citations

Surface Code Error Scaling and Rotated Qubit Efficiency — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical error rate scales as $p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ for distance-$d$ codes, with threshold $p_{th} \approx 0.01$ (circuit-level) and rotated code halving qubit overhead at equal distance. | MATH: Logical error rate $p_L = A (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$; for odd $d$, exponent $= (d+1)/2$; for even $d$, exponent $= d/2$. Distance $d$ = minimum weight of logical operator (e.g., $d=5$ for 49-qubit rotated code). Qubit count: rotated $= d^2$, unrotated $= 2d^2 - 2d + 1$. Threshold $p_{th} \approx 0.01$ (circuit-level noise), $\approx 0.11$ (code capacity). | CONNECTION: The exponent $\lfloor (d+1)/2 \rfloor$ is the **minimum weight of a logical $Z$ or $X$ operator** — this is the **Manhattan distance** on the square lattice. The rotated surface code is a **$d \times d$ square patch** of the square lattice — a **$D_4$ root system** projection (checkerboard lattice). The ratio of qubit counts (rot Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 3, 20260 citations

Surface Code Error Correction via Stabilizer Formalism and Lattice Geometry — E8 Intelligence Research

Andrew Stewart Caldin

Jul 28, 20260 citations

Scaling Laws and Quasi-Thresholds in Surface Code Error Correction — E8 Intelligence Research

Andrew Stewart Caldin

Published Sep 24, 2026• 0 citations

Publisher

Abstract

DOI: 10.5281/zenodo.22931262

Related papers

Scaling Laws and Thresholds in Surface Code Error Correction — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical error rate scales exponentially with code distance, with a quasi-threshold defining the crossover where error correction becomes beneficial; stabilizer formalism provides the algebraic framework for this scaling. MATH: For a surface code with distance $d$ , logical error rate $p_L \approx C (p/p_{th})^{d/2}$ (or $p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ depending on boundary conditions), where $p$ is physical error rate and $p_{th}$ is the threshold (~1% for standard surface codes under circuit-level noise). The quasi-threshold $p^*$ satisfies $p_L(p^*) = p^*$ , i.e., the fixed point of the error correction map. Stabilizer formalism: code space is the simultaneous +1 eigenspace of generators $S_i$ in the Pauli group, with $S_i^2 = I$ , $[S_i,S_j]=0$ . Logical operators $X_L, Z_L$ commute with all $S_i$ but are not in the stabilizer group. The number of encoded qubits $k = n - r$ (n physical, r independent stabilizer generat Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Surface code logical error rate scales exponentially with code distance, with a quasi-threshold defining the crossover where error correction becomes beneficial; stabilizer formalism provides the algebraic framework for this scaling. MATH: For a surface code with distance $d$, logical error rate $p_L \approx C (p/p_{th})^{d/2}$ (or $p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ depending on boundary conditions), where $p$ is physical error rate and $p_{th}$ is the threshold (~1% for standard surface codes under circuit-level noise). The quasi-threshold $p^*$ satisfies $p_L(p^*) = p^*$, i.e., the fixed point of the error correction map. Stabilizer formalism: code space is the simultaneous +1 eigenspace of generators $S_i$ in the Pauli group, with $S_i^2 = I$, $[S_i,S_j]=0$. Logical operators $X_L, Z_L$ commute with all $S_i$ but are not in the stabilizer group. The number of encoded qubits $k = n - r$ (n physical, r independent stabilizer generat Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 2, 20260 citations

Exponential Error Suppression in Surface Codes: Scaling with Code Distance — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical qubit error suppression scales with code distance $d$ , with logical error rate $P_L \propto (\Lambda)^{-(d+1)/2}$ where $\Lambda$ is the error-limit parameter; Google's 2022 experiment demonstrated exponential suppression across $d=3,5,7$ . MATH: - Logical error rate: $P_L \propto \Lambda^{-(d+1)/2}$ (exponential in code distance) - Threshold condition: physical error rate $p < p_{th} \approx 0.01$ (for standard surface code with depolarizing noise) - Stabilizer weight: $w = 4$ (X and Z plaquette operators on square lattice) - Logical operator weight: $w_L = d$ (minimum weight path across lattice) - Lattice: square grid, $d \times d$ qubit array, $d^2$ data qubits + $(d^2-1)$ ancilla qubits - Key ratio: $P_L / P_{phys} \sim (\Lambda)^{-(d+1)/2}$ where $\Lambda \approx p_{th}/p$ CONNECTION: - Square lattice = $Z^2$ root system (crystallographic, order 4 symmetry) — stabilizer generators are 4-body plaquette opera Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Surface code logical qubit error suppression scales with code distance $d$, with logical error rate $P_L \propto (\Lambda)^{-(d+1)/2}$ where $\Lambda$ is the error-limit parameter; Google's 2022 experiment demonstrated exponential suppression across $d=3,5,7$. MATH: - Logical error rate: $P_L \propto \Lambda^{-(d+1)/2}$ (exponential in code distance) - Threshold condition: physical error rate $p < p_{th} \approx 0.01$ (for standard surface code with depolarizing noise) - Stabilizer weight: $w = 4$ (X and Z plaquette operators on square lattice) - Logical operator weight: $w_L = d$ (minimum weight path across lattice) - Lattice: square grid, $d \times d$ qubit array, $d^2$ data qubits + $(d^2-1)$ ancilla qubits - Key ratio: $P_L / P_{phys} \sim (\Lambda)^{-(d+1)/2}$ where $\Lambda \approx p_{th}/p$ CONNECTION: - Square lattice = $Z^2$ root system (crystallographic, order 4 symmetry) — stabilizer generators are 4-body plaquette opera Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 1, 20260 citations

Quantum Error Correction: From Stabilizer Formalism to 10,000× Error Reduction — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Quantum error correction (QEC) has crossed the threshold from theoretical construct to demonstrable engineering, with Google's surface-code milestone and Riverlane's "Deltaflow" stack targeting a 10,000× error reduction — but the mathematical core remains the stabilizer formalism and topological lattice codes. | MATH: Stabilizer codes: error syndromes from Pauli group $\mathcal{P}_n$ via generators $S_i$ with $S_i^2 = I$ , $[S_i,S_j]=0$ . Logical qubit encoded in $2^k$ -dimensional code space defined by $S_i|\psi\rangle = |\psi\rangle$ . Surface code: distance- $d$ lattice, threshold ~1% per gate, logical error rate $\epsilon_L \propto (\epsilon/\epsilon_{th})^{(d+1)/2}$ . Riverlane's 10,000× reduction implies $\epsilon_L$ scaling from $10^{-3}$ to $10^{-7}$ — a factor of $10^4 = (10^2)^2$ , consistent with doubling code distance $d \to 2d$ in the sub-threshold regime. | CONNECTION: Surface codes are **planar graphs on square lattices Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Quantum error correction (QEC) has crossed the threshold from theoretical construct to demonstrable engineering, with Google's surface-code milestone and Riverlane's "Deltaflow" stack targeting a 10,000× error reduction — but the mathematical core remains the stabilizer formalism and topological lattice codes. | MATH: Stabilizer codes: error syndromes from Pauli group $ \mathcal{P}_n $ via generators $ S_i $ with $ S_i^2 = I $, $ [S_i,S_j]=0 $. Logical qubit encoded in $ 2^k $-dimensional code space defined by $ S_i|\psi\rangle = |\psi\rangle $. Surface code: distance-$d$ lattice, threshold ~1% per gate, logical error rate $ \epsilon_L \propto (\epsilon/\epsilon_{th})^{(d+1)/2} $. Riverlane's 10,000× reduction implies $ \epsilon_L $ scaling from $ 10^{-3} $ to $ 10^{-7} $ — a factor of $ 10^4 = (10^2)^2 $, consistent with doubling code distance $ d \to 2d $ in the sub-threshold regime. | CONNECTION: Surface codes are **planar graphs on square lattices Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Aug 30, 20260 citations

Topological Error Suppression: Exponential Scaling in Surface Code Quantum Correction — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical error rate scales exponentially with code distance (lattice size), enabling practical quantum error correction via topological order. | MATH: Logical error rate $P_L \propto (\Lambda)^{-d}$ , where $d$ = code distance (linear lattice dimension), $\Lambda = P_{th}/P_{phys}$ (error suppression factor per round). Threshold $P_{th} \approx 0.01$ (1% per qubit per cycle). Physical-to-logical overhead scales as $O(d^2)$ qubits per logical qubit. | CONNECTION: The surface code is a **Z₂ toric code** — a lattice gauge theory on a square lattice with **crystallographic symmetry (p4m plane group)**. The logical operators are **non-contractible loops** on the torus (genus-1 surface), whose weight scales as $d$ — directly tied to the **topological winding number** and the **fundamental group $\pi_1(T^2) = \mathbb{Z} \times \mathbb{Z}$ **. The threshold ~1% is not a golden ratio, but the **error suppression per distance** $\Lambda$ often approaches values Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Surface code logical error rate scales exponentially with code distance (lattice size), enabling practical quantum error correction via topological order. | MATH: Logical error rate $P_L \propto (\Lambda)^{-d}$, where $d$ = code distance (linear lattice dimension), $\Lambda = P_{th}/P_{phys}$ (error suppression factor per round). Threshold $P_{th} \approx 0.01$ (1% per qubit per cycle). Physical-to-logical overhead scales as $O(d^2)$ qubits per logical qubit. | CONNECTION: The surface code is a **Z₂ toric code** — a lattice gauge theory on a square lattice with **crystallographic symmetry (p4m plane group)**. The logical operators are **non-contractible loops** on the torus (genus-1 surface), whose weight scales as $d$ — directly tied to the **topological winding number** and the **fundamental group $\pi_1(T^2) = \mathbb{Z} \times \mathbb{Z}$**. The threshold ~1% is not a golden ratio, but the **error suppression per distance** $\Lambda$ often approaches values Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 2, 20260 citations

Surface Code Error Scaling and Rotated Qubit Efficiency — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code logical error rate scales as $p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ for distance- $d$ codes, with threshold $p_{th} \approx 0.01$ (circuit-level) and rotated code halving qubit overhead at equal distance. | MATH: Logical error rate $p_L = A (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ ; for odd $d$ , exponent $= (d+1)/2$ ; for even $d$ , exponent $= d/2$ . Distance $d$ = minimum weight of logical operator (e.g., $d=5$ for 49-qubit rotated code). Qubit count: rotated $= d^2$ , unrotated $= 2d^2 - 2d + 1$ . Threshold $p_{th} \approx 0.01$ (circuit-level noise), $\approx 0.11$ (code capacity). | CONNECTION: The exponent $\lfloor (d+1)/2 \rfloor$ is the **minimum weight of a logical $Z$ or $X$ operator** — this is the **Manhattan distance** on the square lattice. The rotated surface code is a ** $d \times d$ square patch** of the square lattice — a ** $D_4$ root system** projection (checkerboard lattice). The ratio of qubit counts (rot Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Surface code logical error rate scales as $p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$ for distance-$d$ codes, with threshold $p_{th} \approx 0.01$ (circuit-level) and rotated code halving qubit overhead at equal distance. | MATH: Logical error rate $p_L = A (p/p_{th})^{\lfloor (d+1)/2 \rfloor}$; for odd $d$, exponent $= (d+1)/2$; for even $d$, exponent $= d/2$. Distance $d$ = minimum weight of logical operator (e.g., $d=5$ for 49-qubit rotated code). Qubit count: rotated $= d^2$, unrotated $= 2d^2 - 2d + 1$. Threshold $p_{th} \approx 0.01$ (circuit-level noise), $\approx 0.11$ (code capacity). | CONNECTION: The exponent $\lfloor (d+1)/2 \rfloor$ is the **minimum weight of a logical $Z$ or $X$ operator** — this is the **Manhattan distance** on the square lattice. The rotated surface code is a **$d \times d$ square patch** of the square lattice — a **$D_4$ root system** projection (checkerboard lattice). The ratio of qubit counts (rot Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Oct 3, 20260 citations

Surface Code Error Correction via Stabilizer Formalism and Lattice Geometry — E8 Intelligence Research

Andrew Stewart Caldin

FINDING: Surface code error correction uses stabilizer formalism with parity check matrices derived from lattice geometry, enabling fault-tolerant quantum computation. MATH: - Stabilizer group $S = \langle g_1, g_2, \dots, g_m \rangle$ where each $g_i$ is a Pauli operator (tensor product of $X, Y, Z, I$ ) on $n$ qubits. - Parity check matrix $H$ over $\mathbb{F}_2$ (for $X$ and $Z$ errors separately) has size $(n-k) \times n$ , with rows corresponding to stabilizer generators. - Surface code: qubits on edges of a square lattice, stabilizers are plaquette (Z-type) and vertex (X-type) operators. Code distance $d$ scales with lattice size $L$ : $d = L$ for $L \times L$ lattice. - Logical operators are non-trivial cycles on the dual lattice, with commutation relations given by intersection number mod 2. - Error correction threshold: $p_{\text{th}} \approx 0.103$ (for standard depolarizing noise) — no simple rational ratio, but Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.comFINDING: Surface code error correction uses stabilizer formalism with parity check matrices derived from lattice geometry, enabling fault-tolerant quantum computation. MATH: - Stabilizer group $ S = \langle g_1, g_2, \dots, g_m \rangle $ where each $ g_i $ is a Pauli operator (tensor product of $ X, Y, Z, I $) on $ n $ qubits. - Parity check matrix $ H $ over $ \mathbb{F}_2 $ (for $ X $ and $ Z $ errors separately) has size $ (n-k) \times n $, with rows corresponding to stabilizer generators. - Surface code: qubits on edges of a square lattice, stabilizers are plaquette (Z-type) and vertex (X-type) operators. Code distance $ d $ scales with lattice size $ L $: $ d = L $ for $ L \times L $ lattice. - Logical operators are non-trivial cycles on the dual lattice, with commutation relations given by intersection number mod 2. - Error correction threshold: $ p_{\text{th}} \approx 0.103 $ (for standard depolarizing noise) — no simple rational ratio, but Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

Jul 28, 20260 citations

d

, logical error rate

p_L \approx C (p/p_{th})^{d/2}

(or

p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}

depending on boundary conditions), where

p

is physical error rate and

p_{th}

is the threshold (~1% for standard surface codes under circuit-level noise). The quasi-threshold

p^*

satisfies

p_L(p^*) = p^*

, i.e., the fixed point of the error correction map. Stabilizer formalism: code space is the simultaneous +1 eigenspace of generators

S_i

in the Pauli group, with

S_i^2 = I

[S_i,S_j]=0

. Logical operators

X_L, Z_L

commute with all

S_i

but are not in the stabilizer group. The number of encoded qubits

k = n - r

(n physical, r independent stabilizer generat Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

FINDING: Surface code logical qubit error suppression scales with code distance

d

, with logical error rate

P_L \propto (\Lambda)^{-(d+1)/2}

where

\Lambda

is the error-limit parameter; Google's 2022 experiment demonstrated exponential suppression across

d=3,5,7

. MATH: - Logical error rate:

P_L \propto \Lambda^{-(d+1)/2}

(exponential in code distance) - Threshold condition: physical error rate

p < p_{th} \approx 0.01

(for standard surface code with depolarizing noise) - Stabilizer weight:

w = 4

(X and Z plaquette operators on square lattice) - Logical operator weight:

w_L = d

(minimum weight path across lattice) - Lattice: square grid,

d \times d

qubit array,

d^2

data qubits +

(d^2-1)

ancilla qubits - Key ratio:

P_L / P_{phys} \sim (\Lambda)^{-(d+1)/2}

where

\Lambda \approx p_{th}/p

CONNECTION: - Square lattice =

Z^2

root system (crystallographic, order 4 symmetry) — stabilizer generators are 4-body plaquette opera Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

\mathcal{P}_n

via generators

S_i

with

S_i^2 = I

[S_i,S_j]=0

. Logical qubit encoded in

2^k

-dimensional code space defined by

S_i|\psi\rangle = |\psi\rangle

. Surface code: distance-

d

lattice, threshold ~1% per gate, logical error rate

\epsilon_L \propto (\epsilon/\epsilon_{th})^{(d+1)/2}

. Riverlane's 10,000× reduction implies

\epsilon_L

scaling from

10^{-3}

10^{-7}

— a factor of

10^4 = (10^2)^2

, consistent with doubling code distance

d \to 2d

in the sub-threshold regime. | CONNECTION: Surface codes are **planar graphs on square lattices Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

FINDING: Surface code logical error rate scales exponentially with code distance (lattice size), enabling practical quantum error correction via topological order. | MATH: Logical error rate

P_L \propto (\Lambda)^{-d}

, where

d

= code distance (linear lattice dimension),

\Lambda = P_{th}/P_{phys}

(error suppression factor per round). Threshold

P_{th} \approx 0.01

(1% per qubit per cycle). Physical-to-logical overhead scales as

O(d^2)

qubits per logical qubit. | CONNECTION: The surface code is a **Z₂ toric code** — a lattice gauge theory on a square lattice with **crystallographic symmetry (p4m plane group)**. The logical operators are **non-contractible loops** on the torus (genus-1 surface), whose weight scales as

d

— directly tied to the **topological winding number** and the **fundamental group

\pi_1(T^2) = \mathbb{Z} \times \mathbb{Z}

**. The threshold ~1% is not a golden ratio, but the **error suppression per distance**

\Lambda

often approaches values Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

FINDING: Surface code logical error rate scales as

p_L \propto (p/p_{th})^{\lfloor (d+1)/2 \rfloor}

for distance-

d

codes, with threshold

p_{th} \approx 0.01

(circuit-level) and rotated code halving qubit overhead at equal distance. | MATH: Logical error rate

p_L = A (p/p_{th})^{\lfloor (d+1)/2 \rfloor}

; for odd

d

, exponent

= (d+1)/2

; for even

d

, exponent

= d/2

. Distance

d

= minimum weight of logical operator (e.g.,

d=5

for 49-qubit rotated code). Qubit count: rotated

= d^2

, unrotated

= 2d^2 - 2d + 1

. Threshold

p_{th} \approx 0.01

(circuit-level noise),

\approx 0.11

(code capacity). | CONNECTION: The exponent

\lfloor (d+1)/2 \rfloor

is the **minimum weight of a logical

Z

X

operator** — this is the **Manhattan distance** on the square lattice. The rotated surface code is a **

d \times d

square patch** of the square lattice — a **

D_4

root system** projection (checkerboard lattice). The ratio of qubit counts (rot Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com

FINDING: Surface code error correction uses stabilizer formalism with parity check matrices derived from lattice geometry, enabling fault-tolerant quantum computation. MATH: - Stabilizer group

S = \langle g_1, g_2, \dots, g_m \rangle

where each

g_i

is a Pauli operator (tensor product of

X, Y, Z, I

) on

n

qubits. - Parity check matrix

H

over

\mathbb{F}_2

(for

X

and

Z

errors separately) has size

(n-k) \times n

, with rows corresponding to stabilizer generators. - Surface code: qubits on edges of a square lattice, stabilizers are plaquette (Z-type) and vertex (X-type) operators. Code distance

d

scales with lattice size

L

d = L

for

L \times L

lattice. - Logical operators are non-trivial cycles on the dual lattice, with commutation relations given by intersection number mod 2. - Error correction threshold:

p_{\text{th}} \approx 0.103

(for standard depolarizing noise) — no simple rational ratio, but Author: Andrew Stewart Caldin, Independent Researcher, UK. Part of the E8 Intelligence Research series. Platform: e8intelligence.com