anchor.diff:      match implicits with
       | [] ->
         if not changed
  -      then let out, changed = try_solve_single_valued_implicits env out in
  +      then let out, changed = try_solve_single_valued_implicits env is_tac out in
              if changed then until_fixpoint ([], false) out
              else out
         else until_fixpoint ([], false) out
  
positive.code:  *   for inductives, this may later include implicits for pattern variables
   *)
   
  let try_solve_single_valued_implicits env (imps:Env.implicits) : Env.implicits * bool =
    (*
     * Get the value of the implicit imp
     * Going forward, it can also return new implicits for the pattern variables
     *   (cf. the comment above about extending it to inductives)
     *)
    let imp_value imp : option<term> =
      let ctx_u, r = imp.imp_uvar, imp.imp_range in
  
      let t_norm = N.normalize N.whnf_steps env ctx_u.ctx_uvar_typ in
      
      match (SS.compress t_norm).n with
      | Tm_fvar fv when S.fv_eq_lid fv Const.unit_lid ->
        r |> S.unit_const_with_range |> Some
      | Tm_refine (b, _) when U.is_unit b.sort ->
        r |> S.unit_const_with_range |> Some
      | _ -> None
  
    in
  
    let b = List.fold_left (fun b imp ->  //check that the imp is still unsolved
      if UF.find imp.imp_uvar.ctx_uvar_head |> is_none
      then match imp_value imp with
           | Some tm -> commit ([TERM (imp.imp_uvar, tm)]); true
           | None -> b
      else b) false imps in
  
    imps, b
    
  let resolve_implicits' env must_total forcelax g =
    let rec unresolved ctx_u =
      match (Unionfind.find ctx_u.ctx_uvar_head) with
      | Some r ->
  
negative.code:       else solve_t_flex_flex env (make_prob_eq orig) wl lhs rhs
  
      | EQ ->
        if should_defer_flex_to_user_tac env wl lhs || should_defer_flex_to_user_tac env wl rhs
        then defer_to_user_tac env orig (flex_reason lhs ^", "^flex_reason rhs)wl
        else
  
  