# OP3-V1 Finite-State Causal-Conditioned Command-Capacity Theorem Target

Status: formal theorem-development target, created 2026-06-11 after Pro review `pro_op3_command_attribution_no_super_observer_review_2026_06_10`.

Route:

```text
op3_v1_postreview_patch_ready_for_confirmation
```

This note defines the next OP3 object:

```text
OP3-V1 finite-state causal-conditioned command-capacity theorem
+ OP3 route-classifier specification
```

It is not accepted OP3 theorem status, accepted `Prog_T` theorem status, OP2 command-effect acceptance, hardware evidence, Layer-3 support, Tau-X capability, or public claim clearance.

## Purpose

OP3-V1 states when plant change can be attributed to a declared command interface rather than to actuator randomness, hidden predictors, common causes, environment, clocks, calibration tables, passive dynamics, or denominator omissions.

The current BT3/BT5 verifier remains the memoryless finite-state regression artifact. OP3-V1 uses it as the base lemma case and adds a history-conditioned root theorem target.

## Objects

Finite horizon:

```text
t = 0, ..., T-1
```

Declared variables:

```text
X_t       plant state or declared Markov-sufficient state
M_t       controller command
U_tilde_t full declared joint command-interface output
H_t       declared causal conditioning history/state
C_joint,t actual declared joint command-interface capacity envelope
E_total   denominator ledger, only for normalized corollaries
F_task    task functional, only for task-score corollaries
```

The conditioning object `H_t` may include:

```text
X_t
past commands
past actuator outputs
declared channel state
clock/synchronization state
calibration state
environment state
observation history
variables allowed to explain prediction but not credited as current command influence
```

Freeze a declared pre-command record `R_t^-` and deterministic map

```text
H_t = f_t(R_t^-)
```

before scoring. `H_t` cannot contain future outcomes, descendants of
`X_{t+1}`, or post-command descendants of `M_t` outside the declared
interface. This excludes collider conditioning that could manufacture an
apparent command association.

## Layer A: Memoryless Base Lemma

Assumptions:

```text
X_t is Markov-sufficient for the OP3 claim.
M_t -> U_tilde_t -> X_{t+1} conditional on X_t.
The declared command interface has actual joint capacity C_joint,t.
No hidden path from M_t to X_{t+1} bypasses U_tilde_t. Command-bearing side channels are folded into U_tilde_t and C_joint,t; non-command common causes are conditioned in H_t or routed away.
```

Then:

```text
I(M_t; X_{t+1} | X_t)
  <= I(M_t; U_tilde_t | X_t)
  <= C_joint,t
```

This is the BT3/BT5 verifier's current finite-state route surface.

## Layer B: History-Conditioned Root Theorem

Assumptions:

```text
H_t is the declared sufficient causal conditioning state/history.
M_t -> U_tilde_t -> X_{t+1} conditional on H_t.
The actual joint command-interface capacity envelope is C_joint,t.
Command-bearing side channels are included in U_tilde_t and C_joint,t. Non-command hidden channels, clocks, calibration state, memory, environment state, and actuator noise are included in H_t or routed away.
The certified interface channel is the same frozen conditional law that generates the scored record; a re-estimated or shifted channel law requires a separate transport certificate.
```

Then:

```text
sum_t I(M_t; X_{t+1} | H_t)
  <= sum_t I(M_t; U_tilde_t | H_t)
  <= sum_t C_joint,t
```

This is a one-step, current-command ledger. It can condition away influence
stored by earlier commands in declared memory, so it is not a lower bound on
cumulative command influence and is not full directed information.

The proof is the finite-state conditional data-processing argument plus the
reviewed capacity-envelope lemma recorded in the proof draft.

## Route Classifier Fields

Machine-readable OP3 route records should include:

```text
claim_scope
causal_graph_status
conditioning_time_status
state_sufficiency_status
history_conditioning_status
hidden_channel_status
joint_capacity_status
actuator_noise_status
clock_sync_status
calibration_memory_status
denominator_status
task_functional_status
policy_variation_status
capacity_model_status
```

`claim_scope` separates the unnormalized information-attribution theorem from normalized `Prog_T` / resource-ratio corollaries, task-functional promotion, and empirical command-effect estimation. Denominator, task-functional, and deterministic-policy gates apply to the relevant scope rather than to every OP3 route record.

The `hidden_channel_status` vocabulary separates paths conditioned in `H_t`, command-bearing side channels folded into `U_tilde_t` and `C_joint,t`, and non-command common causes that route away when merely charged to capacity.

## Route Labels

Positive / development routes:

```text
op3_memoryless_base_lemma_applies
op3_history_conditioned_theorem_target_applies
op3_ready_for_formal_command_attribution_theorem_development
```

Audit routes:

