AFTD Auto-Formalizing Theoretical Domains

round_robin_five_item_spe_not_nel

theoremverified

For two agents with identical item values 16, 8, 4, 2 and 1 and the round-robin order 0,1,0,1,0, there is a subgame-perfect continuation profile whose first agent receives items 0,2,4 and whose allocation fails NEL under pairwise dominance.

Statement

theorem round_robin_five_item_spe_not_nel :
  ∃ F : List (Fin 5) → Finset (Fin 5),
    pick_game_is_spe (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ)) [0, 1, 0, 1, 0] F ∧
    F [] = {0, 2, 4} ∧
    ¬ is_nel_pd (fun (_ : Fin 2) (x y : Fin 5) => (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x ≤ (![16, 8, 4, 2, 1] : Fin 5 → ℝ) y) (pick_game_root_allocation F)
Source
The round-robin interpretation of OP-1323, arXiv:2611.09685 Section 7; finite search experiment 20540.
Verified
10 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 5
  • pick_game_is_speAn outcome-continuation function is subgame-perfect for a fixed finite two-agent picking order if, after every duplicate-free history, its…
  • pick_game_root_allocationThe root allocation from the continuation assigns its root bundle to agent 0 and all remaining objects to agent 1.
  • is_nel_pdAn allocation A : Agent → Finset Object satisfies NEL under pairwise dominance with respect to item preferences le : Agent → Object →…
  • pick_game_move_payoffThe mover’s additive payoff from the current remaining objects if the specified item is chosen, followed by the given continuations: agent…
  • pick_game_move_zeroFor a history and a legal next choice, the resulting agent-0 continuation bundle consists of the selected object together with the…

The proof, explained

The proof constructs a subgame-perfect continuation profile for two agents taking turns in round-robin order [0, 1, 0, 1, 0] by defining a greedy strategy that always selects the available item with the smallest index (and largest value). Because the item values (16, 8, 4, 2, 1) are strictly super-increasing in reverse, greedy choice is strictly dominant at every subgame, which is verified for all 32 item subsets by finite computation. At the root of the game, this equilibrium allocates items {0, 2, 4} to agent 0 and {1, 3} to agent 1. Removing item 4 from agent 0's bundle leaves items {0, 2}, which cannot be pairwise dominated by {1, 3} since item 0 (value 16) strictly exceeds both items 1 and 3 (values 8 and 2), violating NEL under pairwise dominance.

  1. For every subset of available items, the greedy continuation strategy chooses a weakly optimal item for the active agent. automation

    Because there are only 5 items in total, there are 2⁵ = 32 possible subsets R of remaining items. For each subset, the greedy policy picks the item with minimal index. Since the utilities (16, 8, 4, 2, 1) decrease strictly faster than powers of 2, greedy choice is always weakly optimal. In Lean, this universal property over all 32 subsets is verified by finite computation via the decide tactic.

    lines 55–63

    theorem round_robin_five_item_spe_for_all_R : ∀ R : Finset (Fin 5),
        round_robin_five_item_G_finset R ⊆ R ∧
        if R.Nonempty then
          ∃ x ∈ R, round_robin_five_item_G_finset R = round_robin_five_item_move_zero_finset R x ∧
            ∀ y ∈ R, round_robin_five_item_payoff_nat R y ≤ round_robin_five_item_payoff_nat R x
        else
          round_robin_five_item_G_finset R = ∅ := by
      decide
    
  2. Duplicate-free game histories correspond to remaining item subsets, and the game transition coincides with set-theoretic item removal.

    For any history h of distinct items, its length is 5 - |R| where R = univ \ h.toFinset, proved using set difference cardinality (Finset.card_sdiff_of_subset), universal set bounds (Finset.subset_univ, Finset.card_le_univ), and duplicate-free list properties (List.toFinset_card_of_nodup). Appending a move x to h corresponds to erasing x from R (round_robin_five_item_rem_erase_eq). Consequently, the abstract game transition pick_game_move_zero is shown to equal the set-theoretic move function round_robin_five_item_move_zero_finset.

    lines 64–87

    uses Finset.card_sdiff_of_subset, Finset.subset_univ, List.toFinset_card_of_nodup, Finset.card_le_univ, round_robin_five_item_h_len_eq, round_robin_five_item_rem_erase_eq

    lemma round_robin_five_item_h_len_eq {h : List (Fin 5)} (hnodup : h.Nodup) :
        h.length = 5 - (Finset.univ \ h.toFinset : Finset (Fin 5)).card := by
      have h1 : (Finset.univ \ h.toFinset : Finset (Fin 5)).card = 5 - h.toFinset.card := by
        rw [Finset.card_sdiff_of_subset (Finset.subset_univ _)]
        simp
      have h2 : h.toFinset.card = h.length := List.toFinset_card_of_nodup hnodup
      have h3 : h.length ≤ 5 := by
        rw [← h2]
        exact Finset.card_le_univ h.toFinset
      omega
    
    lemma round_robin_five_item_rem_erase_eq {h : List (Fin 5)} {x : Fin 5}
        (_hx : x ∈ Finset.univ \ h.toFinset) :
        Finset.univ \ (h ++ [x]).toFinset = (Finset.univ \ h.toFinset).erase x := by
      ext y
      simp
    
    lemma round_robin_five_item_move_zero_eq {h : List (Fin 5)} (hnodup : h.Nodup) {x : Fin 5}
        (hx : x ∈ Finset.univ \ h.toFinset) :
        pick_game_move_zero [0, 1, 0, 1, 0] round_robin_five_item_F_alloc h x =
        round_robin_five_item_move_zero_finset (Finset.univ \ h.toFinset) x := by
      dsimp [pick_game_move_zero, round_robin_five_item_move_zero_finset, round_robin_five_item_F_alloc]
      rw [round_robin_five_item_h_len_eq hnodup, round_robin_five_item_rem_erase_eq hx]
    
  3. The real-valued game payoff for choosing an item equals the integer payoff computed on the remaining item subset.

    By exhaustive case analysis over the five items, the real-valued utility vector is shown to equal the integer utility vector (round_robin_five_item_u_val_eq). Using the history length formula (round_robin_five_item_h_len_eq) and move equivalence (round_robin_five_item_move_zero_eq), the definition of pick_game_move_payoff unfolds to a sum over the set of received items, which matches the integer payoff function round_robin_five_item_payoff_nat via congruence of finite sums (Finset.sum_congr).

    lines 88–101

    uses round_robin_five_item_u_val_eq, round_robin_five_item_h_len_eq, round_robin_five_item_move_zero_eq, Finset.sum_congr

    lemma round_robin_five_item_u_val_eq (x : Fin 5) :
        (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x = (round_robin_five_item_u_nat x : ℝ) := by
      fin_cases x <;> simp [round_robin_five_item_u_nat]
    
    lemma round_robin_five_item_payoff_eq {h : List (Fin 5)} (hnodup : h.Nodup) {x : Fin 5}
        (hx : x ∈ Finset.univ \ h.toFinset) :
        pick_game_move_payoff (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ))
          [0, 1, 0, 1, 0] round_robin_five_item_F_alloc h x =
        (round_robin_five_item_payoff_nat (Finset.univ \ h.toFinset) x : ℝ) := by
      dsimp [pick_game_move_payoff, round_robin_five_item_payoff_nat]
      rw [round_robin_five_item_h_len_eq hnodup, round_robin_five_item_move_zero_eq hnodup hx]
      push_cast
      exact Finset.sum_congr rfl (fun z _ => round_robin_five_item_u_val_eq z)
    
  4. The greedy continuation allocation profile is a subgame-perfect equilibrium of the picking game.

    To prove pick_game_is_spe, the round-robin schedule [0, 1, 0, 1, 0] first matches the total number of items 5. Then, for any duplicate-free history h with remaining items R, the greedy allocation satisfies F(h) ⊆ R. When R is nonempty, the exhaustive verification lemma (round_robin_five_item_spe_for_all_R) provides an optimal item x ∈ R. Using move equivalence (round_robin_five_item_move_zero_eq), the allocation matches the move transition at x, and using payoff equivalence (round_robin_five_item_payoff_eq together with Nat.cast_le.mpr), x maximizes the active agent's payoff over all available choices y ∈ R. When R is empty, F(h) = ∅.

    lines 102–123

    uses round_robin_five_item_spe_for_all_R, if_pos, round_robin_five_item_move_zero_eq, round_robin_five_item_payoff_eq, Nat.cast_le.mpr, if_neg

    lemma round_robin_five_item_is_spe :
        pick_game_is_spe (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ))
          [0, 1, 0, 1, 0] round_robin_five_item_F_alloc := by
      constructor
      · rfl
      · intro h hnodup
        let R := Finset.univ \ h.toFinset
        have hR := round_robin_five_item_spe_for_all_R R
        obtain ⟨hsub, hif⟩ := hR
        refine ⟨hsub, ?_⟩
        by_cases hne : R.Nonempty
        · rw [if_pos hne] at hif ⊢
          obtain ⟨x, hx, heq, hopt⟩ := hif
          refine ⟨x, hx, ?_, ?_⟩
          · change round_robin_five_item_G_finset R = _
            rw [heq, ← round_robin_five_item_move_zero_eq hnodup hx]
          · intro y hy
            rw [round_robin_five_item_payoff_eq hnodup hy, round_robin_five_item_payoff_eq hnodup hx]
            exact Nat.cast_le.mpr (hopt y hy)
        · rw [if_neg hne] at hif ⊢
          exact hif
    
  5. At the empty history, the equilibrium allocates items 0, 2, and 4 to agent 0. automation

    Evaluating the continuation allocation at the empty history [] is verified directly by computational evaluation (decide), returning the set {0, 2, 4}.

    lines 124–127

    lemma round_robin_five_item_hFroot :
        round_robin_five_item_F_alloc [] = {0, 2, 4} := by
      decide
    
  6. If the allocation satisfied NEL-PD, removing item 4 would require a dominating injection from {0, 2} into {1, 3}.

    Suppose for contradiction that the root allocation satisfies NEL under pairwise dominance (is_nel_pd). From the root allocation result (round_robin_five_item_hFroot), agent 0 receives A₀ = {0, 2, 4} and agent 1 receives A₁ = {1, 3}. Since |A₁| = 2 < 3 = |A₀|, NEL-PD applied with item y = 4 ∈ A₀ yields an injection f : A₀ \ {4} → A₁ such that agent 1 weakly prefers f(z) to z for every z ∈ A₀ \ {4} = {0, 2}.

    lines 128–142

    uses round_robin_five_item_hFroot

    lemma round_robin_five_item_not_nel :
        ¬ is_nel_pd (fun (_ : Fin 2) (x y : Fin 5) => (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x ≤ (![16, 8, 4, 2, 1] : Fin 5 → ℝ) y)
          (pick_game_root_allocation round_robin_five_item_F_alloc) := by
      intro h
      have hA0 : pick_game_root_allocation round_robin_five_item_F_alloc 0 = {0, 2, 4} := by
        simp [pick_game_root_allocation, round_robin_five_item_hFroot]
      have hA1 : pick_game_root_allocation round_robin_five_item_F_alloc 1 = {1, 3} := by
        simp [pick_game_root_allocation, round_robin_five_item_hFroot]
        ext x; fin_cases x <;> decide
      have hlt : (pick_game_root_allocation round_robin_five_item_F_alloc 1).card <
          (pick_game_root_allocation round_robin_five_item_F_alloc 0).card := by
        rw [hA0, hA1]; decide
      have hy : (4 : Fin 5) ∈ pick_game_root_allocation round_robin_five_item_F_alloc 0 := by
        rw [hA0]; simp
      obtain ⟨f, hfA, -, hpref⟩ := h 1 0 hlt 4 hy
  7. The injection condition leads to an arithmetic contradiction, establishing that NEL-PD fails and concluding the theorem.

    Since 0 ∈ {0, 2}, its image f(0) must belong to A₁ = {1, 3}, meaning f(0) = 1 or f(0) = 3 by set membership lemmas (Finset.mem_insert, Finset.mem_singleton). By the pairwise dominance condition, agent 1 must satisfy u₁(0) ≤ u₁(f(0)). If f(0) = 1, this requires 16 ≤ 8; if f(0) = 3, this requires 16 ≤ 2. Both inequalities are impossible by linear arithmetic (linarith), proving that NEL-PD fails (round_robin_five_item_not_nel). Finally, bundling the strategy profile round_robin_five_item_F_alloc, the SPE proof (round_robin_five_item_is_spe), the root allocation (round_robin_five_item_hFroot), and this non-NEL result completes the proof of round_robin_five_item_spe_not_nel.

    lines 143–163

    uses Finset.mem_insert, Finset.mem_singleton, round_robin_five_item_not_nel, round_robin_five_item_is_spe, round_robin_five_item_hFroot

      have h0 : (0 : Fin 5) ∈ (pick_game_root_allocation round_robin_five_item_F_alloc 0).erase 4 := by
        rw [hA0]; simp
      have hf0 : f 0 ∈ pick_game_root_allocation round_robin_five_item_F_alloc 1 := hfA 0 h0
      rw [hA1] at hf0
      have hpref0 := hpref 0 h0
      simp only [Finset.mem_insert, Finset.mem_singleton] at hf0
      rcases hf0 with hf0 | hf0
      · rw [hf0] at hpref0
        have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 0 = 16 := by rfl
        have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 1 = 8 := by rfl
        linarith
      · rw [hf0] at hpref0
        have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 0 = 16 := by rfl
        have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 3 = 2 := by rfl
        linarith
    
    theorem round_robin_five_item_spe_not_nel :
      ∃ F : List (Fin 5) → Finset (Fin 5),
        pick_game_is_spe (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ)) [0, 1, 0, 1, 0] F ∧
        F [] = {0, 2, 4} ∧
        ¬ is_nel_pd (fun (_ : Fin 2) (x y : Fin 5) => (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x ≤ (![16, 8, 4, 2, 1] : Fin 5 → ℝ) y) (pick_game_root_allocation F) := ⟨round_robin_five_item_F_alloc, round_robin_five_item_is_spe, round_robin_five_item_hFroot, round_robin_five_item_not_nel⟩
Finset.card_sdiff_of_subset
For a subset s ⊆ t of a finite set, the cardinality of the difference t \ s equals |t| - |s|.
Finset.card_le_univ
The cardinality of any finite subset is at most the cardinality of the universal set of the ambient finite type.
Finset.mem_insert
An element belongs to insert b s if and only if it equals b or belongs to s.
Finset.mem_singleton
An element belongs to the singleton set {a} if and only if it equals a.
Finset.subset_univ
Every finite set of elements from a finite type is a subset of the universal set.
Finset.sum_congr
If two finite sets are equal and two summands agree on every element, their sums are equal.
if_neg
An if-then-else expression evaluates to its else branch when the condition is false.
if_pos
An if-then-else expression evaluates to its then branch when the condition is true.
List.toFinset_card_of_nodup
For a list with no duplicate elements, the cardinality of its set of elements equals its length.
Nat.cast_le.mpr
An inequality m ≤ n between natural numbers implies the corresponding inequality between their real embeddings.
round_robin_five_item_hFroot
The greedy continuation allocation at the empty history assigns items 0, 2, and 4 to agent 0.
round_robin_five_item_h_len_eq
For any duplicate-free picking history h, the length of h equals 5 minus the number of remaining items.
round_robin_five_item_is_spe
The greedy continuation profile is a subgame-perfect equilibrium of the picking game.
round_robin_five_item_move_zero_eq
The game transition function pick_game_move_zero on history h and choice x equals the set-based move function on the remaining items and x.
round_robin_five_item_not_nel
The root allocation produced by the greedy continuation profile fails the condition of no envy of a larger bundle under pairwise dominance.
round_robin_five_item_payoff_eq
The real game payoff from choosing item x after history h equals the integer payoff on the remaining items, cast to the real numbers.
round_robin_five_item_rem_erase_eq
Appending an unchosen item x to history h corresponds to erasing x from the set of remaining items.
round_robin_five_item_spe_for_all_R
For every remaining set of items R, the greedy allocation is contained in R, and if R is nonempty, there is an item in R whose choice reproduces the allocation and maximizes the natural-number payoff among all available choices.
round_robin_five_item_u_val_eq
The real utility of item x equals the integer utility of x cast to the real numbers.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

open Finsetdef round_robin_five_item_u_nat : Fin 5 → ℕ := ![16, 8, 4, 2, 1]def round_robin_five_item_count_true (b : Fin 5 → Bool) : Nat :=  ((List.finRange 5).filter b).lengthdef round_robin_five_item_min_true (b : Fin 5 → Bool) : Option (Fin 5) :=  ((List.finRange 5).filter b).head?def round_robin_five_item_s_picker (step : Nat) : Fin 2 :=  if step = 0 then 0  else if step = 1 then 1  else if step = 2 then 0  else if step = 3 then 1  else 0def round_robin_five_item_b_erase (b : Fin 5 → Bool) (x : Fin 5) : Fin 5 → Bool :=  fun y => if y = x then false else b ydef round_robin_five_item_g_fuel : Nat → (Fin 5 → Bool) → (Fin 5 → Bool)| 0, _ => fun _ => false| fuel + 1, b =>  match round_robin_five_item_min_true b with  | none => fun _ => false  | some m =>    let b' := round_robin_five_item_b_erase b m    let rest := round_robin_five_item_g_fuel fuel b'    let step := 5 - round_robin_five_item_count_true b    if round_robin_five_item_s_picker step = 0 then      fun x => if x = m then true else rest x    else      restdef round_robin_five_item_g_alloc (b : Fin 5 → Bool) : Fin 5 → Bool :=  round_robin_five_item_g_fuel 5 bdef round_robin_five_item_G_finset (R : Finset (Fin 5)) : Finset (Fin 5) :=  Finset.filter (fun x => round_robin_five_item_g_alloc (fun y => decide (y ∈ R)) x) Finset.univdef round_robin_five_item_F_alloc (h : List (Fin 5)) : Finset (Fin 5) :=  round_robin_five_item_G_finset (Finset.univ \ h.toFinset)def round_robin_five_item_move_zero_finset (R : Finset (Fin 5)) (x : Fin 5) : Finset (Fin 5) :=  if ([0, 1, 0, 1, 0] : List (Fin 2)).getD (5 - R.card) 0 = 0 then    insert x (round_robin_five_item_G_finset (R.erase x))  else    round_robin_five_item_G_finset (R.erase x)def round_robin_five_item_payoff_nat (R : Finset (Fin 5)) (x : Fin 5) : ℕ :=  let p := ([0, 1, 0, 1, 0] : List (Fin 2)).getD (5 - R.card) 0  let A := round_robin_five_item_move_zero_finset R x  ∑ z ∈ (if p = 0 then A else R \ A), round_robin_five_item_u_nat ztheorem round_robin_five_item_spe_for_all_R : ∀ R : Finset (Fin 5),    round_robin_five_item_G_finset R ⊆ R ∧    if R.Nonempty then      ∃ x ∈ R, round_robin_five_item_G_finset R = round_robin_five_item_move_zero_finset R x ∧        ∀ y ∈ R, round_robin_five_item_payoff_nat R y ≤ round_robin_five_item_payoff_nat R x    else      round_robin_five_item_G_finset R = ∅ := by  decidelemma round_robin_five_item_h_len_eq {h : List (Fin 5)} (hnodup : h.Nodup) :    h.length = 5 - (Finset.univ \ h.toFinset : Finset (Fin 5)).card := by  have h1 : (Finset.univ \ h.toFinset : Finset (Fin 5)).card = 5 - h.toFinset.card := by    rw [Finset.card_sdiff_of_subset (Finset.subset_univ _)]    simp  have h2 : h.toFinset.card = h.length := List.toFinset_card_of_nodup hnodup  have h3 : h.length ≤ 5 := by    rw [← h2]    exact Finset.card_le_univ h.toFinset  omegalemma round_robin_five_item_rem_erase_eq {h : List (Fin 5)} {x : Fin 5}    (_hx : x ∈ Finset.univ \ h.toFinset) :    Finset.univ \ (h ++ [x]).toFinset = (Finset.univ \ h.toFinset).erase x := by  ext y  simplemma round_robin_five_item_move_zero_eq {h : List (Fin 5)} (hnodup : h.Nodup) {x : Fin 5}    (hx : x ∈ Finset.univ \ h.toFinset) :    pick_game_move_zero [0, 1, 0, 1, 0] round_robin_five_item_F_alloc h x =    round_robin_five_item_move_zero_finset (Finset.univ \ h.toFinset) x := by  dsimp [pick_game_move_zero, round_robin_five_item_move_zero_finset, round_robin_five_item_F_alloc]  rw [round_robin_five_item_h_len_eq hnodup, round_robin_five_item_rem_erase_eq hx]lemma round_robin_five_item_u_val_eq (x : Fin 5) :    (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x = (round_robin_five_item_u_nat x : ℝ) := by  fin_cases x <;> simp [round_robin_five_item_u_nat]lemma round_robin_five_item_payoff_eq {h : List (Fin 5)} (hnodup : h.Nodup) {x : Fin 5}    (hx : x ∈ Finset.univ \ h.toFinset) :    pick_game_move_payoff (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ))      [0, 1, 0, 1, 0] round_robin_five_item_F_alloc h x =    (round_robin_five_item_payoff_nat (Finset.univ \ h.toFinset) x : ℝ) := by  dsimp [pick_game_move_payoff, round_robin_five_item_payoff_nat]  rw [round_robin_five_item_h_len_eq hnodup, round_robin_five_item_move_zero_eq hnodup hx]  push_cast  exact Finset.sum_congr rfl (fun z _ => round_robin_five_item_u_val_eq z)lemma round_robin_five_item_is_spe :    pick_game_is_spe (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ))      [0, 1, 0, 1, 0] round_robin_five_item_F_alloc := by  constructor  · rfl  · intro h hnodup    let R := Finset.univ \ h.toFinset    have hR := round_robin_five_item_spe_for_all_R R    obtain ⟨hsub, hif⟩ := hR    refine ⟨hsub, ?_⟩    by_cases hne : R.Nonempty    · rw [if_pos hne] at hif ⊢      obtain ⟨x, hx, heq, hopt⟩ := hif      refine ⟨x, hx, ?_, ?_⟩      · change round_robin_five_item_G_finset R = _        rw [heq, ← round_robin_five_item_move_zero_eq hnodup hx]      · intro y hy        rw [round_robin_five_item_payoff_eq hnodup hy, round_robin_five_item_payoff_eq hnodup hx]        exact Nat.cast_le.mpr (hopt y hy)    · rw [if_neg hne] at hif ⊢      exact hiflemma round_robin_five_item_hFroot :    round_robin_five_item_F_alloc [] = {0, 2, 4} := by  decidelemma round_robin_five_item_not_nel :    ¬ is_nel_pd (fun (_ : Fin 2) (x y : Fin 5) => (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x ≤ (![16, 8, 4, 2, 1] : Fin 5 → ℝ) y)      (pick_game_root_allocation round_robin_five_item_F_alloc) := by  intro h  have hA0 : pick_game_root_allocation round_robin_five_item_F_alloc 0 = {0, 2, 4} := by    simp [pick_game_root_allocation, round_robin_five_item_hFroot]  have hA1 : pick_game_root_allocation round_robin_five_item_F_alloc 1 = {1, 3} := by    simp [pick_game_root_allocation, round_robin_five_item_hFroot]    ext x; fin_cases x <;> decide  have hlt : (pick_game_root_allocation round_robin_five_item_F_alloc 1).card <      (pick_game_root_allocation round_robin_five_item_F_alloc 0).card := by    rw [hA0, hA1]; decide  have hy : (4 : Fin 5) ∈ pick_game_root_allocation round_robin_five_item_F_alloc 0 := by    rw [hA0]; simp  obtain ⟨f, hfA, -, hpref⟩ := h 1 0 hlt 4 hy  have h0 : (0 : Fin 5) ∈ (pick_game_root_allocation round_robin_five_item_F_alloc 0).erase 4 := by    rw [hA0]; simp  have hf0 : f 0 ∈ pick_game_root_allocation round_robin_five_item_F_alloc 1 := hfA 0 h0  rw [hA1] at hf0  have hpref0 := hpref 0 h0  simp only [Finset.mem_insert, Finset.mem_singleton] at hf0  rcases hf0 with hf0 | hf0  · rw [hf0] at hpref0    have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 0 = 16 := by rfl    have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 1 = 8 := by rfl    linarith  · rw [hf0] at hpref0    have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 0 = 16 := by rfl    have : (![16, 8, 4, 2, 1] : Fin 5 → ℝ) 3 = 2 := by rfl    linariththeorem round_robin_five_item_spe_not_nel :  ∃ F : List (Fin 5) → Finset (Fin 5),    pick_game_is_spe (fun _ => (![16, 8, 4, 2, 1] : Fin 5 → ℝ)) [0, 1, 0, 1, 0] F ∧    F [] = {0, 2, 4} ∧    ¬ is_nel_pd (fun (_ : Fin 2) (x y : Fin 5) => (![16, 8, 4, 2, 1] : Fin 5 → ℝ) x ≤ (![16, 8, 4, 2, 1] : Fin 5 → ℝ) y) (pick_game_root_allocation F) := ⟨round_robin_five_item_F_alloc, round_robin_five_item_is_spe, round_robin_five_item_hFroot, round_robin_five_item_not_nel⟩
See it in the graphDiscuss this resultChallenge it