Twin Branch Evaluation Protocol

• Twin Branch Evaluation Protocol is a methodological framework that pairs baseline and alternative branches to enable controlled counterfactual evaluations across diverse domains.
• It supports rigorous testing in cyber-physical systems, compact-star physics, agentic LLM routing, and DeFi by mirroring live states and replaying alternative scenarios under predefined conditions.
• The protocol integrates explicit metrics, decision criteria, and fidelity analyses to compare performance, stability, and favoredness, ensuring actionable insights and robust anomaly detection.

“Twin Branch Evaluation Protocol” denotes a family of paired-branch or two-track evaluation schemes rather than a single canonical standard. In recent arXiv usage, the term is applied to at least four technically distinct settings: cyber-physical Byzantine-fault experimentation in ByzTwin-Range, compact-star branch identification and favoredness analysis, agentic LLM routing in TwinRouterBench, and off-chain DeFi state-twin evaluation. Across these usages, the common structure is a bifurcated workflow in which one branch represents an operational, hadronic, live, or on-chain baseline, while a second branch supports mirrored, alternative, downgraded, hybrid, or counterfactual evaluation under controlled conditions (Freitas et al., 20 Apr 2026, Montana et al., 2018, Haque et al., 2 Feb 2026, Yang et al., 14 May 2026, Moore, 12 May 2026).

1. Terminological scope and recurring structure

The expression is used in multiple domains with different referents. In ByzTwin-Range, the twin-branch approach instantiates two coupled branches: an “Operational branch” comprising a production-grade BFT deployment in the OT plane, and a “Digital Twin (DT) branch” comprising an Operational Twin that continuously mirrors the live operational state and protocol execution into a high-fidelity cyber range (Freitas et al., 20 Apr 2026). In compact-star studies, “twin branches” refer to two distinct, stable equilibrium branches in the mass–radius relation generated by a strong first-order hadron–quark phase transition, namely a normal hadronic branch and a more compact twin branch (Montana et al., 2018, Haque et al., 2 Feb 2026). In TwinRouterBench, the protocol is explicitly a “fast, deterministic static branch for offline development” paired with a “live, end-to-end dynamic branch for realistic validation” (Yang et al., 14 May 2026). In State Twins for DeFi, TBEP is a deterministic, multi-scenario evaluation workflow in which a single snapshot is forked into multiple scenario branches and rolled forward off-chain (Moore, 12 May 2026).

This suggests that “twin branch” functions as a methodological motif centered on controlled comparison between coupled but non-identical execution paths. A plausible implication is that the term is best understood by its shared evaluation logic—mirroring, branching, controlled perturbation, and differential decision-making—rather than by a single domain-independent formalism.

Domain	Branch pair or branch set	Representative paper
CPS/BFT	Operational branch and DT branch	(Freitas et al., 20 Apr 2026)
Compact stars	Hadronic branch and twin branch	(Montana et al., 2018, Haque et al., 2 Feb 2026)
Agentic LLM routing	Static branch and dynamic branch	(Yang et al., 14 May 2026)
DeFi state twins	Forked scenario branches from one snapshot	(Moore, 12 May 2026)

2. Shared methodological pattern

Despite disciplinary differences, the protocols share a small set of structural elements. First, each begins from a reference state or baseline execution: live OT state in ByzTwin-Range, an EOS-derived equilibrium sequence in compact-star work, router-visible prefixes and successful strong trajectories in TwinRouterBench, or a pinned on-chain pool snapshot in State Twins (Freitas et al., 20 Apr 2026, Montana et al., 2018, Yang et al., 14 May 2026, Moore, 12 May 2026). Second, each constructs an alternative branch that preserves enough causal or mathematical structure to support meaningful counterfactuals: exact replay and co-simulation in the DT branch, a disconnected but stable hybrid-star branch in twin-star EOSs, step-level target tiers under causal prefixes in static routing, or forked deterministic AMM transitions in off-chain twins (Freitas et al., 20 Apr 2026, Montana et al., 2018, Yang et al., 14 May 2026, Moore, 12 May 2026).

