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
    • Connectivity Checking
      • Table-Driven Connectivity Proof
      • Mode Conditions and Escapes
      • A Wrong Row and Its Counterexample
    • Register (CSR) Verification
    • Deadlock, Livelock and Starvation Checks
    • Reset Determinism and X
    • Data, Handshake and Pipeline Property Sets
    • Other Applications, Honestly Scoped
  • Equivalence Checking14
  • Formal Coverage and Signoff15
  • Methodology and Debug13
  • Interview Prep15
  • Capstone: A Chip-Block Verification Lab24
Loading lesson

←Formal Applications
  1. Topics
  2. Formal Verification
  3. Formal Applications
  4. Connectivity Checking

Part 5 of 10Part 5 of 10/Formal ApplicationsAll levels

Connectivity Checking

Proving a whole chain is wired correctly from a connection table, for every mode, with generated checks.

  • 3topics
  • 3lessons

A swapped pair of bits between two blocks passes every block-level testbench and fails in the system. Connectivity proof exists for exactly that bug: it checks, structurally and for all input values, that every destination sees its specified source. This topic proves the helper chain of pipeline into FIFO into handshake stage from a six-row table, generates the checks from the table so the table stays the source of truth, and reads the counterexamples that a wrong row and three wiring faults produce.

Lesson

After it you can...

Table-Driven Connectivity Proof

Write a connection table, generate its proof block, run the proof, and see a table typo fail it.

Mode Conditions and Escapes

Prove each connection in its mode and catch a link that is live outside it.

A Wrong Row and Its Counterexample

Read a truncation, a swap and a missing tie-off, and decide whether the table or the wiring is wrong.

Suggested order: top to bottom. The first lesson builds the method on the chain, the second adds modes, and the third is the debug guide you will actually open when a check fails. The structural lint view of the same tables lives in the SoC course.

A top-down flow with five boxes. The connection table feeds a generator script, which emits an assertion block. The formal tool proves the block over all values, ending either in proven or in a counterexample trace.
From a connection table to a proof: the table feeds a generator, the generator emits checks, the tool proves them or returns a trace.
Check yourself Why generate the checks from the table instead of writing one assertion per signal by hand?

Hand-written checks drift from the intent: the table is reviewed and the checks are derived, so a wrong row is one typo in one place and the proof names it. A hand-written set can also silently miss a signal.

Related topics

  • SoC: Connectivity Tables as Source of Truth

  • SoC: Python Connectivity Checker

  • Verification First Principles: Formal Apps

PreviousNext: Table-Driven Connectivity Proof

Up next

Up nextTable-Driven Connectivity Proof

Sign in to save progress

Practice this lessonPrevious lessonReport an error

See also

  • Register (CSR) Verification
  • Deadlock, Livelock and Starvation Checks
  • Reset Determinism and X