anchor.diff:      List.rev l, decls
   
   (* this assumes t is a Lemma *)
  -and encode_function_type_as_formula (induction_on:option<term>) (new_pats:option<S.term>) (t:typ) (env:env_t) : term * decls_t =
  +and encode_function_type_as_formula (t:typ) (env:env_t) : term * decls_t =
       let list_elements (e:S.term) : list<S.term> =
         match U.list_elements e with
         | Some l -> l
  
positive.code:         pats, decls) |> List.unzip in
  
      let decls' = List.flatten decls' in
  
      let pats =
        match induction_on with
        | None -> pats
        | Some e ->
          begin match vars with
            | [] -> pats
            | [l] -> pats |> List.map (fun p -> mk_Precedes (mkFreeV l) e::p)
            | _ ->
              let rec aux tl vars = match vars with
                | [] -> pats |> List.map (fun p -> mk_Precedes tl e::p)
                | (x, Term_sort)::vars -> aux (mk_LexCons (mkFreeV(x,Term_sort)) tl) vars
                | _ -> pats
              in
              aux (mkFreeV ("Prims.LexTop", Term_sort)) vars
          end
      in
  
      let env = {env with nolabels=true} in
      let pre, decls'' = encode_formula (U.unmeta pre) env in
  
negative.code:           let binders, c = SS.open_comp binders c in
            begin match c.n with
              | Comp ({effect_args=[(pre, _); (post, _); (pats, _)]}) ->
                binders, pre, post, lemma_pats pats
              | _ -> failwith "impos"
            end
  
  