Third, each protocol defines explicit observables or decision criteria on the paired branches. ByzTwin-Range uses latency distributions, commit throughput, view-change rate, false suspicion rate, and recovery time. Compact-star protocols use stability conditions such as $dM/d\varepsilon_c > 0$ or $dM_g/d\rho_c > 0$, fixed-$M_b$ pairing, binding energy, radii, and tidal deformabilities. TwinRouterBench uses deterministic metrics—RowPass, RowExact, TrajPass, CostSave, and Combined in the static branch, and resolution and realized spend in the dynamic branch. State Twins uses slippage, fee accrual, impermanent loss, PnL, invariant residuals, and fidelity bounds relative to chain execution (Freitas et al., 20 Apr 2026, Montana et al., 2018, Haque et al., 2 Feb 2026, Yang et al., 14 May 2026, Moore, 12 May 2026).

Fourth, all variants include an explicit decision loop. In ByzTwin-Range, advisories are sent over a secure, read-only channel to the BFT Manager. In compact stars, favoredness is decided by comparing critical perturbation strengths or binding energies at fixed $M_b$. In TwinRouterBench, offline routing policies are validated by end-to-end live execution. In TBEP for DeFi, branches are ranked, an action is optionally executed on-chain, and the system is re-synchronized by taking a fresh snapshot (Freitas et al., 20 Apr 2026, Haque et al., 2 Feb 2026, Yang et al., 14 May 2026, Moore, 12 May 2026).

3. Cyber-physical systems and Byzantine fault evaluation

In ByzTwin-Range, the Twin Branch Evaluation Protocol is a dual-layer architecture for evaluating Byzantine Fault Tolerant deployments under realistic cyber-physical conditions (Freitas et al., 20 Apr 2026). The operational branch consists of PLCs with local fail-safe watchdogs and BFT replicas interconnected over VLAN/TSN, with OPC UA PubSub over UDP for telemetry. The DT branch includes a streaming store, feature store, BFT Lab for FMU/HLA co-simulation and emulation, orchestrator, SIEM/SOC integration, and Historian/CMDB. A Broker and Time Gateway mediate telemetry, enforce mTLS over QUIC, assign canonical timestamps, align OT time with simulated or logical time, and support reproducible replay (Freitas et al., 20 Apr 2026).

The rationale is that traditional cyber ranges typically run open-loop synthetic workloads and lack timing fidelity, particularly the strict cycle times, bounded jitter, and deterministic scheduling of CPS OT networks. Testing in production is unsafe because adversarial timing perturbations, equivocation, or injected fault states can drive controllers or BFT layers into view-change storms or deadline violations. The DT branch therefore acts as a safety boundary where the same live state and timing traces can be replayed and stressed without impacting the plant (Freitas et al., 20 Apr 2026).

The formal BFT model uses the standard bounds $n \ge 3f + 1$ and quorum size $q = 2f + 1$. Timing is modeled under partial synchrony using message-delay upper bound $\Delta$, clock-drift bound $\epsilon$, and timeout selection criteria such as $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$. False suspicion is defined probabilistically by

$$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$

with adversarial jitter modeled by $dM_g/d\rho_c > 0$0. View-change frequency is approximated as $dM_g/d\rho_c > 0$1, and adversarial delays increase both $dM_g/d\rho_c > 0$2 and $dM_g/d\rho_c > 0$3 (Freitas et al., 20 Apr 2026).

The workflow is explicit: state mirroring and synchronization; DT co-simulation/emulation setup; Byzantine fault injection; measurement and metrics collection; analysis for synchrony vulnerabilities; and secure advisory feedback. Reported metrics include phase latencies, overall commit latency, throughput $dM_g/d\rho_c > 0$4, commit rate, view-change count, $dM_g/d\rho_c > 0$5, false suspicion rate $dM_g/d\rho_c > 0$6 estimates, recovery time $dM_g/d\rho_c > 0$7, quorum acquisition time, and CPS co-simulation safety margins (Freitas et al., 20 Apr 2026).

