# Formal Verify

> Run formal property verification (FPV) on RTL by driving model-checkers such as SymbiYosys, Jasper, or VC Formal. Use when the user says "prove this", "formal verify", "model check", "run sby", or has SVA properties from assertion-gen that need to be proven or bounded.

- Skill: `vibeic/formal-verify` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx get-skill add vibeic/formal-verify`
- Raw SKILL.md: https://api.skillmd.com/api/skills/vibeic/formal-verify/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: vibeic (https://skillmd.com/u/vibeic)
- Updated: 2026-11-15
- Page: https://skillmd.com/skills/vibeic/formal-verify

---


# Formal Verify

> **Doctrine (v0.1.50):** 把修法寫進工具，而非寫進 prompt.
> Programs first; AI is the backstop on cex narrative.

`formal_harness_gen.py` authors the construction-safe floor and writes
`property_contract.json`. This skill owns BOTH the expert property-authoring
fallback for unresolved L3/L6/L8 obligation IDs and the independent review of
model-checker evidence. Without a runner, SVA files are documentation; without
denominator closure, a passing subset is INCOMPLETE rather than Step 5.

## Mandatory Deterministic Preflight

```bash
# MCP tool call — drives SymbiYosys / Jasper / VC Formal:
eda_formal({
  rtl_files: ["<dut>.v"],
  sva_files: ["<assertions>.sva"],
  top_module: "<top>",
  mode: "prove",       // or "bmc" with --bmc-depth N
})
```

The tool returns `property_count`, `proven`, `failed`, plus
`counterexample_paths[]` when failures appear. **Treat the JSON output
as ground truth.** When a property is FAILED, narrate the CEX trace;
when UNDETERMINED at the bound, recommend deeper BMC. Never claim a
property "obviously holds" without the tool's PROVEN verdict.

## The Step-5 in-flow path (`formal_property_run`) — author the harness, the program proves

The canonical flow Step 5 starts with PROGRAM `formal_harness_gen.py`. When it
writes `formal_authoring_request.json`, invocation of this skill is mandatory:

1. Read `property_contract.json` and the request. Preserve every obligation ID.
2. Bind each unresolved L3/L6/L8 declaration to visible RTL signals. Never guess
   a signal mapping or transcribe an uncheckable prose promise into an assertion.
3. Author properties in `phase2/stage1/formal/formal_expert_properties.svh`,
   the fragment the generated harness `formal_<top>.sv` includes — the harness
   is rewritten by every `formal_harness_gen` run, the fragment never is. Only
   when no harness could be generated, author `formal_<top>.sv` itself. Each
   obligation is closed by the program's read-back only when its named
   assertion exists. The Step-5 signed judgement
   (`reports/audit/ai_judgements/5.json`) binds the fragment AND the harness,
   so rerun the producers before signing, and re-sign after any change.
4. Write `formal_expert_review.json` with `invocation_status: INVOKED`,
   `fallback_skill: formal-verify`, and a `dispositions` list with one
   `AUTHORED`, `DECLARATION_MISSING`, or `UNANSWERABLE` row for every request
   ID. Every `AUTHORED` row names the exact `property`; `UNANSWERABLE` keeps
   the row INCOMPLETE and names what declaration/property is missing.
5. Run `formal_property_run.py`, then `formal_proof_evidence_check.py`.

The PROGRAM `formal_property_run.py` emits the `.sby`, runs `sby` in the
container, parses the transcript, and writes `formal/results.json` plus the
report that `formal_proof_evidence_check` verifies (`all_proved:true` ONLY when
every task shows `DONE (PASS)`). A completed result must cite the elaborated
`.sby`, proof transcript, positive property denominator, and bounded/unbounded
scope. Without a sound harness the request remains INCOMPLETE; it is never a
skip.

**When the engine cannot be REACHED (#216).** "The proof engine was never
reached" and "the proof ran and was inconclusive" are different facts and are
reported differently. If `sby` is unreachable (container not running, Docker
down, `sby` not on PATH) the program writes
`phase2/stage1/formal/formal_env_unavailable.json` + `.md` with
`verdict: ENV_UNAVAILABLE` and an `env_gap` block naming **what** capability is
missing, **where** the flow looked for it, and **what to install or stage** —
and it writes NO `results.json`, so nothing that looks like a proof enters the
record. It never reports `INCONCLUSIVE`, which is a claim about solver
convergence that a run with no transcript cannot support.

Before waiving Step 5, CHECK THE CLAIM: our SymbiYosys fork ships inside the
`vibeic-eda` image at `/usr/local/bin/sby`, so on a provisioned host there is
usually nothing to waive — verify with
`docker exec <container> command -v sby`. Passing the wrong `--container` name
is a DISCOVERY bug, not an environment gap, and the fix is to point at a
running container (`docker ps`), not to file a waiver.

A genuine gap is waived through `waivers.json` with
`step: "formal"`, `verdict_tier: "ENV_UNAVAILABLE"`, a `ticket`,
`review_required: true`, non-empty `evidence`, and a `rationale` that names the
capability, the search location and the remedy. An entry missing any of those,
or naming an unknown step role, is REJECTED and reported as an advisory in the
compliance output — it is never silently dropped, and the step stays unwaived.
A waiver is open work: it never counts as a pass, and it defers only the steps
that genuinely declare a `blocks_on` dependency on formal results.

**Engine recipe (no external SMT solver needed).** The container ships NO
z3/yices/boolector — do NOT dead-end on that: SBY's built-in **ABC engines**
need none (`aigsmt none`): `abc pdr` proves safety properties UNBOUNDED;
`abc bmc3` runs functional BMC to a DISCLOSED depth. Split the harness into a
`[safety]` prove task and a `[bmc]` task so each engine does what it is good at.

**Harness-authoring craft (blind, §4.05-clean) — distilled from the spm proof:**
- Golden reference = the OPERATOR SEMANTICS (`assert (p_acc == x * y_low)`),
  never a TB/oracle/harness read. Universally quantify inputs with
  `(* anyseq *)` wires; pin the contract's stability assumptions explicitly
  (e.g. `assume (x == $past(x))` when the datasheet says x is held).
- Model reset honestly: a one-shot init assumption (`assume (rst)` at t0,
  `assume (!rst)` after) beats leaving reset free — a free-running reset makes
  every property vacuously provable or spuriously refutable.
- Disclose bounded-vs-unbounded in the result: a wide datapath's full-latency
  functional proof may be solver-hard (SAT size grows exponentially with
  frame count); the achievable HONEST tier is safety-UNBOUNDED +
  functional-BMC-to-depth-k with k stated. Corroborate the miter at reduced
  widths (e.g. full-latency proof at size=8/16) — same properties, full
  coverage where the solver can reach.

## When to use

- Control-dominated logic (arbiters, FIFOs, protocol adapters, CDC samplers)
- When the program-first request names unresolved L3/L6/L8 obligations
- Regression: re-prove after any RTL change to a formally-verified block
- Safety-critical paths where simulation coverage is insufficient

## Verification Modes

| Mode | What it proves | When to use | Limitation |
|------|---------------|-------------|-----------|
| **k-induction** (`mode prove`) | Property holds for ALL reachable states | Small modules (<100 FFs, no deep counters) | Fails on large state spaces |
| **BMC** (`mode bmc`) | No bug exists within N cycles | Large/complex modules | Not a complete proof |
| **cover** (`mode cover`) | A given state IS reachable | Checking liveness, debug | — |

## Why Large Modules Fail k-induction

k-induction requires depth ≥ longest counter/timer path; deep counters, large
memory arrays, and many-FF state spaces all defeat unbounded proof — the
**state explosion problem**, fundamental to model checking.

Use the native elaborated design and solver behavior to choose prove or
bounded model checking. Deep counters, memories and long traces affect proof
cost. Report the actual engine, bound, assumptions and timeout. A bounded
result is not an unbounded proof.

## Solutions for Complex Modules

### Solution A: BMC-Only (Immediate)

Don't pursue complete proof. BMC to depth 50-200 catches most bugs:

```
[options]
mode bmc
depth 50
```

**<benchmark> result**: All 4 complex modules pass BMC at depth 50.

### Solution B: Abstract Timers (`ifdef FORMAL`)

Replace long counters with short ones for formal:

```systemverilog
`ifdef FORMAL
  localparam logic [11:0] EPROG_CYCLES = 4;  // formal: 4 cycles
`else
  localparam logic [11:0] EPROG_CYCLES = 1650;  // real: 1650 cycles
