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

AboutRoadmapCareersInternshipsFAQContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Paths
  • Glossary
  • Metrics Reference
  • Formal Cheat Sheet
  • Formal Foundations19
    • Formal versus Simulation
      • Three Outcomes of a Formal Run
      • A Proof Is Relative to Its Assumptions
      • A Bug Simulation Misses
      • The Formal Engineer's Split
    • Transition Systems, Invariants and the Three Property Roles
    • Reset, Initial State and the First Cycle
    • Cone of Influence
    • The Formal Tool Flow, Vendor-Neutral
  • Properties and SVA16
  • Property Development and Constraints19
  • Proof Engines and Convergence23
  • Formal Applications20
  • Equivalence Checking14
  • Formal Coverage and Signoff15
  • Methodology and Debug13
  • Interview Prep15
  • Capstone: A Chip-Block Verification Lab24
Loading lesson

←Formal Foundations
  1. Topics
  2. Formal Verification
  3. Formal Foundations
  4. Formal versus Simulation

Part 1 of 10Part 1 of 10/Formal FoundationsAll levels

Formal versus Simulation

What a formal result means, what it costs, and which obligations belong to formal rather than simulation.

  • 4topics
  • 4lessons

Simulation shows the design working on the sequences you wrote. A formal run checks a property against every input sequence the model allows, up to a bound or all the way to a proof, and answers in one of three ways: proven, counterexample, or inconclusive. This topic fixes that vocabulary, shows that every proof is relative to its assumptions, gives one honest measurement of what simulation misses, and ends with a practical split of work between the two methods. It assumes the on-ramp lessons below and starts where they stop: with results you must defend.

Lesson

After it you can...

Three Outcomes of a Formal Run

Read any formal result as proven, counterexample, or inconclusive, and say what bounded to N does and does not promise.

A Proof Is Relative to Its Assumptions

Predict how an assumption changes a result, and spot an assumption that hides a bug.

A Bug Simulation Misses

Quantify why a deep corner bug escapes random simulation and falls to a bounded check.

The Formal Engineer's Split

Assign each obligation to formal or simulation and size a formal model from its state bits.

Suggested order: top to bottom. The first lesson fixes the vocabulary every later lesson uses. The second shows why that vocabulary always carries an assumption list. The third motivates the cost with one measured bug. The fourth turns the insight into a work split.

A run feeds a model plus assumptions into the check. A proven result is signed off with its assumption list. When no proof is reached the result is either a counterexample, whose trace is triaged, or inconclusive, which demands a bound justification or a stronger proof.
A formal run and its three outcomes, with what each outcome demands next.
Check yourself A report says a property passed at depth 12. Which of the three outcomes is that?

Inconclusive, bounded to 12: no counterexample up to 12 steps. That is a sound result with a stated bound, but not a proof; it becomes signoff-grade only with a bound justification.

Related topics

  • On-ramp: Formal in One Lesson

  • Verification First Principles: What Formal Does

  • Later: Bounded versus Unbounded Proofs

PreviousNext: Three Outcomes of a Formal Run

Up next

Up nextThree Outcomes of a Formal Run

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Transition Systems, Invariants and the Three Property Roles
  • Reset, Initial State and the First Cycle
  • Cone of Influence