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
    • Intent and the Oracle
    • From Prose to Rules
    • Reference Models
    • Tables and Executable Specifications
    • Specification Review and Ambiguity
    • Requirements Traceability
    • What Not to Check
    • Drills: Specifications as Checkable Rules
  • 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

‹First Principles of Verification Strategy
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 2: Specifications as Checkable Rules

Part 2 · Specifications as Checkable Rules · All levels

Part 2: Specifications as Checkable Rules

What exactly are we checking against? Turn a prose requirement into checkable rules.

  • 8topics
  • 8lessons
On this page

    Part 2 answers: What exactly are we checking against?

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

    Every check needs an oracle: something that knows the right answer. Prose specifications are ambiguous, incomplete and sometimes wrong, so the first job of verification is to turn intent into rules a machine can check and models that compute expected results.

    This part covers the oracle problem, turning sentences into numbered rules, reference models at different levels of detail, specification review as a bug-finding activity, traceability from requirement to result, and the opposite danger: checks that forbid legal behaviour.

    After this part you can

    • Turn a prose requirement into checkable rules.

    • Choose the right level of detail for a reference model.

    • Review a specification for ambiguity and trace every requirement to evidence.

    Warm-up: three questions from Part 1

    Answer each in your head before opening it. If two or more feel shaky, revisit Part 1: What Can Go Wrong first.

    Check yourself Name four classes of bug.

    Any four of: corner case, concurrency, integration, configuration, performance, reset or power, specification.

    Check yourself Why do integration bugs escape block-level tests?

    Each block is tested against its own understanding of the interface; the disagreement only appears when they meet.

    Check yourself Where do bugs cluster?

    In new, complex and recently changed logic, and at boundaries between blocks and teams.

    Lessons

    #

    Lesson

    Level

    Status

    2.1

    Intent and the Oracle

    W · Working

    Ready

    2.2

    From Prose to Rules

    W · Working

    Ready

    2.3

    Reference Models

    S · Senior

    Ready

    2.4

    Tables and Executable Specifications

    S · Senior

    Ready

    2.5

    Specification Review and Ambiguity

    S · Senior

    Ready

    2.6

    Requirements Traceability

    P · Principal

    Ready

    2.7

    What Not to Check

    P · Principal

    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 3: a Python reference model of DCRouter that predicts every output packet. 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.

    • VIP and compliance course: Transaction Modelling

    • Protocols course: Writing an Interface Contract

    Related topics

    • Course hub

    • Previous: Part 1 · What Can Go Wrong

    • Next: Part 3 · Observability and Controllability

    PreviousNext: Intent and the Oracle

    Up next

    Up nextIntent and the Oracle

    Sign in to save progress

    Practice this lessonReport an error

    See also

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