Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • RTL Foundations36
  • Combinational Design25
  • Sequential Design27
  • FSM & Control27
  • Timing & Clocking39
  • Reset & CDC34
  • Memory & Buses57
  • Advanced RTL28
    • Parameterization and Generate Hub
    • Top-Level Integration Hub
    • Synthesis Intent Hub
    • Style and Static Checks Hub
    • Assertions in RTL Hub
    • Formal Verification Basics Hub
      • What formal adds beyond simulation
      • Assumption discipline
      • When formal helps most
      • Your First Formal Run
    • Reusable SystemVerilog for RTL
  • Senior & Interview76
  • Glossary and Notation
Loading lesson

‹Advanced RTL
  1. Topics
  2. RTL Design
  3. Advanced RTL
  4. Formal Verification Basics Hub

Part 8 · Advanced · Advanced

Formal Verification Basics Hub

Bounded proofs, assumption discipline, and where formal methods beat simulation.

  • 4topics
  • 4lessons

Topics in this section

  1. 1What formal adds beyond simulation1 lesson
  2. 2Assumption discipline1 lesson
  3. 3When formal helps most1 lesson
  4. 4Your First Formal Run1 lesson
On this page

    Simulation samples behaviors. Formal explores the state space under given assumptions.

    Question

    Simulation

    Formal

    Coverage

    Samples chosen behaviors

    Explores every behavior under the assumptions

    Result on a pass

    The sampled runs pass

    The property holds inside the bound

    Needs

    Stimulus and checkers

    Properties and environment assumptions

    Misses

    Corners no seed visits

    Anything outside the assumptions or the bound

    Lessons in this topic

    4 lessons, about 23 min

    1. 1What formal adds beyond simulationYou can explain what exhaustive search adds to simulation, and say exactly what a bounded pass, a proof and a cover result each tell you.5 min
    2. 2Assumption disciplineYou can write assumptions as environment contracts, find a vacuous pass by covering the antecedent, and re-run with fewer assumptions.4 min
    3. 3When formal helps mostYou can pick small control-heavy blocks for formal, pair each assert with a cover, and derive a response bound from the service gap and the flag policy.6 min
    4. 4Your First Formal RunYou can write an immediate assertion with an input assume, run a bounded check and an induction with Yosys and yosys-smtbmc, read the counterexample, and add a helper invariant when induction fails.8 min
    Check yourself A block passes 10,000 random runs and a bounded proof to depth 20. What is still unknown?

    Any behavior after cycle 20 that the random runs did not happen to sample, and anything the formal assumptions exclude. Inside the bound, BMC covers every input sequence; beyond it, only the sampled runs speak.

    Interview

    Likely question: what is the difference between a bounded pass and a proof?

    • Bounded pass covers cycles 0 to N under stated assumptions.

    • Proof covers every cycle, usually by induction.

    • Vacuity: an implication holds without a response obligation on traces where its antecedent never fires. Exact-trigger reachability and property proof are separate questions.

    Revision sheet

    The whole topic on one page, taken from each lesson's Remember box. Read it before an interview, or print it.

    What formal adds beyond simulation

    • Each simulation seed walks one path; formal explores the state space under given assumptions.

    • A pass at depth N is bounded assurance; an unbounded proof needs a complete method.

    • Formal wins on control corners and protocol invariants. Simulation stays essential for datapaths and long sequences.

    Rule of thumb: read the actual task result; PASS, FAIL, UNKNOWN and ERROR are not interchangeable.

    Assumption discipline

    • Every strong assumption should map to an interface or protocol guarantee, and be reviewed like an assertion.

    • If the trigger never fires, the implication holds with no check on the grant logic.

    • Zero cover hits in simulation mean non-exercise; a bounded formal miss means no witness within that depth.

    Rule of thumb: weaken assumptions until legal stress passes through.

    When formal helps most

    • Formal pays back fastest on small control logic with a large state space: FIFOs and arbiters.

    • Pair each obligation with an exact-trigger cover; a bounded cover miss is inconclusive beyond its depth.

    • Eventual service gives eventual progress. A numeric deadline needs a maximum service gap and persistent request ownership.

    Rule of thumb: state the service-gap and persistence assumptions before you derive the bound.

    Your First Formal Run

    • A bounded pass covers its depth from reset. Induction covers every cycle, but it starts from any state that satisfies the assertions, reachable or not.

    • When induction fails, check step 0 of its trace: an unreachable start state needs a helper assertion, proved like any other.

    • An over-constrained assume makes a buggy design pass. Cover the inputs your asserts depend on.

    Rule of thumb: a formal pass means nothing until you know its depth, its assumptions and whether induction closed.

    Practise it

    • Mini project: a reusable FIFO IP with package, interface, assertions and a formal check

    • Practice question: FSM formal verification of liveness and safety

    • Code lab: Formal vacuity check

    • Practice question: Formal-friendly CDC FIFO checkers

    • Code lab: Synchronous FIFO (4 entries)

    • Interview: run a mock interview on this topic

    How this was checked

    All simulation benches here are finite exercises, not formal proofs. Executed with Icarus Verilog 13.0 (2026-10-16): each prints PASS. Each bench declares 1ns/1ps time units and terminates unexpected failures with a diagnostic $fatal(1, ...); $finish follows PASS. The repository runner recognizes FAIL markers in logs, whereas copied standalone automation also needs failing process termination.

    PreviousNext: What formal adds beyond simulation

    Up next

    Up nextWhat formal adds beyond simulation

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Parameterization and Generate Hub
    • Top-Level Integration Hub
    • Synthesis Intent Hub