The paper’s example scenarios make the evaluation logic concrete. In Scenario A, with $dM_g/d\rho_c > 0$8 ms, latency distribution $dM_g/d\rho_c > 0$9 ms, and $M_b$0 ms, the DT branch observes $M_b$1, $M_b$2 vc/s, throughput dropping from $M_b$3 tx/s to $M_b$4 tx/s, and $M_b$5 inflating from $M_b$6 ms to $M_b$7 ms. The advisory recommends $M_b$8 ms after incorporating $M_b$9 and $M_b$0, plus TSN schedule padding of $M_b$1 ms; the post-mitigation operational branch shows $M_b$2, $M_b$3 vc/h, $M_b$4 tx/s, and $M_b$5 ms (Freitas et al., 20 Apr 2026).

A recurrent misconception addressed by this framework is that protocol robustness can be validated adequately in static cyber ranges or pure simulation. The comparison section states that static ranges and simulations often miss synchrony edge cases, whereas the twin branch preserves OT timing via TSN, OPC UA PubSub, and the Time Gateway. At the same time, the architecture is not presented as exact duplication: the paper explicitly notes twin fidelity gaps, co-simulation accuracy and scalability limits, and synchronization overhead (Freitas et al., 20 Apr 2026).

4. Compact-star twin branches: identification, constraints, and favoredness

In compact-star physics, “twin branch” refers to a third-family branch produced by a strong first-order hadron–quark phase transition. Two stable configurations can exist at the same gravitational mass $M_b$6 but with different radii $M_b$7 and tidal deformabilities $M_b$8: a normal-neutron-star or hadronic branch and a more compact twin branch (Montana et al., 2018, Haque et al., 2 Feb 2026). The phase transition is modeled either through a Maxwell construction with a discontinuous energy-density jump at $M_b$9, or through a Gibbs construction with a mixed phase represented by a polytrope $n \ge 3f + 1$0 with $n \ge 3f + 1$1, then matched to a CSS quark phase with $n \ge 3f + 1$2 (Montana et al., 2018).

The equilibrium structure is generated by integrating the TOV equations. In the notation used in the 2018 study,

$n \ge 3f + 1$3

Tidal deformability is computed through the Hinderer formalism using compactness $n \ge 3f + 1$4 and

$n \ge 3f + 1$5

The weighted binary tidal deformability is given by the LIGO/Virgo expression for $n \ge 3f + 1$6 in terms of $n \ge 3f + 1$7 and the chirp mass $n \ge 3f + 1$8 (Montana et al., 2018).

The 2018 protocol defines a reproducible workflow: choose the hadronic EOS FSU2H; specify Maxwell or Gibbs HQPT; build the piecewise EOS $n \ge 3f + 1$9; integrate TOV over central densities; solve the tidal-perturbation ODE; identify stable and unstable segments via $q = 2f + 1$0 or $q = 2f + 1$1; find masses with coexistence on both stable branches; and then validate against $q = 2f + 1$2, GW170817 bounds $q = 2f + 1$3, and the relaxed lower bound $q = 2f + 1$4 at $q = 2f + 1$5 when a phase transition is allowed (Montana et al., 2018).

Characteristic results are branch-specific. The largest number of twin-star solutions occurs with normal-neutron-star branch masses in the range $q = 2f + 1$6–$q = 2f + 1$7 and twin-branch masses $q = 2f + 1$8. In Category III twins near $q = 2f + 1$9, the same-mass radius difference $\Delta$0 reaches up to $\Delta$1 km in Model-1 and $\Delta$2 km in Model-2. The purely hadronic normal branch has $\Delta$3–$\Delta$4, while the twin branch yields $\Delta$5 in $\Delta$6–$\Delta$7 for Model-1 and $\Delta$8–$\Delta$9 for Model-2 (Montana et al., 2018).

The later 2026 work shifts from branch existence to branch favoredness under perturbations (Haque et al., 2 Feb 2026). It constructs nonrotating equilibria with

$\epsilon$0

defines baryonic mass

$\epsilon$1

and binding energy

$\epsilon$2

Twins are paired at strictly fixed $\epsilon$3, not merely at fixed $\epsilon$4 (Haque et al., 2 Feb 2026).