```text
hidden_channel
memoryful_capacity_ledger_required
wrong_capacity_model
non_attributable_stochastic_actuator_influence
invalid_causal_graph
state_sufficiency_defer
history_conditioning_defer
open_loop_or_schedule_baseline
interface_out_of_scope
denominator_incomplete
task_functional_defer
defer_for_capacity_model_review
deterministic_policy_variation_defer
joint_capacity_required
claim_scope_promotion_review_required
```

## Expected Counterexample Fixtures

| Fixture | Expected route |
|---|---|
| Hidden predictor / common-cause variable | `hidden_channel` or `invalid_causal_graph` |
| Shared clock | `hidden_channel` or `wrong_capacity_model` |
| Non-Markov logged state | `state_sufficiency_defer` |
| Open-loop time schedule | `history_conditioning_defer` or `open_loop_or_schedule_baseline` |
| Deterministic state-feedback policy | `deterministic_policy_variation_defer` |
| Correlated two-controller channels | `wrong_capacity_model` |
| XOR/synergy joint command | `joint_capacity_required` |
| Calibration-table lookup | `memoryful_capacity_ledger_required` |
| Non-command common cause charged only to capacity | `hidden_channel` |
| Delayed actuation without augmented state/history | `state_sufficiency_defer` |
| Complete broader claim scope | `claim_scope_promotion_review_required` |
| Actuator-only stochastic influence | `non_attributable_stochastic_actuator_influence` |
| Continuous/high-precision analog channel | `defer_for_capacity_model_review` |
| Missing declared causal history | `history_conditioning_defer` |
| Future-leaking or post-treatment conditioning | `invalid_causal_graph` |
| Denominator incomplete under normalized claim scope | `denominator_incomplete` |
| Denominator incomplete under numerator-only claim scope | positive numerator-only theorem route |
| Deterministic state feedback under empirical-estimation claim scope | `deterministic_policy_variation_defer` |
| Deterministic state feedback under numerator-only claim scope | positive numerator-only theorem route |
| Multi-failure rows | documented priority route |

## OP2 / OP4 Boundaries

OP2 owns:

```text
policy-level live-vs-holdout effect
randomization / assignment validity
observation-quality and holdout-integrity routes
```

OP3 owns:

```text
command attribution
causal interface capacity
hidden-channel and joint-capacity audit
```

OP4 owns:

```text
denominator completeness
multi-resource accounting
amortization / pretraining / calibration support costs
```

An OP2 command-effect request should route into OP3 only after OP2 supplies the assignment, exposure, and observation-validity surface. A normalized `Prog_T` claim should route through OP4 before positive normalized language is used.

## Proof Obligations

1. Conditional data-processing lemma.
2. Capacity-to-command-channel lemma.
3. Hidden-channel exclusion / ledger lemma.
4. State/history sufficiency lemma.
5. Joint-capacity lemma.
6. Denominator separation lemma.
7. Task-functional gate.

## Current Implementation Link

Current verifier:

```text
cct-public-replication/theorem_verifiers/verify_baby_theorems.py --suite batch1a
```

The verifier checks the memoryless finite-state route surface. It is not yet the full history-conditioned theorem checker.

Route-classifier companion:

```text
cct-public-replication/estimators/op3_route_classifier.py
cct-public-replication/examples/op3_route_classifier_cases.csv
```

The companion exercises the OP3-V1.2 route grammar after Pro theorem-draft review route `op3_theorem_draft_clear_for_formal_review_after_minor_statement_patches`: memoryless base lemma, history-conditioned theorem target, hidden predictor/common cause, command-bearing side-channel-in-interface positives, non-command capacity-only common-cause closure, shared clock, non-Markov logged state, delayed-actuation state augmentation defer, missing declared history, future-leaking conditioning, open-loop schedule, deterministic state-feedback by claim scope, correlated joint channels, XOR/synergy joint capacity, memoryful calibration-table ledger requirement, actuator-only stochastic influence, continuous/high-precision channel, denominator incompleteness by claim scope, complete broader-scope promotion-review routes, post-hoc task functional, invalid direct graph, out-of-scope interface, and multi-failure route-priority cases.

Formal theorem-assumption certificate:

```text
cct-public-replication/theorem_verifiers/verify_op3_theorem_assumptions.py
cct-public-replication/schemas/op3_theorem_assumption_manifest_v1.schema.json
cct-public-replication/examples/op3_theorem_assumption_manifest_cases.json
open-theorem-working-notes/op3-v1-formal-handoff-2026-07-11.md
```

This narrower certificate freezes the finite kernel factorization, full joint
interface, independent capacity definition, input-policy class, and scored
support required by the proof. After external-model formal triage it also
freezes scored-channel-law alignment and collider-conditioning rejection. It
passes 28 route fixtures and five structural mutation checks locally.
