anchor.diff:          let fml = List.fold_right (fun (b:binder) (t:term) -> mk_Tm_app tforall [ S.as_arg (U.abs [b] (SS.close [b] t) None) ] None dr) ibs fml in
           //fold right with bs, close and add a forall b
           let fml = List.fold_right (fun (b:binder) (t:term) -> mk_Tm_app tforall [ S.as_arg (U.abs [b] (SS.close [b] t) None) ] None dr) bs fml in
  -        //so now this is the haseq formula we want to generate, TODO: make it a Sig_assume, and generalize universe variables
  +        //so now this is the haseq formula we want to generate, TODO: make it a Sig_assume, and generalize universe variables, TODO: how to add pattern in this forall
   
           //this is the soundness guard
           let guard = U.mk_conj (U.mk_conj haseq_bs haseq_ind) fml in
  
positive.code:     //tcs is the list of type constructors, datas is the list of data constructors
  
      //this is the folding function for tcs
      //list<term> is the list of haseq axioms we are accumulating
      //env is the environment in which the next two terms are well-formed
      //term is the lhs of the implication for soundness
      //term is the soundness condition derived from all the data constructors of this type
      let haseq_ty (acc:(list<term> * env * term * term)) (ty:sigelt) :list<term> * env * term * term =
          let lid, bs, t, d_lids =
              match ty with
                  | Sig_inductive_typ (lid, _, bs, t, _, d_lids, _, _) -> lid, bs, t, d_lids
  
negative.code:         failwith (Util.format1 "Unexpected lex_t: %s\n" (Print.sigelt_to_string (Sig_bundle(ses, [], lids, Range.dummyRange))))
      end
  
  let tc_assume (env:env) (lid:lident) (phi:formula) (quals:list<qualifier>) (r:Range.range) :sigelt =
      let env = Env.set_range env r in
      let k, _ = U.type_u() in
      let phi = tc_check_trivial_guard env phi k |> norm env in
      TcUtil.check_uvars r phi;
      Sig_assume(lid, phi, quals, r)
  
  let tc_inductive env ses quals lids =
      (*  Consider this illustrative example:
  
  