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

  • How to Use This Course
  • Reading Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
    • Verification, Validation and Test
    • The Cost of an Escape
    • Intent, Design and Implementation
    • You Cannot Test Everything
    • Confidence, Not Proof
    • The Verification Stack
    • Meet DCRouter
    • Drills: What Verification Is
  • Part 1: What Can Go Wrong11
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
  • Part 10: Emulation and Prototyping8
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹Part 0: What Verification Is
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 0: What Verification Is
  4. Confidence, Not Proof

Part 0 · What Verification Is · Working (W)

Confidence, Not Proof

If no design can be tested exhaustively, verification produces evidence, not proof. What kinds of evidence exist, how they combine into confidence, and why the honest goal is a known, acceptable residual risk.

On this page

    Note

    Level: Working (W) · Answers: What does it mean for a chip to work?

    Before this: You Cannot Test Everything

    A manager asks the verification lead: "Is the block verified?" The lead can answer "yes", which nobody can actually know, or "no", which is never true either, since a lot of verification has been done. The honest answer is neither. It is a statement of evidence: what was checked, how thoroughly, what was not, and how much risk that leaves.

    If verification cannot prove a design correct, what does it produce, and how do you know it is enough?

    The obvious answer, and why it breaks

    The obvious answer is a binary: verified or not verified, usually decided by a number such as "100% coverage" or "zero failing tests". Each such number measures one kind of evidence and is silent about the rest. Coverage says situations were exercised, not that results were checked; zero failures says the checks passed, not that the checks were right. Treating any single number as "verified" turns a judgement about risk into a false certainty.

    The idea: kinds of evidence, combined

    Evidence

    What it shows

    What it does not show

    Tests pass

    The checks found no mismatch in what was run

    That the checks were right, or that enough was run

    Coverage reached

    The planned situations were exercised

    That results were checked in them, or that the plan was complete

    Formal proof

    A property holds for every allowed input sequence

    That the property and assumptions say what was meant

    Bug trend flattening

    Current methods are finding fewer bugs

    That few bugs remain (lesson 12.6)

    Reviews

    Knowledgeable people found no gaps

    Anything systematic they share as a blind spot

    Independence

    Checks and design were written separately

    That both readings were right

    Each kind covers a weakness of another. Coverage without checks is a false pass; checks without coverage leave untested regions; proofs without review can prove the wrong thing. Confidence comes from several kinds agreeing, not from any one being high.

    Residual risk: the honest goal

    • Residual risk is what remains after all the evidence: the parts not verified, the assumptions not checked, the bugs likely still present.

    • Sign-off is a decision to accept it, made by people who understand it, not a certificate that it is zero (Part 14).

    • Stating it explicitly lets the business decide: ship, add a workaround path, or spend more verification on the riskiest part.

    How real teams express confidence

    Practice

    What it adds

    Sign-off criteria across several kinds of evidence

    No single number can declare completion

    Waivers recorded with reasons and owners

    Known gaps are visible instead of hidden

    Residual-risk statements at tape-out

    The decision-makers know what they are accepting

    What breaks

    A block (illustrative) was declared verified at 100% functional coverage. A later review found that a third of its scoreboard checks were disabled by a configuration flag set during bring-up and never cleared. The coverage was genuine; the checking was not. Combining coverage with checks on whether each checker actually fired would have exposed it the day the flag was set.

    Why this matters

    Principal lens. Never answer "is it verified?" with yes or no. Answer with evidence and risk: what was checked and how, which kinds of evidence agree, what is waived and why, and what risk remains. A team that speaks this way earns trust when it says "ready", and makes escapes discussable instead of embarrassing.

    Interview

    Asked: "When is a design verified?"

    Weak answer: When coverage is 100% and all tests pass.

    Strong answer: Never in the sense of proven correct; verification produces evidence, and the design is ready when the evidence is strong enough that the remaining risk is acceptable to the people deciding. I'd look for several kinds agreeing: checks that pass and are known to fire, coverage of a plan reviewed against the spec, formal proofs on the riskiest control logic, a flattening bug trend that isn't just a sign the methods have saturated, and recorded waivers. Then state the residual risk explicitly at sign-off.

    Follow-ups: (1) What is a false pass? (2) Who decides whether residual risk is acceptable?

    Check yourself Coverage is 100% and no test fails. Name two ways the design could still be badly wrong.

    The checks might not check what matters (or not run at all), and the coverage plan might be missing important situations; also the specification itself might be wrong.

    Check yourself Why combine several kinds of evidence instead of maximising one?

    Each kind has blind spots that another covers; agreement across kinds is what makes confidence justified.

    Key takeaways

    • Verification produces evidence and confidence, not proof.

    • Each kind of evidence has blind spots; confidence comes from several kinds agreeing.

    • The honest goal is a stated, accepted residual risk.

    Keep going

    Next: Lesson 0.6, The Verification Stack. Block, subsystem, SoC, system: what each level can see.

    Related topics

    • Part 0 overview: What Verification Is

    Previous

    10 / 160

    Next: The Verification Stack

    Up next

    Up nextThe Verification Stack

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • Verification, Validation and Test
    • The Cost of an Escape
    • Intent, Design and Implementation