anchor.diff:      in
       // A very F*-specific optimization:
       //  1)                        (p ==> E[p])     ~>     E[True]
  -    //  2)  (forall j1 j2 ... jn. p j1 j2 ... jn) ==> E[p]    ~>    E[(fun j1 j2 ... jn -> True)]
  -    let is_quantified_true (phi : term) : option<term> =
  +    //  2)                       (~p ==> E[p])     ~>     E[False]
  +    //  3)  (forall j1 j2 ... jn. p j1 j2 ... jn)    ==> E[p]    ~>    E[(fun j1 j2 ... jn -> True)]
  +    //  4)  (forall j1 j2 ... jn. ~(p j1 j2 ... jn)) ==> E[p]    ~>    E[(fun j1 j2 ... jn -> False)]
  +    let is_quantified_const (phi : term) : option<term> =
           match U.destruct_typ_as_formula phi with
           | Some (BaseConn (lid, [(p, _); (q, _)])) when Ident.lid_equals lid PC.imp_lid ->
               begin match U.destruct_typ_as_formula p with
  
positive.code:                       end
  
              // Case 2)
              | Some (QAll (bs, pats, phi)) ->
                  begin match is_applied_maybe_squashed bs phi with
                  | Some bv ->
                      let ftrue = U.abs bs U.t_true (Some (U.residual_tot U.ktype0)) in
                      Some (SS.subst [NT (bv, ftrue)] q)
                  | None ->
                      None
                  end
  
  
negative.code:         | _ -> false
      in
      let simplify arg = (simp_t (fst arg), arg) in
      match is_quantified_const tm with
      (* We need to recurse, and maybe reduce further! *)
      | Some tm -> maybe_simplify_aux cfg env stack (norm cfg env [] tm)
      (* Otherwise try to simplify this point *)
  