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
    • Writing Properties That Can Fail and Say Something
      • Spec Sentence to Property
      • End to End Versus Local Properties
      • Symbolic Constants and Tracked Items
      • Widths, Signedness and Initial State
    • Assumptions as a Contract
    • Abstraction and Complexity
    • Assume-Guarantee and Black Boxes
    • Reusable Property Sets
  • 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

←Property Development and Constraints
  1. Topics
  2. Formal Verification
  3. Property Development and Constraints
  4. Writing Properties That Can Fail and Say Something

Part 3 of 10Part 3 of 10/Property Development and ConstraintsAll levels

Writing Properties That Can Fail and Say Something

Turn each requirement sentence into a property with a trigger, a response, a window and a scope, and prove the property can fail.

  • 4topics
  • 4lessons

A property is a contract written in logic. The commonest failure of a first formal run is not a design bug but a property that cannot fail: a trigger that never fires, a comparison against the design's own expression, a width that throws the failing case away. The proof then passes and means nothing. This topic builds one habit: read each requirement sentence, ask five questions about it, write the property, then break the design on purpose and read the counterexample.

Lesson

After it you can...

Spec Sentence to Property

Ask the five questions, write the property with the right window, count answers one to one, and show a cover that its trigger can fire.

End to End Versus Local Properties

Layer a local stage check under an end-to-end check and say which one names the broken stage.

Symbolic Constants and Tracked Items

Prove data integrity by following one free item instead of building a scoreboard.

Widths, Signedness and Initial State

Size, sign and start a property so that large values, negative values and the first cycle are checked.

Suggested order: top to bottom. The five questions come first because every later lesson uses them; layering decides where each property lives; tracked items need both; widths and initial state are the quiet ways a good property goes blind. For the SVA language itself see the SystemVerilog course: only the forms the front end accepts are used here.

A loop from a requirement sentence through trigger and response, then window and scope, then the property with a cover, then a planted fault, and back to the first questions.
From a requirement sentence to a property that has been seen failing: trigger and response, window and scope, the property with its cover, then a planted fault whose counterexample feeds back into the questions.
Check yourself A property proves on its first run and nobody can show it failing. What are the first two checks?

Whether its trigger can fire (an antecedent cover), and whether it compares the design with an independent expectation instead of with its own expression. Then plant a fault the property should catch.

You will be handed a sentence and asked for the property. Answer with the five questions, the property, the cover that shows the trigger fires, and one planted fault it catches.

Related topics

  • Up: Property Development and Constraints

  • SVA forms: Implication and Clocking

PreviousNext: Spec Sentence to Property

Up next

Up nextSpec Sentence to Property

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Assumptions as a Contract
  • Abstraction and Complexity
  • Assume-Guarantee and Black Boxes