anchor.diff:                let lhs' = U.arrow bs c' in
                 let sol = TERM (u_lhs, U.abs bs_lhs lhs' (Some (U.residual_tot t_res_lhs))) in
                 let sub_prob, wl =
  -                  mk_t_problem wl (p_scope orig) orig lhs' EQ rhs None "arrow imitation" in
  +                  mk_t_problem wl (p_scope orig) orig lhs' rel arrow None "arrow imitation"
  +              in
                 //printfn "Arrow imitation: %s =?= %s" (Print.term_to_string lhs') (Print.term_to_string rhs);
                 solve env (attempt [sub_prob] (solve_prob orig None [sol] wl))
   
  
positive.code:     if Env.debug env <| Options.Other "RelCheck"
      then BU.print1 "solve:\n\t%s\n" (wl_to_string probs);
      match next_prob probs with
         | Some hd, tl, rank ->
           let probs = {probs with attempting=tl} in
           begin match hd with
              | CProb cp ->
                solve_c env (maybe_invert cp) probs
  
              | TProb tp ->
                if not probs.defer_ok
                && rank = flex_rigid
                then let tp = {tp with relation=EQ} in
                     solve_t' env tp probs
                //      match solve_flex_rigid_join env tp probs with
                //      | None -> solve_t' env (maybe_invert tp) probs //giveup env "join doesn't exist" hd
                //      | Some wl -> solve env wl
                else if not probs.defer_ok
                     && rigid_flex = rank
                then let tp = {tp with relation=EQ} in
                     solve_t' env tp probs
                     //match solve_rigid_flex_meet env tp probs with
                     // | None -> solve_t' env (maybe_invert tp) probs //giveup env "meet doesn't exist" hd
                     // | Some wl -> solve env wl
                else solve_t' env (maybe_invert tp) probs
           end
  
         | None, _, _ ->
           match probs.wl_deferred with
              | [] ->
                Success ([], probs.wl_implicits) //Yay ... done!
  
              | _ ->
                let attempt, rest = probs.wl_deferred |> List.partition (fun (c, _, _) -> c < probs.ctr) in
                match attempt with
                   | [] -> //can't solve yet; defer the rest
                     Success(List.map (fun (_, x, y) -> (x, y)) probs.wl_deferred, probs.wl_implicits)
  
                   | _ ->
                     solve env ({probs with attempting=attempt |> List.map (fun (_, _, y) -> y); wl_deferred=rest})
  
  and solve_one_universe_eq (env:Env.env) (orig:prob) (u1:universe) (u2:universe) (wl:worklist) : solution =
      match solve_universe_eq (p_pid orig) wl u1 u2 with
          | USolved wl ->
            solve env (solve_prob orig None [] wl)
  
          | UFailed msg ->
            giveup env msg orig
  
          | UDeferred wl ->
            solve env (defer "" orig wl)
  
  and solve_maybe_uinsts (env:Env.env) (orig:prob) (t1:term) (t2:term) (wl:worklist) : univ_eq_sol =
      let rec aux wl us1 us2 = match us1, us2 with
  
negative.code:     check_uvar_ctx_invariant reason r should_check gamma binders;
      let t = mk (Tm_uvar ctx_uvar) None r in
      ctx_uvar, t, {wl with wl_implicits=(reason, t, ctx_uvar, r, should_check)::wl.wl_implicits}
  
  let copy_uvar u t wl =
      new_uvar u.ctx_uvar_reason wl u.ctx_uvar_range u.ctx_uvar_gamma
               u.ctx_uvar_binders t u.ctx_uvar_should_check
  
  (* --------------------------------------------------------- *)
  (* </new_uvar>                                               *)
  