The following definition and proof will also work for admitting 
fast-subset.  It uses the list primitives instead of the set 
primitives.  Upon reflection, this is a bad way to go, because 
the set primitives are already set up to use MBE and should be
just about as fast as the list primitives.  (Not entirely sure
how the details of the MBE system works with the compiler, so
maybe I am wrong here.)  Anyway, the proof is easier when we 
use the set primitives because we have more theory about them.

;(defun fast-subset (X Y)
;  (declare (xargs :guard (and (setp X) (setp Y))
;                  :verify-guards nil))
;  (cond ((endp X) t)
;        ((endp Y) nil)
;        ((<< (car X) (car Y)) nil)
;        ((equal (car X) (car Y)) (fast-subset (cdr X) (cdr Y)))
;        (t (fast-subset X (cdr Y)))))

;(defthmd fse-lemma-1
;  (implies (not (in (head Y) X))
;           (equal (subset X Y) (subset X (tail Y)))))

;(defthmd fast-subset-equivalence
;  (implies (and (setp X) (setp Y))
;           (equal (fast-subset X Y) (subset X Y)))
;  :hints(("Goal"
;          :in-theory (enable setp empty head tail sfix)
;          :induct (fast-subset X Y))
;         ("Subgoal *1/5"
;          :use (:instance fse-lemma-1 (X X) (Y Y)))
;         ("Subgoal *1/4.3"
;          :use (:instance fse-lemma-1 (X (cdr X)) (Y Y)))
;         ("Subgoal *1/4.2"
;          :use (:instance fse-lemma-1 (X (cdr X)) (Y Y)))))

;(verify-guards subset
;  :hints(("Goal" :in-theory (enable fast-subset-equivalence))))


Similarly, you can use a "fast insert" and MBE it in, if you want.
But, it doesn't seem to be any faster, so I have gone ahead and 
left it out.  The only difference is that it does a full check using
equal to try to avoid using <<, which might be slow.

;(defun aux-insert-1 (a X)               ; same as in
;  (declare (xargs :guard (setp X)))
;  (and (not (endp X))
;       (or (equal a (car X))
;           (aux-insert-1 a (cdr X)))))
;(defun aux-insert-2 (a X)               ; insert without equality
checks
;  (declare (xargs :guard (setp X)))
;  (cond ((endp X) (cons a X))
;        ((<< a (car X)) (cons a X))
;        (t (cons (car X) (aux-insert-2 a (cdr X))))))
;(defun fast-insert (a X)                ; do all equality checking
first
;  (declare (xargs :guard (setp X)))
;  (if (aux-insert-1 a X)
;      X
;    (aux-insert-2 a X)))


