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
      • Rapid Fire: Assume, Assert, and Vacuity
      • Rapid Fire: Induction and Bounded Proofs
      • Rapid Fire: Liveness and SVA
      • Rapid Fire: Abstraction, Equivalence, and Signoff
    • Numeric Drills
    • Spot the Bug in the Answer
  • Capstone: A Chip-Block Verification Lab24
Loading lesson

←Rapid Fire by Theme
  1. Topics
  2. Formal Verification
  3. Interview Prep
  4. Rapid Fire by Theme
  5. Rapid Fire: Liveness and SVA

Part 9 of 10, lesson 10 of 15Part 9 of 10/Interview Prep/Lesson 10 of 15All levels

Rapid Fire: Liveness and SVA

Answer twelve questions on safety versus liveness, fairness, lassos, bounded response, and the runnable Boolean forms.

Why it matters

Liveness answers reveal whether the candidate has proved one or only simulated one, and SVA answers reveal whether each operator is read at cycle level. This drill pairs the two because the runnable forms tie them together. Each answer is two sentences; the trap column names the confusion being fished for.

Question

Short answer

Trap

Teaching lesson

Safety versus liveness?

Safety says nothing bad happens on any prefix; liveness says something good happens on every infinite trace. Starvation is a liveness failure, overflow is a safety failure.

Proving eventually with a bounded run.

Safety and liveness

Why is bounded response a safety property?

Waiting too long is decided on a finite prefix: the trace already violates the window. True eventually needs an infinite loop to fail.

Calling a windowed check a liveness proof.

Bounded response is safety

What is a lasso counterexample?

A finite prefix plus a loop the trace repeats for ever, showing the good event never arrives. Bounded runs cannot produce one; they can only miss the window.

Showing a long finite trace as a liveness refutation.

Lasso counterexamples

Where does fairness live?

On environment choices only: requesters persist, holders finish. Never on design outputs, where it would assume the answer.

Assuming the grant to prove the grant.

Fairness and what you may assume

Weak versus strong, in one line?

Strong forms demand the event; weak forms tolerate the trace ending first. A bounded response is a safety property: written as a sequence it is weak unless wrapped in strong, and the counter form needs no such choice.

Offering a weak eventuality as a proof.

Weak and strong

Overlapped versus non-overlapped implication?

Overlapped checks the consequent in the same cycle as the antecedent; non-overlapped in the next. State the cycle of the consequent explicitly in the runnable form.

Being off by one on the response cycle.

Overlapped and non-overlapped

What runs in the open flow?

Boolean assertions with sampled history: past, rose, fell, stable, plus free inputs and free constants. Implication operators and sequences are concept-only and always paired with the Boolean form.

Showing only the unrunnable form.

Textbook SVA to Boolean past

What does sampled history check?

The relation between the present cycle and named past cycles, with a guard skipping the cycle after reset. History before the first cycle is undefined, so the guard is load-bearing.

Unguarded history failing the good design at step 2.

Past gating and history windows

One-to-one request and response?

Track the item or count it: a symbolic tag or a counter ties each grant to its request. A lone next-cycle implication cannot match pairs.

Asserting pairing with a single implication.

Symbolic constants and tracked items

Stable-until-grant, correctly?

The request holds and the address holds until the grant arrives, checked every cycle of the wait. One stable check covers one cycle only.

Checking stability once for a multi-cycle wait.

Stable until the handshake

Edge or level: rose or high?

The edge form fires once on the rising request; the level form fires on every cycle the request is high. Most handshake properties want the edge.

Firing the property on every high cycle.

Every cycle versus rose

Starvation versus deadlock versus livelock?

Starvation serves some and never one; deadlock serves none with a cycle of waits; livelock moves without completing. Different shapes, different proofs, different fixes.

One cure for all three hangs.

Defined once, precisely

If a finite prefix can violate the property it is a safety property, such as a bounded response. If only an infinite trace can violate it, it is liveness and needs a lasso engine and fairness on the environment.
How to classify a progress property before choosing how to prove it.

Fairness on an output. Symptom: the liveness proof passes and so does the starvation mutant. Cause: the assumption forces the grant the property demands. Fix: fairness on requester behaviour only. Found by a starvation mutant that must fail.

When asked for eventually, answer with within N and derive N on the board. When asked for an operator, state the cycle it checks. Both habits mark answers that have been proved, not memorised.

Check yourself The environment may stall forever and the property still passes. What is wrong?

The liveness obligation is vacuous or the fairness is too strong: an unbounded wait must fail, so either the trigger never fires or an assumption forces the answer.

Related topics

  • Scenario: A Deadlock-Like Trace

  • SystemVerilog: Operator Interview Drills

  • SystemVerilog: SVA Interview Drills

Previous

154 / 183

Next: Rapid Fire: Abstraction, Equivalence, and Signoff

Up next

Up nextRapid Fire: Abstraction, Equivalence, and Signoff

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Rapid Fire: Assume, Assert, and Vacuity