The protocol then applies inward radial velocity kicks,

$\epsilon$5

to hadronic-branch and twin-branch models with identical $\epsilon$6. For each branch and mass, there exists a critical threshold $\epsilon$7 such that subcritical kicks lead to damped oscillations on the original branch, while supercritical kicks trigger migration to the neighboring branch at fixed $\epsilon$8 (Haque et al., 2 Feb 2026). At $\epsilon$9, the paper reports $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$0 and $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$1, with both models settling within $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$2 ms to the partner equilibrium after migration (Haque et al., 2 Feb 2026).

The central criterion is that the favored branch at fixed $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$3 is the one with the larger critical perturbation threshold. The paper further shows that this agrees with the branch having the larger binding energy, at $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$4 level, allowing a simulation-free decision rule:

$$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$5

and conversely for HB. A neutral mass $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$6 is defined by equality of thresholds or binding energies; for the representative EOS the paper finds $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$7 (Haque et al., 2 Feb 2026).

A common misconception challenged by this result is that stellar models on the twin branch are generically the favored ones. The 2026 paper explicitly states that its binding-energy and dynamical analysis corrects that “common wisdom”: low-mass twins can favor the hadronic branch, while more massive twins above the neutral mass can favor the twin branch (Haque et al., 2 Feb 2026).

5. Static–dynamic twin-branch evaluation in agentic LLM routing

In TwinRouterBench, the Twin Branch Evaluation Protocol is the paper’s “two-track development and validation loop” for realistic agentic routing (Yang et al., 14 May 2026). The static branch is an offline deterministic track providing execution-verified, step-level target tiers under fixed model tiers and prices. The dynamic branch is a live execution track on SWE-bench Verified in which the router selects a concrete model at each LLM call from a locked pool, and success is measured by official task resolution and realized provider spend (Yang et al., 14 May 2026).

The static branch formalizes step-level routing. At step $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$8, the router sees the full router-visible prefix $$T_{\text{timeout}} \ge k \cdot \Delta \cdot (1+\epsilon)$$9—system messages, user instructions, prior assistant messages, tool outputs, retrieval snippets, logs, and partial code edits—and applies

$$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$0

The ideal per-call target tier is

$$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$1

and the released label $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$2 is an execution-verified estimate of $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$3 under a fixed downgrade-and-cascade protocol (Yang et al., 14 May 2026).

The corpus contains 970 step-level rows from 520 instances across SWE-bench, BFCL, mtRAG, QMSum, and PinchBench. The total tier distribution is low 689, mid 62, mid_high 49, and high 170. Each row contains id, benchmark, instance_id, step_index, total_steps, messages, target_tier, and target_tier_id (Yang et al., 14 May 2026). Label construction begins from successful strong trajectories, then performs sequential-locking downgrade search with causal prefixes, reducing naive $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$4 search to $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$5 trials. For non-low tiers, verification is existential over three-model cascades within the tier. For open-ended tasks, the pass predicate is hardened by first checking whether the turn is resolved and then scoring Faithfulness, Appropriateness, and Completeness, with hard-fail on unsupported claims and evidence conflicts (Yang et al., 14 May 2026).

Static scoring is deterministic and contains no evaluator-side LLM judge. If $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$6 is the router prediction, the metrics are RowPass, RowExact, TrajPass, CostSave, and

$$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$7

Per-row cost uses the four-bucket accounting function

$$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$8

with deterministic modeling of prompt caching, including TTL 5 minutes, cache writes on cold starts, tier switches, TTL expiry, or prefix deltas, and cache reads on valid same-tier hits (Yang et al., 14 May 2026). The failure-aware CostSave formula credits savings only for passing trajectories and subtracts burned spend for failing ones.

The dynamic branch evaluates on a 100-instance held-out SWE-bench Verified split disjoint from the static SWE supervision split. The harness is mini-swe-agent v2.2.8. For instance $$P_{fs} = \Pr[L > T_{\text{timeout}}] = 1 - F_L(T_{\text{timeout}}),$$9, realized API cost is

