           (when (and (integer? new) (not (neg? new)))
             (DSymbol. dim (max size new) s# v#)))
   (dsdisj [_ old]
-          (let [s-remove (fn [[i a]]
-                           [i (reduce dissoc a (concat old (map (s# i) old)))])
-                v-remove (fn [[i a]] [i (reduce dissoc a old)])
-                new-s# (into {} (map s-remove s#))
-                new-v# (into {} (map v-remove v#))]
-            (DSymbol. dim size new-s# new-v#)))
-  (dsglue [ds i D E]
+          (when (= old size)
+            (let [s-remove (fn [[i a]]
+                             [i (reduce dissoc a (concat old (map (s# i) old)))])
+                  v-remove (fn [[i a]] [i (reduce dissoc a old)])
+                  new-s# (into {} (map s-remove s#))
+                  new-v# (into {} (map v-remove v#))]
+              (DSymbol. dim (dec size) new-s# new-v#))))
+  (glue [ds i D E]
           (when (and (integer? i) (not (neg? i))
                      (integer? D) (pos? D)
                      (integer? E) (pos? E))

  (indices [ds] (iterator-seq (.indices ds)))
  (s [ds i D] (when (.definesOp ds i D) (.op ds i D)))
  (v [ds i j D] (when (.definesV ds i j D) (.v ds i j D))))

(deftype DSymbol [dim size s# v#]
  IDSymbol

                      (ops ds)
                      (vs ds))
                w))

(defn walk [ds D & idxs]
  "Returns the result of applying the D-symbol operators on ds with the
