失败分类、轨迹诊断与反事实实验

import java.util.*;
public class Main {
    static void near(double expected,double actual) {
        if (!Double.isFinite(actual) || Math.abs(expected-actual)>1e-9*Math.max(1,Math.abs(expected)))
            throw new AssertionError(expected+" != "+actual);
    }
    static void check(boolean ok) { if(!ok) throw new AssertionError(); }
    static void bad(Runnable r) {
        try { r.run(); } catch(IllegalArgumentException e) { return; }
        throw new AssertionError("invalid input accepted");
    }
static List<Integer> minimize(List<Integer> input,java.util.function.Predicate<List<Integer>> fails) {
        if(input==null||fails==null||input.stream().anyMatch(Objects::isNull)||new HashSet<>(input).size()!=input.size()) throw new IllegalArgumentException("events");
        List<Integer> current=List.copyOf(input);
        if(!fails.test(current)) throw new IllegalArgumentException("not failing");
        if(fails.test(List.of())) return List.of(); // 空输入也失败时，已无需保留任何事件。
        int granularity=2;
        while(current.size()>=2) {
            int size=current.size(),chunk=(size+granularity-1)/granularity;boolean reduced=false;
            for(int start=0;start<size;start+=chunk) {
                int end=Math.min(size,start+chunk);List<Integer> candidate=new ArrayList<>(size-(end-start));
                candidate.addAll(current.subList(0,start));candidate.addAll(current.subList(end,size)); // 删除连续分块，同时保持其余事件顺序。
                if(fails.test(List.copyOf(candidate))) {
                    current=List.copyOf(candidate);granularity=Math.max(2,granularity-1);reduced=true;break;
                }
            }
            if(!reduced) {
                if(granularity==current.size()) break; // 单个事件删除均不能保留失败，得到一项最小而非全局最小。
                granularity=Math.min(current.size(),granularity*2);
            }
        }
        return current;
    }
    public static void main(String[] args) {
java.util.function.Predicate<List<Integer>> pair=x->x.contains(2)&&x.contains(5);
        check(minimize(List.of(1,2,3,4,5,6),pair).equals(List.of(2,5)));
        check(minimize(List.of(1,7,3),x->x.contains(7)).equals(List.of(7)));
        check(minimize(List.of(1,2),x->true).isEmpty());
        bad(()->minimize(List.of(1),x->false));
        java.util.function.Predicate<List<Integer>> nonmonotone=x->x.equals(List.of(1,2))||(x.contains(4)&&x.contains(5)&&x.contains(6));
        List<Integer> local=minimize(List.of(1,2,3,4,5,6),nonmonotone);
        check(local.equals(List.of(4,5,6))&&nonmonotone.test(List.of(1,2)));
        bad(()->minimize(List.of(),x->false));
        bad(()->minimize(List.of(1,1),x->true));
        check(minimize(List.of(5,2),pair).equals(List.of(5,2)));
        System.out.println("PASS 8 cases");
    }
}