$dM_g/d\rho_c > 0$00

and leaderboard bill is

$dM_g/d\rho_c > 0$01

with fixed add-on $dM_g/d\rho_c > 0$02 USD per unresolved instance (Yang et al., 14 May 2026). Resolution follows the official SWE-bench Verified rule that the patch must pass FAIL_TO_PASS tests.

The benchmark’s reported alignment between branches is empirical as well as conceptual. On the 100-case dynamic held-out split, a trained UncommonRoute resolves 75/100 cases with average API cost \$dM_g/d\rho_c > 0$0325.66, penalty \$dM_g/d\rho_c > 0$0440.66, versus unrouted <a href="https://www.emergentmind.com/topics/opus-4-6" title="" rel="nofollow" data-turbo="false" class="assistant-link" x-data x-tooltip.raw="">Opus 4.6</a> at 74/100, \$dM_g/d\rho_c > 0$0554.73, \$dM_g/d\rho_c > 0$0670.33. The paper states that the trained router reduces realized API cost by 53.1% relative to unrouted Opus at comparable resolve rate (Yang et al., 14 May 2026).

The paper also addresses a potential misunderstanding that one-shot prompt benchmarks suffice for routing research. Its explicit motivation is that existing router benchmarks evaluate routers only on one-shot prompts, never expose the router-visible prefix at an intermediate agent step, never test whether a cheaper replacement preserves downstream task success, and often rely on online LLM judges at evaluation time. The twin-branch design is introduced precisely to replace that setup with causal-prefix supervision and live end-to-end validation (Yang et al., 14 May 2026).

6. State Twins and multi-scenario branch evaluation in DeFi

In the DeFi setting, TBEP is enabled by the State Twin: a typed, in-memory, replayable replica of an AMM pool’s on-chain state at a pinned block, paired with operations that evaluate the pool’s exact transition and observation maps off-chain (Moore, 12 May 2026). The twin decouples reasoning from chain time and admits operations not supported by on-chain state itself: forking, replay, branching, counterfactual rollout, and safe merging in the sense of “choose and re-sync,” not arithmetic state merging (Moore, 12 May 2026).

The open architecture, implemented in DeFiPy v2, separates Provider and Builder. StateTwinProvider maps a pool identifier to a typed PoolSnapshot, with MockProvider for synthetic recipes and LiveProvider for RPC-backed Uniswap V2/V3 reads. StateTwinBuilder lifts the snapshot into a typed twin or exchange object with exact invariant math and rounding rules. The toolkit also exposes 21 typed analytical primitives, such as SimulatePriceMove and AnalyzePosition, and an MCP server in which the tool path is pool_id → Provider.snapshot → StateTwinBuilder.build → Primitive.apply → typed result (JSON) (Moore, 12 May 2026).

AMMs are modeled as controlled dynamical systems with state $dM_g/d\rho_c > 0$07, control $dM_g/d\rho_c > 0$08, exogenous input $dM_g/d\rho_c > 0$09, transition

$dM_g/d\rho_c > 0$10

and observation

$dM_g/d\rho_c > 0$11

For constant-product AMMs, the invariant is $dM_g/d\rho_c > 0$12, with swap output

$dM_g/d\rho_c > 0$13

where $dM_g/d\rho_c > 0$14. The paper also states the concentrated-liquidity V3 formulas for position amounts, the Balancer weighted-invariant output equation, and the Stableswap Newton iteration for solving $dM_g/d\rho_c > 0$15 and computing get_y (Moore, 12 May 2026).

A central component of TBEP in this setting is the twin–chain fidelity analysis. Under a fixed block snapshot, identical input sequence, and differences arising only from fixed-point rounding, the paper gives a single-step bound for the constant-product invariant and then a multi-step bound

$dM_g/d\rho_c > 0$16

with corresponding twin–chain divergence inequality

$dM_g/d\rho_c > 0$17

It also states a general norm bound

$dM_g/d\rho_c > 0$18

where $dM_g/d\rho_c > 0$19 aggregates per-step rounding slack propagated through $dM_g/d\rho_c > 0$20 (Moore, 12 May 2026).

