anchor.diff:              * the expected type is defined within lbs
               * *)
              let env0, topt = Env.clear_expected_typ env in
  -           let lbs, rec_env = build_let_rec_env true env0 lbs in
  +           let lbs, rec_env, g_t = build_let_rec_env true env0 lbs in
              (* now we type check each let rec *)
              let lbs, g_lbs = check_let_recs rec_env lbs in
  -           let g_lbs = Rel.solve_deferred_constraints env g_lbs |> Rel.resolve_implicits env in
  +           let g_lbs = Rel.conj_guard g_t g_lbs |> Rel.solve_deferred_constraints env |> Rel.resolve_implicits env in
   
              let all_lb_names = lbs |> List.map (fun lb -> right lb.lbname) |> Some in
   
  
positive.code:                                                                                 //adding universes here so that when we add the let binding, we can add a typescheme with these universes
                    else Env.push_let_binding env lb.lbname (univ_vars, t) in
          let lb = {lb with lbtyp=t; lbunivs=univ_vars; lbdef=e} in
          lb::lbs,  env)
      ([],env)
      lbs  in
    List.rev lbs, env
  
  and check_let_recs env lbs =
      let lbs, gs = lbs |> List.map (fun lb ->
  
negative.code: (*open*)  let lbs, e2 = SS.open_let_rec lbs e2 in
  
            let env0, topt = Env.clear_expected_typ env in
            let lbs, rec_env, g_t = build_let_rec_env false env0 lbs in
            let lbs, g_lbs = check_let_recs rec_env lbs |> (fun (lbs, g) -> lbs, Rel.conj_guard g_t g) in
  
            let env, lbs = lbs |> BU.fold_map (fun env lb ->
              let x = {left lb.lbname with sort=lb.lbtyp} in
  