`endif
```

Logic structure unchanged, but solver finishes in seconds.

Reference: [Tom Verbeure — Under the Hood of Formal Verification](https://tomverbeure.github.io/rtl/2019/01/04/Under-the-Hood-of-Formal-Verification.html)

### Solution C: Assume-Constrain Decomposition

Use `assume()` to restrict inputs to legal behavior:

```systemverilog
// cmd_processor: break only in valid states
always @(posedge clk)
  assume (!break_detected || state_r == IDLE || state_r == COMM_ERROR);

// byte_rx_valid never two consecutive cycles
always @(posedge clk)
  if (!init) assume (!byte_rx_valid || !$past(byte_rx_valid));
```

Massively reduces state space — solver ignores unreachable scenarios.

Reference: [ZipCPU — Swapping Assumptions and Assertions](https://zipcpu.com/formal/2018/12/18/skynet.html)

### Solution D: Helper Invariants

Help solver know which state combinations are impossible:

```systemverilog
// otp_controller: prog_timer nonzero only in PROG states
always @(posedge clk)
  if (!init && rst_n)
    assert (prog_timer_r != 0 |-> 
      (prog_state_r == PROG_ACTIVE || prog_state_r == PROG_WAIT));
```

Reference: [ZipCPU — An Exercise in Formal Induction](https://zipcpu.com/blog/2018/03/10/induction-exercise.html)

### Solution E: Per-Command Task Splitting

For `cmd_processor` with 8 commands — split into 8 formal tasks:

```
[tasks]
verify_cmd_id
verify_cmd_set_state
verify_cmd_get_state
...

[options]
verify_cmd_id: mode bmc
verify_cmd_id: depth 30
```

Each task assumes `cmd_byte_r` is one specific value. 8 small problems >> 1 huge problem.

Reference: [SymbiYosys Tasks](https://symbiyosys.readthedocs.io/en/latest/reference.html)

### Solution F: Memory Abstraction

For `otp_controller`'s 47-byte array:
- **Memory slicing**: only verify 3-4 representative bytes
- **Array theory**: SMT solver uses `(Array (_ BitVec 6) (_ BitVec 8))` — more efficient than 47×8 bits

## Inputs to gather

1. RTL module under verification
2. SVA properties (from the deterministic floor or expert-authored here)
3. Target engine: SymbiYosys (open), Jasper (Cadence), VC Formal (Synopsys)
4. Bound (for BMC) or depth (for k-induction)
5. Constraints / assumptions (`assume` properties)

## Workflow

1. **Choose the proof scope.** Read the elaborated state, required property and native solver results to choose unbounded proof or a disclosed BMC bound.
2. **Generate assertions** — deterministic floor first, then this skill for the
   exact unresolved obligation IDs
3. **Write `.sby` config** with appropriate mode and depth
4. **Run engine** — `sby -f module.sby`
5. **Triage results**:
   - PASS: record bound/depth
   - FAIL: capture CEX trace, map to RTL line, propose fix → `/rtl-repair`
   - TIMEOUT: apply solutions B-F above
6. **Regression harness**: re-run after any RTL change

## Output format

- `formal/<module>.sby`
- `formal/<module>_formal.sv` — assertions
- `formal/<module>_report.md` with per-property status table
- Counterexample VCDs (if FAIL)

## Technical basis

SymbiYosys is the canonical open-source FPV driver on top of Yosys. K-induction and IC3/PDR are the dominant engines. SMT solvers (Yices, Z3) handle the underlying satisfiability.

References:
- [SymbiYosys Documentation](https://symbiyosys.readthedocs.io/)
- [ZipCPU Formal Verification Blog Series](https://zipcpu.com/formal/formal.html)
- [Model Checking and State Explosion (Clarke et al.)](https://link.springer.com/chapter/10.1007/978-3-642-35746-6_1)
- [Formal Verification with SymbiYosys (Clifford Wolf)](https://slideplayer.com/slide/11950984/)
- [HIVE: Scalable HW-FW Co-Verification via Decomposition](https://arxiv.org/html/2309.08002v2)

## Handoff

- CEX → `/rtl-repair`
- Uncovered states → `/coverage-closure`
- New SVA needed → `/assertion-gen`

## Captured rule — a SymbiYosys deck must be relocatable

List `[files]` relative to the `.sby` and read the basenames that SymbiYosys
copies into its `src/` directory. An absolute container path such as
`/work/ip/phase2/stage1/rtl/spm.v` breaks every copy of the project that is
mounted elsewhere. Measured 2026-11-08: the PPA spool mounted the SPM project at
`/work/project`, and all 48 SPM Level 2 trials (IC and IP) ended
`formal_verification` NOT_MEASURED ("native formal model is absent") and failed
signoff. After the fix the IP trials returned 44/44 PASS.
`formal_property_run.emit_sby` and `emit_invariant_sby` write relocatable decks
from v1.40.51. An existing `.sby` is used as is, so regenerate a deck written by
an older version or by hand before reusing the project.

### Retained SBY decks must bind the active project's sources

A copied project's authored `.sby` can still name its creator's absolute
`phase2/`, `phase3/` or `input/` paths. `sby --dumptasks` can succeed even when
all proof tasks then fail while copying those files. Read the native traceback;
that is an input-binding failure, not a proof or a counterexample.

Rebind only a creator root established by a `[files]` entry whose complete
project-relative suffix exists inside the active project. Use the same root
mapping for frontend/include references. Never choose a file by basename,
substitute an unrelated same-named module, or rewrite properties, assumptions,
engines, depth or timeouts to make relocation pass. Keep the original deck and
the actual rebound native input in the ordinary reports.

On AES/image 0.4.76 this restored the supplied `security_shadow` prove/BMC and
both native reachability covers from missing-file errors to PASS at depth 40
and the original 300-second task limits. Other supplied AES decks still hit
unsupported temporal-SVA frontend constructs. Keep those tasks unmeasured;
never disable assertions or claim whole-AES/security closure from a successful
shadow-register proof.

## Captured rule — native formal frontend selection

When `read_verilog` and sv2v cannot read a deck, the native runner retries with
`read_slang --single-unit --no-synthesis-define --ignore-timing -DFORMAL`.
`--ignore-timing` matches `read_verilog`, which also ignores delays (OpenTitan's
`ASSERT_INIT_NET` waits `#1ps` in an `initial` block). A deck that passes
`-DYOSYS` makes vendor headers pick the bodies written for `read_verilog`:
OpenTitan's `prim_assert` then turns every concurrent property into an
immediate assert, and slang rejects it as soon as the property is temporal.
The runner first retries with the deck's own defines
(`slang_frontend.sby`). If that gives no model and the deck defined YOSYS, it
retries once more without only that define (`slang_frontend_standard.sby`) so
the standard concurrent bodies are read. Both decks stay in the reports.
Never remove assertions, rewrite properties or change engines, depth or
timeouts to get a model.

Standard bodies only help if the frontend can lower temporal properties. On
AES/image 0.4.76 the shipped sv-elab rejects them (`encountered unsupported SVA
feature`: 4 on the selector deck, 6 on the register deck). With the fork's
temporal lowering (vibeic/sv-elab PR #5, not yet in the image), measured
2026-11-10 at the deck engines, depth 40 and 300-second limits:
- shadow: 56 assert/8 assume/24 cover, prove and BMC PASS (as before);
- selectors: 13/0/2, prove and BMC PASS;
- registers: 65/1/6, prove and BMC FAIL. 63 of 65 asserts proved; the two
  failures are `u_prim_reg_we_check.u_prim_onehot_check.AssertConnected_A`,
  whose trigger is only driven by an alert check that this register harness
  does not instantiate. That is a genuine verdict of the supplied harness,
  not a lowering error. Report it; do not waive or remove it;
- core: still NOT_MEASURED (`$isunknown` in `ASSERT_KNOWN`, and enum
  `.next()` in `prim_sparse_fsm_flop`).
A false temporal control property is refuted by both prove and BMC. Keep
FAIL and NOT_MEASURED verdicts as they are; never claim whole-AES closure
from the selector or shadow proofs.

SymbiYosys must use the same Yosys executable that the native adapter resolves
from PATH. Pass its native `--yosys` option; an SBY executable packaged in a
fixed tool environment can otherwise invoke its packaged Yosys while the
adapter's model and cover readers use a different build. Preserve an explicit
`--yosys` selection. Do not put a shell wrapper in front of SBY to select a
frontend. The command record must show the executable actually selected.

Frontend regression controls state the property's expected truth: a supported
model must prove the true property and refute the false one. If the frontend
explicitly refuses a construct before producing a model, preserve
NOT_MEASURED and the named native diagnostic, with no proof metric. Do not
make an expected "unsupported SVA" error the success condition of a test;
adding native support must exercise the proof instead. Bind the staged source
bytes rather than assuming the deck still contains an absolute creator path.

## Captured rule — preserve a vendor primitive's required error-check binding

A primitive's `AssertConnected_A` can require the containing harness to install
an error-propagation assertion. Read the vendor contract and the connected RTL
output, then use its assertion macro at the boundary this harness verifies.
Keep the connectivity assertion and add the actual error-to-output assertion;
do not disable its parameter, assume away the error, or set the connectivity
marker by hand. The vendor macro is the executable program; the native
connectivity and propagation assertions are its existing program gate.

For a register-block miter whose `intg_err_o` is connected to `integrity0`, the
RTL assignment `intg_err_o = err_q | intg_err | reg_we_err` establishes the
register-error endpoint. The vendor form is:

```systemverilog
`ASSERT_PRIM_REG_WE_ONEHOT_ERROR_TRIGGER_ERR(RegWeToIntegrity, dut, integrity0)
```

Include the vendor assertion headers. This ERR form adds the propagation
assertion and its required connectivity binding without adding an assumption.
The ALERT form models a different boundary and adds an alert-initialization
assumption; do not use it for a register error bit. Preserve the vendor gate,
clock, reset and latency defaults and the deck's engines, bounds and timeouts.
Prove every original assertion and each new propagation assertion. Disclose
assertions the native optimizer proves constant, and keep register-block scope
separate from end-to-end alert transmission. Native results remain required;
this rule does not turn a supplied harness into a proof of the declared IC.

## Captured rule — distinguish an initial assertion from its lowered input

When a required connectivity assertion fails after installing its real error
check, inspect the native model as well as the RTL. A continuously driven marker
of one paired with a constant-zero assertion input exposes an initial-read
lowering defect. Preserve the assertion and repair the frontend's treatment of
settled continuous drivers under `--ignore-timing`. Keep procedural initial
variable snapshots and initial-only sampling intact. Native controls must prove
valid bindings in either declaration order and refute missing or wrong bindings.

Run the repaired frontend with the image's embedded Python and Tcl capabilities
preserved. The normal public consumer uses Yosys `-y` for LibreLane's JSON-header
step; standalone formal tests do not verify that build profile. Bind native tool
tests, the selected binary and the full public entry to the same source head.

## Captured rule — distinguish unreset power-up from operational behavior

Decode the native counterexample's initial state and input samples before
changing an operational property. A request-to-output-rise assertion can fail
when an unconstrained power-up state starts with an idle FSM and an already
high output. Compare that state with the RTL reset assignments and the design's
documented startup sequence; do not classify it as a tool defect from FAIL alone.

When the declared operational domain starts with reset, author only that startup
condition in `formal_expert_properties.svh`. The existing generator includes and
preserves this fragment. Constrain the first sample using the declared polarity,
then leave reset and traffic free. Keep the generic reset-safety floor free of
automatic assumptions, especially for reset-polarity and synchrony proofs.

Retain every DUT assertion, engine and bound. Cover a request after reset release
followed by the asserted response, and refute a broken post-reset response under
the same startup condition. A source assumption and a passing safety proof alone
do not establish that the operational antecedent is reachable.

## Captured rule — close a timed-out obligation on its native sequential cone

When a multi-output proof times out, retain its original tasks and property IDs.
An additional native SBY task can select one original assertion or an exact small
group, check that the selection contains the requested number of cells, remove
the other assertion/cover sinks and
let the tool prune unused logic. Preserve the selected statement, hardware,
initial state, free inputs, clocks, assumptions, engines, bounds and timeout.
Check the native assertion ID and assumption count after elaboration. A missing
selection is an error, never an empty proof.

Record a scoped PASS for that ID while all other unresolved IDs stay UNKNOWN.
A failed original task must still fail the consumer even when the scoped task
passes. Do not promote the result to the complete core or IC. If helper
invariants are needed, add them as assertions that the same engines prove on
the same model; never convert them into assumptions or use an unproved helper.

For replicated sparse FSMs, a long error-to-alert property may need a state
legality invariant before PDR can finish. Read the vendor enum decoder and each
FSM's next-state/default branches. In the owned harness, assert that each
encoded register remains legal on its existing clock and reset. Keep those
helpers enabled only in the additional scoped tasks. Require the native engines
to prove every helper and every original target; retain all original whole-core
tasks with helpers disabled. Check all native IDs and assumptions after reading
the model. Never turn a proved or unproved helper into an assumption.

This is a proof of the unchanged nominal trace model. If that model has no
injected state faults, state-legality proofs do not establish fault-injection
coverage; conditional-enable covers do not show that an illegal-state trigger
was reached. Report that boundary alongside the original assertion results.

For a cross-clock held-request interface, the source retention register and the
acknowledgement pulse can be separate proof obligations. Derive each helper from
the connected RTL: retain a prior unacknowledged request, and clear acknowledgement
after a source request/acknowledgement handshake. Assert both helpers alongside
the original property and require all three native proofs. Keep both clocks free
and retain the original reset model, engines and bounds. Preserve an explicit
request/acknowledgement completion cover in the scoped model and measure it at
the same bound; conditional-enable covers alone do not establish completion.

## Captured rule — use a known witness step for bounded cover existence

Read the input contract before changing cover search order. If it requires a
witness within the declared bound, an existing native trace can supply a step
for SBY cover's `skip` option. Keep the same prepared model, every cover target,
free inputs, clocks, assumptions, engine, depth, and timeout. Native `skip N`
omits earlier cover queries while retaining initialization and every transition
in the prefix. It does not shorten the trace or start the design in a new state.

Accept only the native PASS that reaches every required cover within the
original limits. Missing earlier queries cannot establish unreachability or the
earliest response time. Keep the original query order when the contract requires
those results. Do not apply this choice to prove or BMC tasks, change a safety
obligation, or promote component cover witnesses to a complete row verdict.

## Captured rule — prove sampling identities as additional assertions

A temporal monitor can store a comparison and its operands in distinct native
registers. Their arbitrary initial values need not agree, even when every later
capture uses the same clock and data. An owned scoped SBY task can request
`# vibeic: assert sampling identities` after its native preparation and any
reviewed conservative data cuts. The program preserves the existing RTLIL and
adds a capture marker plus assertions for identical samples and captured
comparisons. It also offers stronger unclocked monitor assertions. Every added
assertion must prove with the original target; a failed strengthening is not a
refutation of the original clocked statement. Retain the original tasks and
bounds. Do not use these helpers as assumptions.

Treat an exported PDR invariant as untrusted. A multi-output success can include
clauses that are only valid for a finite frame. Preserve every original check
and validate candidate clauses as assertions, including both the bounded basis
and induction, before using their scoped result. A verified control-only joint
miter gives no credit to any excluded data property.

An additional `# vibeic: control invariant <support-name-patterns>` comment
selects the owned control helpers for the auxiliary joint miter. The native
program exports its clauses and appends their conjunction as another assertion
to the full prepared model. The same SBY task must prove that assertion and all
original checks with the original engines and limits. This also validates the
mapping back from physical AIG latches. The initial-state guard applies only to
the candidate conjunction; every original assertion remains active at time zero.

In a multi-task deck, put both markers under the same task prefix. The adapter
preserves that condition on every generated native command. A scoped marked
task must not run its preprocessing in an original whole-design task, nor clear
that task's failure. Verify both native results through the normal consumer.

## Captured rule — a period monitor that is never active

A maximal-length check counts advances from the reset seed and is switched off
by a sticky flag once the register is reseeded or perturbed. Before attempting
any argument about the period, ask whether the register can advance at all
while that flag is clear. In an integration that reseeds the generator before
its first use it cannot, and then the period statements hold for a short
reason: flag clear outside reset implies counter 0 and state equal to the
reset seed.

Add exactly that implication to the owned harness as a combinational
assertion on the real flag, counter and state, next to the unchanged original
statements, and let the task prove all of them together at the original
bounds. It is never an assumption. If the tool refutes it, the register does
advance unperturbed and the full period has to be argued instead. Report the
result as what it is: the statements are proved for this integration because
the monitored sequence never starts, not because 2^n-1 steps were covered.

## Captured rule — a value collision does not identify a write's source

When a property forbids a datapath source, read the native counterexample's
write enable and source selector at the decision edge. An inequality against
an expression's value does not prove that the register was written from that
expression. A different legal source can have the same value, especially under
chosen input. Retain the original refutation and distinguish a circuit defect
from an error in the stated property. A property correction must follow the
accepted requirement meaning, not merely remove its counterexample.

The AES IV clearing statement was refuted 32 core clocks after reset. Its
actual source was the legal counter (`IV_CTR`), while the chosen input made
the excluded saved-input XOR intermediate-state value equal that counter
value. Parenthesizing the XOR did not fix the source/value confusion. The
accepted design erratum instead checks the write decision's source selector
under the actual fatal alert. Its scoped native PDR proof passed in 23 s
with the original depth 40, 300 s run budget and zero added assumptions;
the encoding helpers were proved assertions. This does not authorize changing
another design's requirement or claim whole-core security closure.

## Captured rule — align the fault with the write decision it governs

For an escalation or fault-response property, reconstruct the native trace's
commit edge, alert edge and every sampled history value. A register change
observed after the alert can have been committed before it. Comparing that
value with an older internal state can reject a legitimate pre-fault result.
Express the accepted requirement at the write decision it actually governs;
do not infer that a prior result was written under the fault.

The AES output-data statement was refuted at core clock 40: the normal result
committed at clock 38, and the external integrity fault arrived afterward.
The later changed-value observation compared that valid result with its
clock-38 cipher state. XOR grouping was unrelated to this failure. The
accepted erratum checks that a write decided under the fatal alert is an
acknowledged output clear, with encryption inactive. Scoped native PDR passed
in 17 s. An independent joint Bitwuzla base-case-to-40 and induction proof of
both corrected statements and their asserted helpers passed in 255 s.

Keep proof and reachability separate. The conditional write covers were not
reached within depth 40; no output-data write under the alert was exhibited.
The joint task's separate ABC BMC arm timed out at 300 s, and wrapper cover
results remained NOT_MEASURED. None of those outcomes is a whole-deck PASS,
nor does the safety proof establish that the fault-response write occurs.

## Captured rule — declared security targets and named qualitative checks

Security-target applicability comes from the design's structured declarations,
not from guessing what its prose means. An authored
`input/verification/security_requirements.json` records `documents_reviewed`
with files and sections, `quantitative_targets`, and `qualitative_properties`.
An explicit empty target list, with the reviewed source locations and the
qualitative property list, makes only the quantitative comparison not applicable.
An existing structured target still uses its original bounds.

Keep every qualitative property's ID, claim, source and exact native check
references in the row. Credit an assertion only when its exact native model cell
is present in a passing unbounded prove task. A bounded task is not that proof.
Credit a cover only from its exact native COVER result and reached trace.
Missing checks, partial scope and incomplete native results leave the property
NOT_MEASURED by name. Duplicate IDs cannot overwrite an unchecked claim with a
different passing claim. No numerical target or security result is invented,
and quantitative inapplicability never removes qualitative obligations.


## Captured rule — compose a leaf proof with its actual producer contract

A leaf harness can give an internal input more behavior than its connected
producer permits. Read the counterexample and the real connection before
changing the leaf's properties. Preserve every original obligation, engine
and bound. If the producer guarantees an input domain, prove that guarantee
on the actual producer with free inputs and no assumptions, then use it at
the leaf boundary. Keep the producer proof as a supplied native task that
the ordinary formal consumer re-runs alongside the leaf tasks.

A scoped producer task may select its added guarantee and remove unrelated
assertion sinks. Assert the exact selected native cell count before pruning;
never remove the leaf's original assertions. Keep scope explicit: this proves
the producer guarantee and the leaf obligations under the stated boundary,
not whole-design functionality.

External traffic assumptions must follow the documented interface. Count
accepted requests at the actual external request boundary, including its
upstream qualification, rather than an unqualified leaf signal. Preserve
legal concurrency, values and response delays. Report every assumption and
native free-input count, and reach explicit post-reset request and response
covers. A missing vendor formal header is an input dependency to restore
from the pinned source; a dummy assertion header is not a formal substitute.

## Captured rule — ship the security decks with the documents and partition a large deck

Verification collateral is design input. A design that owns security property decks
ships them under `input/verification/formal/security/` (decks for the implemented
netlist: `implemented_security/`); the security step reads them from there together
with any deck in the project's own formal folder. A shipped deck names its sources
relative to its own folder (SymbiYosys is started there), so it carries no path of
the machine it was written on.

Decks in different input or project folders may share a filename. Run each actual
path through the native adapter and retain its separate task and proof directory.
When basenames collide, use the project-relative deck path in task labels and
property references. A wrapper naming collision must not prevent measurement.

When one task over every assertion does not reach a final status, partition instead
of waiting on it:

- Tasks by block or hierarchy, not by trial per assertion. Make the last block the
  complement of the named ones (`select -set keep t:$check t:$assert %u <named
  blocks> %d`), so the union is the full list by construction; check it on the
  tool's own per-task assertion counts.
- Statements that need helpers go in scoped tasks with those helpers as assertions;
  exclude them from the block tasks by an asserted count (`select -assert-count N`),
  so a renamed statement stops the read instead of leaving the partition silently.
- A bmc task over a set whose prove task passes adds nothing. A whole-deck task that
  cannot prove the helper-dependent statements only spends its run budget.
- `timeout` is a run budget: a task that stops at it has not been measured yet, so
  rerun it with a budget that lets the tool finish. Report each task's wall time.
- The cover run uses the task's depth. A scenario that needs more cycles (a handshake
  across two clocks, a reseed before a first advance) gets the depth it needs, stated
  beside the result. A cover that only a fault can reach stays unreached in a model
  without fault injection: report it with that reason, never drop it.
  Put fault-only checks and their dependent enable covers in a separate task
  permitting the specified fault. Free only the fault inputs or native cut points
  that model it; retain the other input construction, clocks, resets and DUT logic.
  Check the native task lists: their union must retain every original assertion
  and explicit cover. Keep assumptions required by the specified interface
  contract. Remove an assumption the contract does not require when the original
  checks still prove, without adding replacement host state. Report assumptions
  and remaining construction limits.
- Keep each explicit cover in one task and remove it from the others, or every task
  repeats the same cover run.

## Captured rule — prove software read redaction at the actual interface

When the input declares storage unreadable by software, bind its read-data
property to the actual software-visible response. A register-leaf miter does not
establish the containing interface or behavior outside its host assumptions.
Use native constant-data or noninterference proofs with the documented address,
error and reset scope. Reach accepted-request and response conditions for the
protected regions.
Report unmeasured interfaces and internal-state secrecy separately.

A native cover model can prune data that its cover predicates do not use.
Cite the unbounded proof for redaction and the covers for transaction feasibility;
never infer a concrete payload from unknown waveform bits. Keep assumptions and
configuration explicit, and do not transfer results between different RTL profiles.

