Relational constraints and collection modeling interview questions

Question 1

Why are SystemVerilog constraints described as declarative and bidirectional?

Accepted Answer

A constraint describes relationships that must hold in the final assignment. It does not execute statements from top to bottom or designate the left side of == as an output. length == beats * 4 relates both variables. If either value is fixed, the other is constrained by the same equation. The order of constraint expressions does not change their logical intersection. condition -> rule activates the consequent only when the antecedent is true. It neither creates execution order nor implies the reverse relationship. If one field is purely derived and does not need to influence legality, calculating it in post_randomize() can make intent clearer and reduce solver work. Why interviewers ask: Whether you reason in solution sets rather than importing procedural assignment intuition into the constraint solver. Common trap: Do not claim the solver assigns the left-hand variable from the right-hand variable. Equality is a two-way relation in the solve.

Question 2

What does solve ... before change, and what does it not change?

Accepted Answer

solve a before b changes the sampling order and therefore the marginal distribution of a. It does not add or remove legal solutions, and it is not a remedy for a circular equation. Without ordering, a value of a that has many compatible b values can appear more often. With solve a before b, the solver selects a first from its legal values, then chooses a compatible b. Use ordering only when that distribution is part of the stimulus intent. Excessive ordering couples the model to probability details and can reduce solver flexibility. Why interviewers ask: Whether you can separate satisfiability from probability and explain why two runs can have the same legal pairs but different traffic mixes. Common trap: Do not say solve before makes a bidirectional constraint procedural. All active relationships still have to hold in the final assignment.

Question 3

How are constraints inherited and overridden in a derived class?

Accepted Answer

A derived class inherits its base constraints. A derived constraint block with the same name replaces the inherited block; a differently named block is added and must remain compatible. SystemVerilog class inheritance is single inheritance, although the chain may contain several levels. Use a soft base expression when subclasses and tests should refine a default without replacing the whole named block. Because randomize() is virtual, the constraints of the actual object type apply even when the handle has a base-class type. Why interviewers ask: Whether you understand polymorphic constraint behavior and can predict when a derived rule replaces or combines with a base rule. Common trap: A new block named c_child does not override a base block named c_base. Both remain active and can conflict.

Question 4

How do you constrain a dynamic array's size and elements?

Accepted Answer

Constrain size() to establish the dynamic array's shape, then use foreach to contribute one declarative element rule for every valid index. The solver determines the array size before applying iterative element constraints that depend on the index domain. foreach is constraint syntax. A procedural for loop is not used inside a constraint block. Keep size bounds realistic. Large unconstrained arrays multiply variables and can make an otherwise simple model expensive. Why interviewers ask: Whether you can distinguish collection shape from element legality and write solver-friendly iterative constraints. Common trap: Do not index a dynamic array using a separately randomized index unless the index is also constrained to the solved size.

Question 5

Why can sum() produce a surprising constraint result?

Accepted Answer

