anchor.diff:        let _ = if Env.debug env <| Options.Other "RelCheck"
                 then let wl' = {wl with attempting=TProb eq_prob::sub_probs} in
                      BU.print1 "After meet/join refinements: %s\n" (wl_to_string wl') in
  +
  +      let tx = UF.new_transaction () in
         begin
         match solve_t env eq_prob ({wl with attempting=sub_probs}) with
         | Success _ ->
            let wl = {wl with attempting=rest} in
            let wl = solve_prob' false (TProb tp) None [] wl in
            let _ = List.fold_left (fun wl p -> solve_prob' true p None [] wl) wl bounds_probs in
  +         UF.commit tx;
            solve env wl
         | Failed (p, msg) ->
  -         giveup env ("failed to solve sub-problems: " ^msg) (TProb tp)
  +         UF.rollback tx;
  +         giveup env ("failed to solve sub-problems: " ^msg) p
         end
   
       | _ when flip -> failwith (BU.format1 "Impossible: Not a flex-rigid: %s" (prob_to_string env (TProb tp)))
  
positive.code:               | Some (t1, t2) -> SS.compress t1, SS.compress t2
                | None -> SS.compress t1, SS.compress t2
            in
            begin
            match t1, t2 with
            | {n=Tm_refine(x, phi1)}, {n=Tm_refine(y, phi2)} ->
              let p, wl = eq_prob x.sort y.sort wl in
              let x = freshen_bv x in
              let subst = [DB(0, x)] in
              let phi1 = SS.subst subst phi1 in
              let phi2 = SS.subst subst phi2 in
              (U.refine x (op phi1 phi2), [p], wl)
  
            | t, {n=Tm_refine(x, phi)}
            | {n=Tm_refine(x, phi)}, t ->
              let p, wl = eq_prob x.sort t wl in
              let x = freshen_bv x in
              let subst = [DB(0, x)] in
              let phi = SS.subst subst phi in
              (U.refine x (op U.t_true phi), [p], wl)
  
            | _ ->
              let p, wl = eq_prob t1 t2 wl in
              (t1, [p], wl)
            end
      in
      let rec aux (out, probs, wl) ts =
          match ts with
  
negative.code:         | Tm_refine(x, phi) ->
              if norm
              then (x.sort, Some(x, phi))
              else (match norm_refinement env t1 with
                   | {n=Tm_refine(x, phi)} -> (x.sort, Some(x, phi))
                   | tt -> failwith (BU.format2 "impossible: Got %s ... %s\n"
                                                 (Print.term_to_string tt)
                                                 (Print.tag_of_term tt))
                   )
  
          | Tm_lazy i -> aux norm (U.unfold_lazy i)
  
  