The step-by-step protocol is explicit. One reads on-chain snapshot $dM_g/d\rho_c > 0$21, instantiates StateTwin $dM_g/d\rho_c > 0$22, defines a scenario set $dM_g/d\rho_c > 0$23 over controls and exogenous inputs, forks and rolls out each branch, collects metrics per branch, applies the fidelity bound, ranks branches by an objective, and optionally executes the chosen action on-chain before re-synchronizing with a fresh snapshot (Moore, 12 May 2026). The pseudocode uses copy.deepcopy for branch creation and records complexity as $dM_g/d\rho_c > 0$24, with fork cost $dM_g/d\rho_c > 0$25.

Reported performance figures are concrete. The paper states that fork cost is small, in practice a few KB so that deepcopy is microseconds; memory per twin is typically tens of kilobytes; and in a mainnet V3 USDC/WETH 5 bps pool, $dM_g/d\rho_c > 0$26 scenarios complete in well under one second after one RPC read, with the single RPC dominating wall-clock (Moore, 12 May 2026). The worked example applies seven price shocks $dM_g/d\rho_c > 0$27 to a Uniswap V3 pool and returns typed outputs such as post_price, fees_accrued, IL%, LP_value, and tick_crossings (Moore, 12 May 2026).

The framework explicitly rejects arithmetic merging of divergent branches. This is an important corrective to a likely misconception: in this TBEP, “merge” means selecting a winning branch’s action, executing it on-chain through an external signing stack, and then re-synchronizing from verified chain state (Moore, 12 May 2026).

7. Comparative interpretation, limits, and epistemic status

Across these literatures, twin-branch evaluation is consistently paired with strong claims about controlled realism, but each paper also defines explicit limits. ByzTwin-Range notes twin fidelity gaps, co-simulation scalability constraints, and synchronization overhead (Freitas et al., 20 Apr 2026). The compact-star protocols emphasize EOS dependence, uncertainty in mixed-phase softening, the phenomenological status of $dM_g/d\rho_c > 0$28, and the fact that some GW analyses were generated without twin-aware templates (Montana et al., 2018). The dynamical favoredness study restricts its claims to nonrotating, unmagnetized stars in spherical symmetry, with adiabatic perturbations and no shocks (Haque et al., 2 Feb 2026). TwinRouterBench states that labels are pool-, harness-, and price-specific, that sequential-locking may miss some cross-step interactions, and that dynamic coverage is currently SWE-bench Verified only (Yang et al., 14 May 2026). State Twins notes edge cases such as extreme price shocks, zero-liquidity ranges, fee-on-transfer tokens, and asynchronous oracle updates (Moore, 12 May 2026).

A broader interpretive point follows from these limits. The term does not identify a universal algorithm; rather, it designates a recurring evaluation strategy in which a baseline branch is paired with a mirrored, alternative, or forked branch so that perturbations, constraints, or routing decisions can be assessed without collapsing the causal structure of the original system. In some fields the branch pair is ontological—hadronic versus hybrid equilibrium solutions. In others it is infrastructural—operational versus digital twin, static versus dynamic routing track, or on-chain snapshot versus off-chain forked twins. This suggests that the phrase functions as a cross-domain label for branch-coupled evaluation under controlled divergence.

The common technical promise is not that the auxiliary branch is identical to reality, but that it is close enough, causally aligned enough, or mathematically faithful enough to support decisive comparisons. In ByzTwin-Range this means exact replay and timing-aware fault injection; in twin-star studies it means fixed-$dM_g/d\rho_c > 0$29 or fixed-$dM_g/d\rho_c > 0$30 pairing plus stability analysis; in TwinRouterBench it means execution-verified labels and failure-aware cost accounting; in State Twins it means deterministic transitions with explicit fidelity bounds (Freitas et al., 20 Apr 2026, Haque et al., 2 Feb 2026, Yang et al., 14 May 2026, Moore, 12 May 2026). Under that interpretation, “Twin Branch Evaluation Protocol” names a methodological family whose defining feature is evaluation by structured branching rather than by isolated single-run measurement.