An array reduction returns a value derived from the element or with-expression type. If that type is too narrow, the sum can wrap before it is compared, so cast each contribution to a width that can represent the maximum total. A Boolean predicate such as item == DATA is one bit. Summing those one-bit results without a cast can truncate the count. data.sum() with (int'(item == DATA)) counts matching entries using int-width contributions. For wide unsigned data, choose an explicit unsigned size cast with enough extra bits for the array length rather than blindly using signed int. Why interviewers ask: Whether you account for expression width and signedness instead of assuming the right-hand comparison widens an already computed reduction. Common trap: Casting the final result after sum() is too late if overflow already happened during the reduction. Cast the iterator expression inside with.

Question 6

When should you use unique, randc, or shuffle()?

Accepted Answer

Use unique to require different values across a set in one solve, randc to avoid repeats across successive calls for one cyclic variable, and shuffle() to procedurally permute an existing collection. unique {ids} fails when the element count exceeds the number of legal distinct values. shuffle() is efficient when you can build a known pool first, but it runs procedurally and is not part of the constraint solution. $countones(vector) constrains the number of set bits in one integral value and is the direct tool for one-hot, m-hot, and Hamming-distance patterns. Why interviewers ask: Whether you can map three superficially similar no-repeat requirements to the right time domain and mechanism. Common trap: unique {scalar} says nothing useful, and randc on array elements does not automatically make the elements different from one another.

Question 7

What is the difference between equality, implication, and biconditional constraints?

Accepted Answer

Equality is always active, implication activates its right-hand rule only when the left condition is true, and biconditional requires both conditions to have the same truth value. length == beats * 4 is one bidirectional arithmetic relationship in the legal solution set. (mode == FAST) -> (length >= 64) permits any length when mode is not FAST; the reverse statement is not implied. (mode == FAST) <-> (length >= 64) also prevents non-FAST modes from using a length of 64 or greater. Why interviewers ask: Whether you can translate English requirements into the exact logical relationship without accidentally over-constraining or under-constraining the model. Common trap: A -> B is false only for A=1 and B=0. It does not mean B -> A.

Question 8

When does randomizing a parent object also randomize a nested object?

Accepted Answer

The parent handle must be declared rand and must already refer to a constructed child object. The solver can then include the child's random properties and any cross-object constraints in one solve. A plain child handle is not traversed for recursive randomization, so the child's current values remain fixed. randomize() does not allocate a null child. Construct nested objects in new() or before the randomization call. A parent rule such as outer_value > child.inner_value is solved with the child's active constraints when the child handle participates. Why interviewers ask: Whether you understand object ownership, construction, and recursive constraint participation rather than assuming every reachable handle is randomized. Common trap: Marking the handle rand does not replace construction. A null handle still leaves no child object for the solver to traverse.

Question 9

How do you prove a small constraint system is satisfiable?

Accepted Answer

Enumerate the bounded candidate space, apply each relationship as a filter, and show at least one surviving assignment. The survivors also reveal the actual sampling space. For a in 1 through 4 and b in 2 through 5, the rule a == b or a == b + 1 first narrows the Cartesian product. Adding an even-sum rule leaves (2,2), (3,3), and (4,4). Those three witnesses prove satisfiability. If a dist constraint is added, apply its weights only after identifying the legal survivors and then normalize over those values. Why interviewers ask: Whether you can reason from a concrete solution set before reaching for a simulator or making a probability claim. Common trap: A solver failure means the intersection is empty for the current state and active model; it does not identify which individual rule is wrong.

Question 10

What does sum() with (...) actually compute?

Accepted Answer

The with expression maps every array element to a temporary contribution, and sum() reduces those mapped contributions. It does not necessarily add the original elements. For data = {20, 2, 15, 5, 30}, the expression int'(item > 10) maps to {1, 0, 1, 0, 1}. The sum is therefore 3. This pattern counts states, matching values, or predicate hits without a procedural loop. The contribution's type controls reduction width, which is why an explicit cast belongs inside the with expression. Why interviewers ask: Whether you can explain the map-then-reduce semantics instead of treating with as a filter keyword. Common trap: A Boolean mapping is one bit wide unless you cast it. A mathematically correct count can still truncate in the language's expression type.

Question 11

How do you constrain one-hot, m-hot, or Hamming-distance patterns?

Accepted Answer

Use $countones() on an integral expression. Constrain the count to one for one-hot, to m for m-hot, or apply it to an XOR to constrain Hamming distance. $countones(select_line) == 1 permits exactly one asserted bit at any position. $countones(original_data ^ corrupted_data) == 2 requires exactly two changed bits. Use unique for relationships among separate values; use $countones for the population count of one packed bit vector. Why interviewers ask: Whether you select the direct bit-pattern primitive instead of expanding a fragile set of pairwise bit constraints. Common trap: $countones() counts 1 bits. Decide separately whether X and Z values are possible in the modeled type and whether a 2-state bit vector is more appropriate.

Question 12

How do you generate every ID from 0 through 255 without repeats, then reset?

Accepted Answer

Build a queue containing the full domain, shuffle it once, consume one entry per successful transaction, and rebuild only when the queue is empty. A pool makes the no-repeat state explicit and scales better than asking a wide randc variable or a growing unique model to remember history. Fill and shuffle in pre_randomize() only when the pool is empty. Remove the chosen ID in post_randomize() so a failed solve does not consume it. Linking id to pool[0] keeps the generated field visible to coverage while the queue owns traversal order. Why interviewers ask: Whether you can move a stateful traversal requirement out of the solver while preserving failure semantics and observability. Common trap: Do not pop the queue before knowing randomization succeeded, or failures silently skip IDs.

Question 13

How do you constrain a 4 by 4 Latin square?

Accepted Answer

Constrain every cell to 0 through 3, then require each row and each projected column to contain unique values. Four unique values drawn from a four-value domain form a permutation. The cell domain is essential. Uniqueness alone would allow arbitrary distinct integers instead of the required symbols. Rows are natural array slices, while columns usually need an explicit projection across the first index. Symmetry breaking such as fixing the first row can improve performance when any equivalent Latin square is acceptable, but it changes which solutions are sampled. Why interviewers ask: Whether you can express two-dimensional cross-element relationships cleanly and recognize the role of a finite domain. Common trap: Do not add a separate 'contains every value' rule after uniqueness over a four-cell row with domain 0 through 3; it is already implied.

Question 14

How do you generate a constrained permutation instead of merely unique values?

Accepted Answer

Give every element the complete 0 through N-1 domain and require the array to be unique. With N elements, that proves the result is a permutation; additional index and cross-element rules can then narrow it. For N=8, an even index can be constrained to hold an odd value and an odd index to hold an even value. A tie rule such as perm[0] + perm[1] == 7 relates the selected values without changing the permutation proof. A solve-before directive may express a desired sampling order for a tight pair, but it is not required for correctness and should not be sold as a universal performance fix. Why interviewers ask: Whether you can prove the permutation property from domain cardinality plus uniqueness and layer extra structure without procedural generation. Common trap: Unique values from a domain larger than N are only a selection without replacement, not a permutation of the whole domain.

Form	When it applies	Legal Boolean states
a == b	Always	00, 11
a -> b	b required when a is true	00, 01, 11
a `<->` b	Both directions	00, 11

Mechanism	Relationship	State
`unique`	Different values in one solve	No history required
`randc`	No repeat across calls	History stored per object variable
`shuffle()`	Permutation of an existing array or queue	Procedural collection state

Questions for Relationships + arrays

SystemVerilog Relationships and orderingEncode relationships, not procedures.

Relationships carve one shared solution space

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

SystemVerilog Arrays and collectionsConstrain shape before contents.

Array constraints build from shape to aggregate

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Reason it through

Relationships + arraysRelational constraints and collection modelingInterview guide

SystemVerilog Relationships and orderingEncode relationships, not procedures.

Relationships carve one shared solution space

Why are SystemVerilog constraints described as declarative and bidirectional?+

Reason it through

What does solve ... before change, and what does it not change?+

Reason it through

How are constraints inherited and overridden in a derived class?+

Reason it through

What is the difference between equality, implication, and biconditional constraints?+

Reason it through

When does randomizing a parent object also randomize a nested object?+

Reason it through

How do you prove a small constraint system is satisfiable?+

Reason it through

SystemVerilog Arrays and collectionsConstrain shape before contents.

Array constraints build from shape to aggregate

How do you constrain a dynamic array's size and elements?+

Reason it through

Why can sum() produce a surprising constraint result?+

Reason it through

When should you use unique, randc, or shuffle()?+

Reason it through

What does sum() with (...) actually compute?+

Reason it through

How do you constrain one-hot, m-hot, or Hamming-distance patterns?+

Reason it through

How do you generate every ID from 0 through 255 without repeats, then reset?+

Reason it through

How do you constrain a 4 by 4 Latin square?+

Reason it through

How do you generate a constrained permutation instead of merely unique values?+

Reason it through