anchor.diff:           (zdd-random-member lo)
            (cons var (zdd-random-member hi)))))))
   
  -(defun unit-patch (z)
  -  (ematch z
  -    ((sink t) z)
  +
  +(defun unit-patch (zdd)
  +  "Ensure the empty set is a member of `zdd`."
  +  (ematch zdd
  +    ((sink t) zdd)
       ((sink nil) (sink t))
       ((node variable hi lo)
        (zdd-node variable hi (unit-patch lo)))))
   
   
   (defun zdd-set (elements)
  +  "Return a ZDD with a single member (which contains `elements`)."
     (make-set elements))
   
   
  
positive.code:                                   (zdd-join% lo-a lo-b)))))))
  
  (defun zdd-join (&rest zdds)
    (if zdds
      (reduce #'zdd-join% zdds)
      (sink nil)))
  
negative.code:                                   (zdd-union% hi-a hi-b)
                                    (zdd-union% lo-a lo-b)))))))
  (defun zdd-union (&rest zdds)
    "Return the union of ZDDs: {α | α ∈ Z₁ or α ∈ Z₂}."
    (if zdds
      (reduce #'zdd-union% zdds)
      (sink nil)))
  