anchor.diff:  
         machi_partition_simulator:reset_thresholds(10, 50),
         io:format(user, "\nLet loose the dogs of war!\n", []),
  +      %% machi_partition_simulator:always_these_partitions([]),
  +      %% io:format(user, "\nPuppies for everyone!\n", []),
         [DoIt(30, 0, 0) || _ <- lists:seq(1,2)],
         AllPs = make_partition_list(All_list),
         PartitionCounts = lists:zip(AllPs, lists:seq(1, length(AllPs))),
  
positive.code: 
  get_latest_inner_proj_summ(FLU) ->
      {ok, Proj} = ?FLU_PC:read_latest_projection(FLU, private),
      #projection_v1{epoch_number=E, upi=UPI, repairing=Repairing, down=Down} =
          machi_chain_manager1:inner_projection_or_self(Proj),
      Inner_p = machi_chain_manager1:inner_projection_exists(Proj),
      {E, UPI, Repairing, Down, Inner_p}.
  
  random_sort(L) ->
      random:seed(now()),
  
negative.code:     %%
      FLUs = [FLU || {FLU,_Pid} <- Namez],
      U_UPI_Rs = lists:usort([UPI++Rep ||
                               {_Nm,{_Epoch,UPI,Rep,_Dn,_W,InnerP}} <- Private2]),
      FLU_uses = [{Name, Epoch} ||
                     {Name,{Epoch,_UPI,Rep,_Dn,_W,InnerP}} <- Private2],
      Witnesses = hd([Ws ||
                     {_Name,{_Epoch,_UPI,Rep,_Dn,Ws,InnerP}} <- Private2]),
      HaveWitnesses_p = Witnesses /= [],
      Unanimous_with_all_peers_p =
          lists:all(fun({FLU, UsesEpoch}) ->
                     WhoInEpoch = [Name ||
                                    {Name,{Epoch,_UPI,_Rep,_Dn,_W,I_}}<-Private2,
                                    Epoch == UsesEpoch],
                     UPI_versions = [UPI ||
                                 {_Name,{Epoch,UPI,_Rep,_Dn,_W,I_}}<-Private2,
                                 Epoch == UsesEpoch],
                     UPI_versions == [ [] ] % This FLU in minority partition
                     orelse
                     (length(lists:usort(UPI_versions)) == 1
                      andalso
                      (lists:sort(hd(UPI_versions)) == lists:sort(WhoInEpoch)
                       orelse
                       (HaveWitnesses_p andalso
                        lists:sort(hd(UPI_versions)) == lists:sort(WhoInEpoch--Witnesses))))
                    end, FLU_uses),
      %% io:format(user, "\nPriv1 ~P agree ~p\n", [lists:sort(Private1), 10, Unanimous_with_all_peers_p]),
  
      %%io:format(user, "U_UPI_Rs ~p\n", [U_UPI_Rs]),
      %%io:format(user, "FLUs ~p\n", [FLUs]),
      %%io:format(user, "Unanimous_with_all_peers_p ~p\n", [Unanimous_with_all_peers_p]),
      Flat_U_UPI_Rs = lists:flatten(U_UPI_Rs),
      Private1 == Private2 andalso
          %% If not disjoint, then a flu will appear twice in flattented U_UPIs.
          lists:sort(Flat_U_UPI_Rs) == lists:usort(Flat_U_UPI_Rs) andalso
          %% Another property that we want is that for each participant
          %% X mentioned in a UPI or Repairing list of some epoch E that
          %% X is using the same epoch E.
  