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
  • 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
    • What Formal Does
    • Bounded Proofs
    • Induction and Full Proofs
    • Assumptions and Over-Constraint
    • Where Formal Wins
    • Where Simulation Wins
    • Formal Apps
    • Combining Formal and Simulation
    • Proving DCRouter
    • Drills: Formal and Simulation
  • 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

‹First Principles of Verification Strategy
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 7: Formal and Simulation

Part 7 · Formal and Simulation · All levels

Part 7: Formal and Simulation

When should we prove instead of test? Explain what a bounded proof and an induction proof each guarantee.

  • 10topics
  • 10lessons
On this page

    Part 7 answers: When should we prove instead of test?

    Where Part 7 sits among the sixteen questions of the course.

    Formal tools consider every input sequence the environment allows, so they find rare combinations simulation would need years to hit, and can prove that none exist. They struggle with large designs, long sequences and heavy data paths, and every proof depends on assumptions that may hide bugs.

    This part covers bounded and full proofs, assumptions and over-constraint, where formal wins and where simulation wins, formal apps such as equivalence checking, and how to split a verification plan between proof and test. Proofs on this course run for real, with Yosys and an SMT solver.

    After this part you can

    • Explain what a bounded proof and an induction proof each guarantee.

    • Spot an over-constrained proof and guard against it.

    • Split a verification plan between formal and simulation.

    Warm-up: three questions from Part 6

    Answer each in your head before opening it. If two or more feel shaky, revisit Part 6: Coverage first.

    Check yourself What does 100% coverage prove?

    That every planned situation was exercised, not that the design behaved correctly in them.

    Check yourself What does a coverage plateau usually mean?

    The stimulus can no longer reach the remaining bins; change the stimulus, prove them unreachable, or waive them.

    Check yourself What does mutation testing measure?

    Whether the testbench detects deliberately injected bugs: the quality of the checks, not of the design.

    Lessons

    #

    Lesson

    Level

    Status

    7.1

    What Formal Does

    W · Working

    Ready

    7.2

    Bounded Proofs

    S · Senior

    Ready

    7.3

    Induction and Full Proofs

    S · Senior

    Ready

    7.4

    Assumptions and Over-Constraint

    S · Senior

    Ready

    7.5

    Where Formal Wins

    S · Senior

    Ready

    7.6

    Where Simulation Wins

    S · Senior

    Ready

    7.7

    Formal Apps

    S · Senior

    Ready

    7.8

    Combining Formal and Simulation

    P · Principal

    Ready

    7.9

    Proving DCRouter

    S · Senior

    Ready

    —

    Drills and checkpoint

    all levels

    Ready

    Every lesson in this part is ready. Work through them in order: each one sets up the problem the next one solves.

    Tip

    DCRouter in this part. Step 9: prove DCRouter's arbiter and credit counters; see which zoo bugs fall to proof. DCRouter is the small router you verify across the course, with 24 planted bugs; see Meet DCRouter.

    Where other courses go deeper

    This course teaches the decisions behind verification. These lessons teach the tools and syntax that carry them out, so this part links to them instead of repeating them.

    • Formal course: Formal versus Simulation

    • Formal course: Property Development

    • Formal course: Equivalence Checking

    Related topics

    • Course hub

    • Previous: Part 6 · Coverage

    • Next: Part 8 · Verification Levels and Reuse

    PreviousNext: What Formal Does

    Up next

    Up nextWhat Formal Does

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • How to Use This Course
    • Reading Paths
    • Concept Map