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
# 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:
- Read
property_contract.jsonand the request. Preserve every obligation ID. - 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.
- Author properties in
phase2/stage1/formal/formal_expert_properties.svh, the fragment the generated harnessformal_<top>.svincludes — the harness is rewritten by everyformal_harness_genrun, the fragment never is. Only when no harness could be generated, authorformal_<top>.svitself. 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. - Write
formal_expert_review.jsonwithinvocation_status: INVOKED,fallback_skill: formal-verify, and adispositionslist with oneAUTHORED,DECLARATION_MISSING, orUNANSWERABLErow for every request ID. EveryAUTHOREDrow names the exactproperty;UNANSWERABLEkeeps the row INCOMPLETE and names what declaration/property is missing. - Run
formal_property_run.py, thenformal_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
result: All 4 complex modules pass BMC at depth 50.
Solution B: Abstract Timers (ifdef FORMAL)
Replace long counters with short ones for formal:
`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
Solution C: Assume-Constrain Decomposition
Use assume() to restrict inputs to legal behavior:
// 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
Solution D: Helper Invariants
Help solver know which state combinations are impossible:
// 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
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
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
- RTL module under verification
- SVA properties (from the deterministic floor or expert-authored here)
- Target engine: SymbiYosys (open), Jasper (Cadence), VC Formal (Synopsys)
- Bound (for BMC) or depth (for k-induction)
- Constraints / assumptions (
assumeproperties)
Workflow
- Choose the proof scope. Read the elaborated state, required property and native solver results to choose unbounded proof or a disclosed BMC bound.
- Generate assertions — deterministic floor first, then this skill for the exact unresolved obligation IDs
- Write
.sbyconfig with appropriate mode and depth - Run engine —
sby -f module.sby - Triage results:
- PASS: record bound/depth
- FAIL: capture CEX trace, map to RTL line, propose fix →
/rtl-repair - TIMEOUT: apply solutions B-F above
- Regression harness: re-run after any RTL change
Output format
formal/<module>.sbyformal/<module>_formal.sv— assertionsformal/<module>_report.mdwith 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
- ZipCPU Formal Verification Blog Series
- Model Checking and State Explosion (Clarke et al.)
- Formal Verification with SymbiYosys (Clifford Wolf)
- HIVE: Scalable HW-FW Co-Verification via Decomposition
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 (
$isunknowninASSERT_KNOWN, and enum.next()inprim_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:
`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.
timeoutis 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.