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
  • Properties and SVA16
  • Property Development and Constraints19
  • Proof Engines and Convergence23
  • Formal Applications20
  • Equivalence Checking14
  • Formal Coverage and Signoff15
  • Methodology and Debug13
  • Interview Prep15
    • Formal Whiteboard Framework
    • Scenario: A Proof That Will Not Converge
    • Scenario: Everything Proves, Nothing Is Reached
    • Scenario: A Late ECO Breaks Equivalence
    • Scenario: A Deadlock-Like Trace in Arbiter and Fabric
    • Rapid Fire by Theme
    • Numeric Drills
      • Numeric Drills: State and Depth
      • Numeric Drills: Engine and Assumption Load
    • Spot the Bug in the Answer
  • Capstone: A Chip-Block Verification Lab24
Loading lesson

←Interview Prep
  1. Topics
  2. Formal Verification
  3. Interview Prep
  4. Numeric Drills

Part 9 of 10Part 9 of 10/Interview PrepAll levels

Numeric Drills

Work ten classic whiteboard calculations plus mutation and bound-justification arithmetic as checked calculators.

  • 2topics
  • 2lessons

Interview arithmetic is small, exact, and always tied to a decision: how big the state space is, how deep the bound must reach, how many bits an abstraction saves. These drills compute each number twice: once by hand in the prose, once in a runnable calculator that also shows the failing variant, so a wrong input is caught, not averaged away. Work them with a pen first, then read the calculator.

Lesson

After it you can...

Numeric Drills: State and Depth

Size a state space, justify a bound, and price FIFO depth, induction k, memory, and counter abstraction.

Numeric Drills: Engine and Assumption Load

Price cones, lassos, unrolled problems, assumption load, mutation gates, and bound justifications.

Suggested order: top to bottom. The first lesson sizes the machine and the bound; the second prices the engine's work and the assumptions' cost. Every result is labelled illustrative or tied to a running design.

Size the machine first, justify the bound from the size, price the abstraction that shrinks it, and gate signoff on the numbers.
The numeric habit: size, bound, abstract, gate.
Check yourself Why does every drill show a failing variant?

Because a calculator that cannot fail cannot check: the wrong input must be caught visibly, or the number is decoration rather than evidence.

Related topics

  • Framework: Whiteboard Questions 1 to 6

  • Scenario: A Proof That Will Not Converge

PreviousNext: Numeric Drills: State and Depth

Up next

Up nextNumeric Drills: State and Depth

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Formal Whiteboard Framework
  • Scenario: A Proof That Will Not Converge
  • Scenario: Everything Proves, Nothing Is Reached