round_robin_five_item_spe_not_nel
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.
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.
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
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.
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_eqlemma 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]
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).
uses
round_robin_five_item_u_val_eq,round_robin_five_item_h_len_eq,round_robin_five_item_move_zero_eq,Finset.sum_congrlemma 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)
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) = ∅.
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_neglemma 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
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}.
lemma round_robin_five_item_hFroot : round_robin_five_item_F_alloc [] = {0, 2, 4} := by decide
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}.
uses
round_robin_five_item_hFrootlemma 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
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.
uses
Finset.mem_insert,Finset.mem_singleton,round_robin_five_item_not_nel,round_robin_five_item_is_spe,round_robin_five_item_hFroothave 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.
- Step 1 verifies the subgame-perfect optimality condition across all 32 subsets of remaining items purely through finite computational reflection via Lean's `decide` tactic.
- Step 5 similarly evaluates the root allocation of the greedy profile on the empty history by direct finite evaluation via `decide`.
- The greedy allocation function uses a termination fuel parameter of 5 (`round_robin_five_item_g_fuel 5`) to ensure computability within Lean's kernel.
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
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
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⟩