Theory Brouwer_Fixpoint

(*  Author:     John Harrison
    Author:     Robert Himmelmann, TU Muenchen (Translation from HOL light) and LCP
*)

(* At the moment this is just Brouwer's fixpoint theorem. The proof is from  *)
(* Kuhn: "some combinatorial lemmas in topology", IBM J. v4. (1960) p. 518   *)
(* See "http://www.research.ibm.com/journal/rd/045/ibmrd0405K.pdf".          *)
(*                                                                           *)
(* The script below is quite messy, but at least we avoid formalizing any    *)
(* topological machinery; we don't even use barycentric subdivision; this is *)
(* the big advantage of Kuhn's proof over the usual Sperner's lemma one.     *)
(*                                                                           *)
(*              (c) Copyright, John Harrison 1998-2008                       *)

section Brouwer's Fixed Point Theorem

theory Brouwer_Fixpoint
  imports Homeomorphism Derivative
begin

subsection Retractions

lemma retract_of_contractible:
  assumes "contractible T" "S retract_of T"
    shows "contractible S"
using assms
apply (clarsimp simp add: retract_of_def contractible_def retraction_def homotopic_with)
apply (rule_tac x="r a" in exI)
apply (rule_tac x="r  h" in exI)
apply (intro conjI continuous_intros continuous_on_compose)
apply (erule continuous_on_subset | force)+
done

lemma retract_of_path_connected:
    "path_connected T; S retract_of T  path_connected S"
  by (metis path_connected_continuous_image retract_of_def retraction)

lemma retract_of_simply_connected:
    "simply_connected T; S retract_of T  simply_connected S"
apply (simp add: retract_of_def retraction_def, clarify)
apply (rule simply_connected_retraction_gen)
apply (force elim!: continuous_on_subset)+
done

lemma retract_of_homotopically_trivial:
  assumes ts: "T retract_of S"
      and hom: "f g. continuous_on U f; f ` U  S;
                       continuous_on U g; g ` U  S
                        homotopic_with_canon (λx. True) U S f g"
      and "continuous_on U f" "f ` U  T"
      and "continuous_on U g" "g ` U  T"
    shows "homotopic_with_canon (λx. True) U T f g"
proof -
  obtain r where "r ` S  S" "continuous_on S r" "xS. r (r x) = r x" "T = r ` S"
    using ts by (auto simp: retract_of_def retraction)
  then obtain k where "Retracts S r T k"
    unfolding Retracts_def
    by (metis continuous_on_subset dual_order.trans image_iff image_mono)
  then show ?thesis
    apply (rule Retracts.homotopically_trivial_retraction_gen)
    using assms
    apply (force simp: hom)+
    done
qed

lemma retract_of_homotopically_trivial_null:
  assumes ts: "T retract_of S"
      and hom: "f. continuous_on U f; f ` U  S
                      c. homotopic_with_canon (λx. True) U S f (λx. c)"
      and "continuous_on U f" "f ` U  T"
  obtains c where "homotopic_with_canon (λx. True) U T f (λx. c)"
proof -
  obtain r where "r ` S  S" "continuous_on S r" "xS. r (r x) = r x" "T = r ` S"
    using ts by (auto simp: retract_of_def retraction)
  then obtain k where "Retracts S r T k"
    unfolding Retracts_def
    by (metis continuous_on_subset dual_order.trans image_iff image_mono)
  then show ?thesis
    apply (rule Retracts.homotopically_trivial_retraction_null_gen)
    apply (rule TrueI refl assms that | assumption)+
    done
qed

lemma retraction_openin_vimage_iff:
  "openin (top_of_set S) (S  r -` U)  openin (top_of_set T) U"
  if retraction: "retraction S T r" and "U  T"
  using retraction apply (rule retractionE)
  apply (rule continuous_right_inverse_imp_quotient_map [where g=r])
  using U  T apply (auto elim: continuous_on_subset)
  done

lemma retract_of_locally_compact:
    fixes S :: "'a :: {heine_borel,real_normed_vector} set"
    shows  " locally compact S; T retract_of S  locally compact T"
  by (metis locally_compact_closedin closedin_retract)

lemma homotopic_into_retract:
   "f ` S  T; g ` S  T; T retract_of U; homotopic_with_canon (λx. True) S U f g
         homotopic_with_canon (λx. True) S T f g"
apply (subst (asm) homotopic_with_def)
apply (simp add: homotopic_with retract_of_def retraction_def, clarify)
apply (rule_tac x="r  h" in exI)
apply (rule conjI continuous_intros | erule continuous_on_subset | force simp: image_subset_iff)+
done

lemma retract_of_locally_connected:
  assumes "locally connected T" "S retract_of T"
  shows "locally connected S"
  using assms
  by (auto simp: idempotent_imp_retraction intro!: retraction_openin_vimage_iff elim!: locally_connected_quotient_image retract_ofE)

lemma retract_of_locally_path_connected:
  assumes "locally path_connected T" "S retract_of T"
  shows "locally path_connected S"
  using assms
  by (auto simp: idempotent_imp_retraction intro!: retraction_openin_vimage_iff elim!: locally_path_connected_quotient_image retract_ofE)

text A few simple lemmas about deformation retracts

lemma deformation_retract_imp_homotopy_eqv:
  fixes S :: "'a::euclidean_space set"
  assumes "homotopic_with_canon (λx. True) S S id r" and r: "retraction S T r"
  shows "S homotopy_eqv T"
proof -
  have "homotopic_with_canon (λx. True) S S (id  r) id"
    by (simp add: assms(1) homotopic_with_symD)
  moreover have "homotopic_with_canon (λx. True) T T (r  id) id"
    using r unfolding retraction_def
    by (metis eq_id_iff homotopic_with_id2 topspace_euclidean_subtopology)
  ultimately
  show ?thesis
    unfolding homotopy_equivalent_space_def 
    by (metis (no_types, lifting) continuous_map_subtopology_eu continuous_on_id' id_def image_id r retraction_def)
qed

lemma deformation_retract:
  fixes S :: "'a::euclidean_space set"
    shows "(r. homotopic_with_canon (λx. True) S S id r  retraction S T r) 
           T retract_of S  (f. homotopic_with_canon (λx. True) S S id f  f ` S  T)"
    (is "?lhs = ?rhs")
proof
  assume ?lhs
  then show ?rhs
    by (auto simp: retract_of_def retraction_def)
next
  assume ?rhs
  then show ?lhs
    apply (clarsimp simp add: retract_of_def retraction_def)
    apply (rule_tac x=r in exI, simp)
     apply (rule homotopic_with_trans, assumption)
     apply (rule_tac f = "r  f" and g="r  id" in homotopic_with_eq)
        apply (rule_tac Y=S in homotopic_with_compose_continuous_left)
         apply (auto simp: homotopic_with_sym)
    done
qed

lemma deformation_retract_of_contractible_sing:
  fixes S :: "'a::euclidean_space set"
  assumes "contractible S" "a  S"
  obtains r where "homotopic_with_canon (λx. True) S S id r" "retraction S {a} r"
proof -
  have "{a} retract_of S"
    by (simp add: a  S)
  moreover have "homotopic_with_canon (λx. True) S S id (λx. a)"
      using assms
      by (auto simp: contractible_def homotopic_into_contractible image_subset_iff)
  moreover have "(λx. a) ` S  {a}"
    by (simp add: image_subsetI)
  ultimately show ?thesis
    using that deformation_retract  by metis
qed


lemma continuous_on_compact_surface_projection_aux:
  fixes S :: "'a::t2_space set"
  assumes "compact S" "S  T" "image q T  S"
      and contp: "continuous_on T p"
      and "x. x  S  q x = x"
      and [simp]: "x. x  T  q(p x) = q x"
      and "x. x  T  p(q x) = p x"
    shows "continuous_on T q"
proof -
  have *: "image p T = image p S"
    using assms by auto (metis imageI subset_iff)
  have contp': "continuous_on S p"
    by (rule continuous_on_subset [OF contp S  T])
  have "continuous_on (p ` T) q"
    by (simp add: "*" assms(1) assms(2) assms(5) continuous_on_inv contp' rev_subsetD)
  then have "continuous_on T (q  p)"
    by (rule continuous_on_compose [OF contp])
  then show ?thesis
    by (rule continuous_on_eq [of _ "q  p"]) (simp add: o_def)
qed

lemma continuous_on_compact_surface_projection:
  fixes S :: "'a::real_normed_vector set"
  assumes "compact S"
      and S: "S  V - {0}" and "cone V"
      and iff: "x k. x  V - {0}  0 < k  (k *R x)  S  d x = k"
  shows "continuous_on (V - {0}) (λx. d x *R x)"
proof (rule continuous_on_compact_surface_projection_aux [OF compact S S])
  show "(λx. d x *R x) ` (V - {0})  S"
    using iff by auto
  show "continuous_on (V - {0}) (λx. inverse(norm x) *R x)"
    by (intro continuous_intros) force
  show "x. x  S  d x *R x = x"
    by (metis S zero_less_one local.iff scaleR_one subset_eq)
  show "d (x /R norm x) *R (x /R norm x) = d x *R x" if "x  V - {0}" for x
    using iff [of "inverse(norm x) *R x" "norm x * d x", symmetric] iff that cone V
    by (simp add: field_simps cone_def zero_less_mult_iff)
  show "d x *R x /R norm (d x *R x) = x /R norm x" if "x  V - {0}" for x
  proof -
    have "0 < d x"
      using local.iff that by blast
    then show ?thesis
      by simp
  qed
qed

subsection Kuhn Simplices

lemma bij_betw_singleton_eq:
  assumes f: "bij_betw f A B" and g: "bij_betw g A B" and a: "a  A"
  assumes eq: "(x. x  A  x  a  f x = g x)"
  shows "f a = g a"
proof -
  have "f ` (A - {a}) = g ` (A - {a})"
    by (intro image_cong) (simp_all add: eq)
  then have "B - {f a} = B - {g a}"
    using f g a  by (auto simp: bij_betw_def inj_on_image_set_diff set_eq_iff)
  moreover have "f a  B" "g a  B"
    using f g a by (auto simp: bij_betw_def)
  ultimately show ?thesis
    by auto
qed

lemmas swap_apply1 = swap_apply(1)
lemmas swap_apply2 = swap_apply(2)

lemma pointwise_minimal_pointwise_maximal:
  fixes s :: "(nat  nat) set"
  assumes "finite s"
    and "s  {}"
    and "xs. ys. x  y  y  x"
  shows "as. xs. a  x"
    and "as. xs. x  a"
  using assms
proof (induct s rule: finite_ne_induct)
  case (insert b s)
  assume *: "xinsert b s. yinsert b s. x  y  y  x"
  then obtain u l where "l  s" "bs. l  b" "u  s" "bs. b  u"
    using insert by auto
  with * show "ainsert b s. xinsert b s. a  x" "ainsert b s. xinsert b s. x  a"
    using *[rule_format, of b u] *[rule_format, of b l] by (metis insert_iff order.trans)+
qed auto

lemma kuhn_labelling_lemma:
  fixes P Q :: "'a::euclidean_space  bool"
  assumes "x. P x  P (f x)"
    and "x. P x  (iBasis. Q i  0  xi  xi  1)"
  shows "l. (x.iBasis. l x i  (1::nat)) 
             (x.iBasis. P x  Q i  (xi = 0)  (l x i = 0)) 
             (x.iBasis. P x  Q i  (xi = 1)  (l x i = 1)) 
             (x.iBasis. P x  Q i  (l x i = 0)  xi  f xi) 
             (x.iBasis. P x  Q i  (l x i = 1)  f xi  xi)"
proof -
  { fix x i
    let ?R = "λy. (P x  Q i  x  i = 0  y = (0::nat)) 
        (P x  Q i  x  i = 1  y = 1) 
        (P x  Q i  y = 0  x  i  f x  i) 
        (P x  Q i  y = 1  f x  i  x  i)"
    { assume "P x" "Q i" "i  Basis" with assms have "0  f x  i  f x  i  1" by auto }
    then have "i  Basis  ?R 0  ?R 1" by auto }
  then show ?thesis
    unfolding all_conj_distrib[symmetric] Ball_def (* FIXME: shouldn't this work by metis? *)
    by (subst choice_iff[symmetric])+ blast
qed


subsubsection The key "counting" observation, somewhat abstracted

lemma kuhn_counting_lemma:
  fixes bnd compo compo' face S F
  defines "nF s == card {fF. face f s  compo' f}"
  assumes [simp, intro]: "finite F" ― ‹faces and [simp, intro]: "finite S" ― ‹simplices
    and "f. f  F  bnd f  card {sS. face f s} = 1"
    and "f. f  F  ¬ bnd f  card {sS. face f s} = 2"
    and "s. s  S  compo s  nF s = 1"
    and "s. s  S  ¬ compo s  nF s = 0  nF s = 2"
    and "odd (card {fF. compo' f  bnd f})"
  shows "odd (card {sS. compo s})"
proof -
  have "(s | s  S  ¬ compo s. nF s) + (s | s  S  compo s. nF s) = (sS. nF s)"
    by (subst sum.union_disjoint[symmetric]) (auto intro!: sum.cong)
  also have " = (sS. card {f  {fF. compo' f  bnd f}. face f s}) +
                  (sS. card {f  {fF. compo' f  ¬ bnd f}. face f s})"
    unfolding sum.distrib[symmetric]
    by (subst card_Un_disjoint[symmetric])
       (auto simp: nF_def intro!: sum.cong arg_cong[where f=card])
  also have " = 1 * card {fF. compo' f  bnd f} + 2 * card {fF. compo' f  ¬ bnd f}"
    using assms(4,5) by (fastforce intro!: arg_cong2[where f="(+)"] sum_multicount)
  finally have "odd ((s | s  S  ¬ compo s. nF s) + card {sS. compo s})"
    using assms(6,8) by simp
  moreover have "(s | s  S  ¬ compo s. nF s) =
    (s | s  S  ¬ compo s  nF s = 0. nF s) + (s | s  S  ¬ compo s  nF s = 2. nF s)"
    using assms(7) by (subst sum.union_disjoint[symmetric]) (fastforce intro!: sum.cong)+
  ultimately show ?thesis
    by auto
qed

subsubsection The odd/even result for faces of complete vertices, generalized

lemma kuhn_complete_lemma:
  assumes [simp]: "finite simplices"
    and face: "f s. face f s  (as. f = s - {a})"
    and card_s[simp]:  "s. s  simplices  card s = n + 2"
    and rl_bd: "s. s  simplices  rl ` s  {..Suc n}"
    and bnd: "f s. s  simplices  face f s  bnd f  card {ssimplices. face f s} = 1"
    and nbnd: "f s. s  simplices  face f s  ¬ bnd f  card {ssimplices. face f s} = 2"
    and odd_card: "odd (card {f. (ssimplices. face f s)  rl ` f = {..n}  bnd f})"
  shows "odd (card {ssimplices. (rl ` s = {..Suc n})})"
proof (rule kuhn_counting_lemma)
  have finite_s[simp]: "s. s  simplices  finite s"
    by (metis add_is_0 zero_neq_numeral card.infinite assms(3))

  let ?F = "{f. ssimplices. face f s}"
  have F_eq: "?F = (ssimplices. as. {s - {a}})"
    by (auto simp: face)
  show "finite ?F"
    using finite simplices unfolding F_eq by auto

  show "card {s  simplices. face f s} = 1" if "f  ?F" "bnd f" for f
    using bnd that by auto

  show "card {s  simplices. face f s} = 2" if "f  ?F" "¬ bnd f" for f
    using nbnd that by auto

  show "odd (card {f  {f. ssimplices. face f s}. rl ` f = {..n}  bnd f})"
    using odd_card by simp

  fix s assume s[simp]: "s  simplices"
  let ?S = "{f  {f. ssimplices. face f s}. face f s  rl ` f = {..n}}"
  have "?S = (λa. s - {a}) ` {as. rl ` (s - {a}) = {..n}}"
    using s by (fastforce simp: face)
  then have card_S: "card ?S = card {as. rl ` (s - {a}) = {..n}}"
    by (auto intro!: card_image inj_onI)

  { assume rl: "rl ` s = {..Suc n}"
    then have inj_rl: "inj_on rl s"
      by (intro eq_card_imp_inj_on) auto
    moreover obtain a where "rl a = Suc n" "a  s"
      by (metis atMost_iff image_iff le_Suc_eq rl)
    ultimately have n: "{..n} = rl ` (s - {a})"
      by (auto simp: inj_on_image_set_diff rl)
    have "{as. rl ` (s - {a}) = {..n}} = {a}"
      using inj_rl a  s by (auto simp: n inj_on_image_eq_iff[OF inj_rl])
    then show "card ?S = 1"
      unfolding card_S by simp }

  { assume rl: "rl ` s  {..Suc n}"
    show "card ?S = 0  card ?S = 2"
    proof cases
      assume *: "{..n}  rl ` s"
      with rl rl_bd[OF s] have rl_s: "rl ` s = {..n}"
        by (auto simp: atMost_Suc subset_insert_iff split: if_split_asm)
      then have "¬ inj_on rl s"
        by (intro pigeonhole) simp
      then obtain a b where ab: "a  s" "b  s" "rl a = rl b" "a  b"
        by (auto simp: inj_on_def)
      then have eq: "rl ` (s - {a}) = rl ` s"
        by auto
      with ab have inj: "inj_on rl (s - {a})"
        by (intro eq_card_imp_inj_on) (auto simp: rl_s card_Diff_singleton_if)

      { fix x assume "x  s" "x  {a, b}"
        then have "rl ` s - {rl x} = rl ` ((s - {a}) - {x})"
          by (auto simp: eq inj_on_image_set_diff[OF inj])
        also have " = rl ` (s - {x})"
          using ab x  {a, b} by auto
        also assume " = rl ` s"
        finally have False
          using xs by auto }
      moreover
      { fix x assume "x  {a, b}" with ab have "x  s  rl ` (s - {x}) = rl ` s"
          by (simp add: set_eq_iff image_iff Bex_def) metis }
      ultimately have "{as. rl ` (s - {a}) = {..n}} = {a, b}"
        unfolding rl_s[symmetric] by fastforce
      with a  b show "card ?S = 0  card ?S = 2"
        unfolding card_S by simp
    next
      assume "¬ {..n}  rl ` s"
      then have "x. rl ` (s - {x})  {..n}"
        by auto
      then show "card ?S = 0  card ?S = 2"
        unfolding card_S by simp
    qed }
qed fact

locale kuhn_simplex =
  fixes p n and base upd and s :: "(nat  nat) set"
  assumes base: "base  {..< n}  {..< p}"
  assumes base_out: "i. n  i  base i = p"
  assumes upd: "bij_betw upd {..< n} {..< n}"
  assumes s_pre: "s = (λi j. if j  upd`{..< i} then Suc (base j) else base j) ` {.. n}"
begin

definition "enum i j = (if j  upd`{..< i} then Suc (base j) else base j)"

lemma s_eq: "s = enum ` {.. n}"
  unfolding s_pre enum_def[abs_def] ..

lemma upd_space: "i < n  upd i < n"
  using upd by (auto dest!: bij_betwE)

lemma s_space: "s  {..< n}  {.. p}"
proof -
  { fix i assume "i  n" then have "enum i  {..< n}  {.. p}"
    proof (induct i)
      case 0 then show ?case
        using base by (auto simp: Pi_iff less_imp_le enum_def)
    next
      case (Suc i) with base show ?case
        by (auto simp: Pi_iff Suc_le_eq less_imp_le enum_def intro: upd_space)
    qed }
  then show ?thesis
    by (auto simp: s_eq)
qed

lemma inj_upd: "inj_on upd {..< n}"
  using upd by (simp add: bij_betw_def)

lemma inj_enum: "inj_on enum {.. n}"
proof -
  { fix x y :: nat assume "x  y" "x  n" "y  n"
    with upd have "upd ` {..< x}  upd ` {..< y}"
      by (subst inj_on_image_eq_iff[where C="{..< n}"]) (auto simp: bij_betw_def)
    then have "enum x  enum y"
      by (auto simp: enum_def fun_eq_iff) }
  then show ?thesis
    by (auto simp: inj_on_def)
qed

lemma enum_0: "enum 0 = base"
  by (simp add: enum_def[abs_def])

lemma base_in_s: "base  s"
  unfolding s_eq by (subst enum_0[symmetric]) auto

lemma enum_in: "i  n  enum i  s"
  unfolding s_eq by auto

lemma one_step:
  assumes a: "a  s" "j < n"
  assumes *: "a'. a'  s  a'  a  a' j = p'"
  shows "a j  p'"
proof
  assume "a j = p'"
  with * a have "a'. a'  s  a' j = p'"
    by auto
  then have "i. i  n  enum i j = p'"
    unfolding s_eq by auto
  from this[of 0] this[of n] have "j  upd ` {..< n}"
    by (auto simp: enum_def fun_eq_iff split: if_split_asm)
  with upd j < n show False
    by (auto simp: bij_betw_def)
qed

lemma upd_inj: "i < n  j < n  upd i = upd j  i = j"
  using upd by (auto simp: bij_betw_def inj_on_eq_iff)

lemma upd_surj: "upd ` {..< n} = {..< n}"
  using upd by (auto simp: bij_betw_def)

lemma in_upd_image: "A  {..< n}  i < n  upd i  upd ` A  i  A"
  using inj_on_image_mem_iff[of upd "{..< n}"] upd
  by (auto simp: bij_betw_def)

lemma enum_inj: "i  n  j  n  enum i = enum j  i = j"
  using inj_enum by (auto simp: inj_on_eq_iff)

lemma in_enum_image: "A  {.. n}  i  n  enum i  enum ` A  i  A"
  using inj_on_image_mem_iff[OF inj_enum] by auto

lemma enum_mono: "i  n  j  n  enum i  enum j  i  j"
  by (auto simp: enum_def le_fun_def in_upd_image Ball_def[symmetric])

lemma enum_strict_mono: "i  n  j  n  enum i < enum j  i < j"
  using enum_mono[of i j] enum_inj[of i j] by (auto simp: le_less)

lemma chain: "a  s  b  s  a  b  b  a"
  by (auto simp: s_eq enum_mono)

lemma less: "a  s  b  s  a i < b i  a < b"
  using chain[of a b] by (auto simp: less_fun_def le_fun_def not_le[symmetric])

lemma enum_0_bot: "a  s  a = enum 0  (a's. a  a')"
  unfolding s_eq by (auto simp: enum_mono Ball_def)

lemma enum_n_top: "a  s  a = enum n  (a's. a'  a)"
  unfolding s_eq by (auto simp: enum_mono Ball_def)

lemma enum_Suc: "i < n  enum (Suc i) = (enum i)(upd i := Suc (enum i (upd i)))"
  by (auto simp: fun_eq_iff enum_def upd_inj)

lemma enum_eq_p: "i  n  n  j  enum i j = p"
  by (induct i) (auto simp: enum_Suc enum_0 base_out upd_space not_less[symmetric])

lemma out_eq_p: "a  s  n  j  a j = p"
  unfolding s_eq by (auto simp: enum_eq_p)

lemma s_le_p: "a  s  a j  p"
  using out_eq_p[of a j] s_space by (cases "j < n") auto

lemma le_Suc_base: "a  s  a j  Suc (base j)"
  unfolding s_eq by (auto simp: enum_def)

lemma base_le: "a  s  base j  a j"
  unfolding s_eq by (auto simp: enum_def)

lemma enum_le_p: "i  n  j < n  enum i j  p"
  using enum_in[of i] s_space by auto

lemma enum_less: "a  s  i < n  enum i < a  enum (Suc i)  a"
  unfolding s_eq by (auto simp: enum_strict_mono enum_mono)

lemma ksimplex_0:
  "n = 0  s = {(λx. p)}"
  using s_eq enum_def base_out by auto

lemma replace_0:
  assumes "j < n" "a  s" and p: "xs - {a}. x j = 0" and "x  s"
  shows "x  a"
proof cases
  assume "x  a"
  have "a j  0"
    using assms by (intro one_step[where a=a]) auto
  with less[OF xs as, of j] p[rule_format, of x] x  s x  a
  show ?thesis
    by auto
qed simp

lemma replace_1:
  assumes "j < n" "a  s" and p: "xs - {a}. x j = p" and "x  s"
  shows "a  x"
proof cases
  assume "x  a"
  have "a j  p"
    using assms by (intro one_step[where a=a]) auto
  with enum_le_p[of _ j] j < n as
  have "a j < p"
    by (auto simp: less_le s_eq)
  with less[OF as xs, of j] p[rule_format, of x] x  s x  a
  show ?thesis
    by auto
qed simp

end

locale kuhn_simplex_pair = s: kuhn_simplex p n b_s u_s s + t: kuhn_simplex p n b_t u_t t
  for p n b_s u_s s b_t u_t t
begin

lemma enum_eq:
  assumes l: "i  l" "l  j" and "j + d  n"
  assumes eq: "s.enum ` {i .. j} = t.enum ` {i + d .. j + d}"
  shows "s.enum l = t.enum (l + d)"
using l proof (induct l rule: dec_induct)
  case base
  then have s: "s.enum i  t.enum ` {i + d .. j + d}" and t: "t.enum (i + d)  s.enum ` {i .. j}"
    using eq by auto
  from t i  j j + d  n have "s.enum i  t.enum (i + d)"
    by (auto simp: s.enum_mono)
  moreover from s i  j j + d  n have "t.enum (i + d)  s.enum i"
    by (auto simp: t.enum_mono)
  ultimately show ?case
    by auto
next
  case (step l)
  moreover from step.prems j + d  n have
      "s.enum l < s.enum (Suc l)"
      "t.enum (l + d) < t.enum (Suc l + d)"
    by (simp_all add: s.enum_strict_mono t.enum_strict_mono)
  moreover have
      "s.enum (Suc l)  t.enum ` {i + d .. j + d}"
      "t.enum (Suc l + d)  s.enum ` {i .. j}"
    using step j + d  n eq by (auto simp: s.enum_inj t.enum_inj)
  ultimately have "s.enum (Suc l) = t.enum (Suc (l + d))"
    using j + d  n
    by (intro antisym s.enum_less[THEN iffD1] t.enum_less[THEN iffD1])
       (auto intro!: s.enum_in t.enum_in)
  then show ?case by simp
qed

lemma ksimplex_eq_bot:
  assumes a: "a  s" "a'. a'  s  a  a'"
  assumes b: "b  t" "b'. b'  t  b  b'"
  assumes eq: "s - {a} = t - {b}"
  shows "s = t"
proof cases
  assume "n = 0" with s.ksimplex_0 t.ksimplex_0 show ?thesis by simp
next
  assume "n  0"
  have "s.enum 0 = (s.enum (Suc 0)) (u_s 0 := s.enum (Suc 0) (u_s 0) - 1)"
       "t.enum 0 = (t.enum (Suc 0)) (u_t 0 := t.enum (Suc 0) (u_t 0) - 1)"
    using n  0 by (simp_all add: s.enum_Suc t.enum_Suc)
  moreover have e0: "a = s.enum 0" "b = t.enum 0"
    using a b by (simp_all add: s.enum_0_bot t.enum_0_bot)
  moreover
  { fix j assume "0 < j" "j  n"
    moreover have "s - {a} = s.enum ` {Suc 0 .. n}" "t - {b} = t.enum ` {Suc 0 .. n}"
      unfolding s.s_eq t.s_eq e0 by (auto simp: s.enum_inj t.enum_inj)
    ultimately have "s.enum j = t.enum j"
      using enum_eq[of "1" j n 0] eq by auto }
  note enum_eq = this
  then have "s.enum (Suc 0) = t.enum (Suc 0)"
    using n  0 by auto
  moreover
  { fix j assume "Suc j < n"
    with enum_eq[of "Suc j"] enum_eq[of "Suc (Suc j)"]
    have "u_s (Suc j) = u_t (Suc j)"
      using s.enum_Suc[of "Suc j"] t.enum_Suc[of "Suc j"]
      by (auto simp: fun_eq_iff split: if_split_asm) }
  then have "j. 0 < j  j < n  u_s j = u_t j"
    by (auto simp: gr0_conv_Suc)
  with n  0 have "u_t 0 = u_s 0"
    by (intro bij_betw_singleton_eq[OF t.upd s.upd, of 0]) auto
  ultimately have "a = b"
    by simp
  with assms show "s = t"
    by auto
qed

lemma ksimplex_eq_top:
  assumes a: "a  s" "a'. a'  s  a'  a"
  assumes b: "b  t" "b'. b'  t  b'  b"
  assumes eq: "s - {a} = t - {b}"
  shows "s = t"
proof (cases n)
  assume "n = 0" with s.ksimplex_0 t.ksimplex_0 show ?thesis by simp
next
  case (Suc n')
  have "s.enum n = (s.enum n') (u_s n' := Suc (s.enum n' (u_s n')))"
       "t.enum n = (t.enum n') (u_t n' := Suc (t.enum n' (u_t n')))"
    using Suc by (simp_all add: s.enum_Suc t.enum_Suc)
  moreover have en: "a = s.enum n" "b = t.enum n"
    using a b by (simp_all add: s.enum_n_top t.enum_n_top)
  moreover
  { fix j assume "j < n"
    moreover have "s - {a} = s.enum ` {0 .. n'}" "t - {b} = t.enum ` {0 .. n'}"
      unfolding s.s_eq t.s_eq en by (auto simp: s.enum_inj t.enum_inj Suc)
    ultimately have "s.enum j = t.enum j"
      using enum_eq[of "0" j n' 0] eq Suc by auto }
  note enum_eq = this
  then have "s.enum n' = t.enum n'"
    using Suc by auto
  moreover
  { fix j assume "j < n'"
    with enum_eq[of j] enum_eq[of "Suc j"]
    have "u_s j = u_t j"
      using s.enum_Suc[of j] t.enum_Suc[of j]
      by (auto simp: Suc fun_eq_iff split: if_split_asm) }
  then have "j. j < n'  u_s j = u_t j"
    by (auto simp: gr0_conv_Suc)
  then have "u_t n' = u_s n'"
    by (intro bij_betw_singleton_eq[OF t.upd s.upd, of n']) (auto simp: Suc)
  ultimately have "a = b"
    by simp
  with assms show "s = t"
    by auto
qed

end

inductive ksimplex for p n :: nat where
  ksimplex: "kuhn_simplex p n base upd s  ksimplex p n s"

lemma finite_ksimplexes: "finite {s. ksimplex p n s}"
proof (rule finite_subset)
  { fix a s assume "ksimplex p n s" "a  s"
    then obtain b u where "kuhn_simplex p n b u s" by (auto elim: ksimplex.cases)
    then interpret kuhn_simplex p n b u s .
    from s_space a  s out_eq_p[OF a  s]
    have "a  (λf x. if n  x then p else f x) ` ({..< n} E {.. p})"
      by (auto simp: image_iff subset_eq Pi_iff split: if_split_asm
               intro!: bexI[of _ "restrict a {..< n}"]) }
  then show "{s. ksimplex p n s}  Pow ((λf x. if n  x then p else f x) ` ({..< n} E {.. p}))"
    by auto
qed (simp add: finite_PiE)

lemma ksimplex_card:
  assumes "ksimplex p n s" shows "card s = Suc n"
using assms proof cases
  case (ksimplex u b)
  then interpret kuhn_simplex p n u b s .
  show ?thesis
    by (simp add: card_image s_eq inj_enum)
qed

lemma simplex_top_face:
  assumes "0 < p" "xs'. x n = p"
  shows "ksimplex p n s'  (s a. ksimplex p (Suc n) s  a  s  s' = s - {a})"
  using assms
proof safe
  fix s a assume "ksimplex p (Suc n) s" and a: "a  s" and na: "xs - {a}. x n = p"
  then show "ksimplex p n (s - {a})"
  proof cases
    case (ksimplex base upd)
    then interpret kuhn_simplex p "Suc n" base upd "s" .

    have "a n < p"
      using one_step[of a n p] na as s_space by (auto simp: less_le)
    then have "a = enum 0"
      using a  s na by (subst enum_0_bot) (auto simp: le_less intro!: less[of a _ n])
    then have s_eq: "s - {a} = enum ` Suc ` {.. n}"
      using s_eq by (simp add: atMost_Suc_eq_insert_0 insert_ident in_enum_image subset_eq)
    then have "enum 1  s - {a}"
      by auto
    then have "upd 0 = n"
      using a n < p a = enum 0 na[rule_format, of "enum 1"]
      by (auto simp: fun_eq_iff enum_Suc split: if_split_asm)
    then have "bij_betw upd (Suc ` {..< n}) {..< n}"
      using upd
      by (subst notIn_Un_bij_betw3[where b=0])
         (auto simp: lessThan_Suc[symmetric] lessThan_Suc_eq_insert_0)
    then have "bij_betw (updSuc) {..<n} {..<n}"
      by (rule bij_betw_trans[rotated]) (auto simp: bij_betw_def)

    have "a n = p - 1"
      using enum_Suc[of 0] na[rule_format, OF enum 1  s - {a}] a = enum 0 by (auto simp: upd 0 = n)

    show ?thesis
    proof (rule ksimplex.intros, standard)
      show "bij_betw (updSuc) {..< n} {..< n}" by fact
      show "base(n := p)  {..<n}  {..<p}" "i. ni  (base(n := p)) i = p"
        using base base_out by (auto simp: Pi_iff)

      have "i. Suc ` {..< i} = {..< Suc i} - {0}"
        by (auto simp: image_iff Ball_def) arith
      then have upd_Suc: "i. i  n  (updSuc) ` {..< i} = upd ` {..< Suc i} - {n}"
        using upd 0 = n upd_inj by (auto simp add: image_iff less_Suc_eq_0_disj)
      have n_in_upd: "i. n  upd ` {..< Suc i}"
        using upd 0 = n by auto

      define f' where "f' i j =
        (if j  (updSuc)`{..< i} then Suc ((base(n := p)) j) else (base(n := p)) j)" for i j
      { fix x i
        assume i [arith]: "i  n"
        with upd_Suc have "(upd  Suc) ` {..<i} = upd ` {..<Suc i} - {n}" .
        with a n < p a = enum 0 upd 0 = n a n = p - 1
        have "enum (Suc i) x = f' i x"
          by (auto simp add: f'_def enum_def)  }
      then show "s - {a} = f' ` {.. n}"
        unfolding s_eq image_comp by (intro image_cong) auto
    qed
  qed
next
  assume "ksimplex p n s'" and *: "xs'. x n = p"
  then show "s a. ksimplex p (Suc n) s  a  s  s' = s - {a}"
  proof cases
    case (ksimplex base upd)
    then interpret kuhn_simplex p n base upd s' .
    define b where "b = base (n := p - 1)"
    define u where "u i = (case i of 0  n | Suc i  upd i)" for i

    have "ksimplex p (Suc n) (s'  {b})"
    proof (rule ksimplex.intros, standard)
      show "b  {..<Suc n}  {..<p}"
        using base 0 < p unfolding lessThan_Suc b_def by (auto simp: PiE_iff)
      show "i. Suc n  i  b i = p"
        using base_out by (auto simp: b_def)

      have "bij_betw u (Suc ` {..< n}  {0}) ({..<n}  {u 0})"
        using upd
        by (intro notIn_Un_bij_betw) (auto simp: u_def bij_betw_def image_comp comp_def inj_on_def)
      then show "bij_betw u {..<Suc n} {..<Suc n}"
        by (simp add: u_def lessThan_Suc[symmetric] lessThan_Suc_eq_insert_0)

      define f' where "f' i j = (if j  u`{..< i} then Suc (b j) else b j)" for i j

      have u_eq: "i. i  n  u ` {..< Suc i} = upd ` {..< i}  { n }"
        by (auto simp: u_def image_iff upd_inj Ball_def split: nat.split) arith

      { fix x have "x  n  n  upd ` {..<x}"
          using upd_space by (simp add: image_iff neq_iff) }
      note n_not_upd = this

      have *: "f' ` {.. Suc n} = f' ` (Suc ` {.. n}  {0})"
        unfolding atMost_Suc_eq_insert_0 by simp
      also have " = (f'  Suc) ` {.. n}  {b}"
        by (auto simp: f'_def)
      also have "(f'  Suc) ` {.. n} = s'"
        using 0 < p base_out[of n]
        unfolding s_eq enum_def[abs_def] f'_def[abs_def] upd_space
        by (intro image_cong) (simp_all add: u_eq b_def fun_eq_iff n_not_upd)
      finally show "s'  {b} = f' ` {.. Suc n}" ..
    qed
    moreover have "b  s'"
      using * 0 < p by (auto simp: b_def)
    ultimately show ?thesis by auto
  qed
qed

lemma ksimplex_replace_0:
  assumes s: "ksimplex p n s" and a: "a  s"
  assumes j: "j < n" and p: "xs - {a}. x j = 0"
  shows "card {s'. ksimplex p n s'  (bs'. s' - {b} = s - {a})} = 1"
  using s
proof cases
  case (ksimplex b_s u_s)

  { fix t b assume "ksimplex p n t"
    then obtain b_t u_t where "kuhn_simplex p n b_t u_t t"
      by (auto elim: ksimplex.cases)
    interpret kuhn_simplex_pair p n b_s u_s s b_t u_t t
      by intro_locales fact+

    assume b: "b  t" "t - {b} = s - {a}"
    with a j p s.replace_0[of _ a] t.replace_0[of _ b] have "s = t"
      by (intro ksimplex_eq_top[of a b]) auto }
  then have "{s'. ksimplex p n s'  (bs'. s' - {b} = s - {a})} = {s}"
    using s a  s by auto
  then show ?thesis
    by simp
qed

lemma ksimplex_replace_1:
  assumes s: "ksimplex p n s" and a: "a  s"
  assumes j: "j < n" and p: "xs - {a}. x j = p"
  shows "card {s'. ksimplex p n s'  (bs'. s' - {b} = s - {a})} = 1"
  using s
proof cases
  case (ksimplex b_s u_s)

  { fix t b assume "ksimplex p n t"
    then obtain b_t u_t where "kuhn_simplex p n b_t u_t t"
      by (auto elim: ksimplex.cases)
    interpret kuhn_simplex_pair p n b_s u_s s b_t u_t t
      by intro_locales fact+

    assume b: "b  t" "t - {b} = s - {a}"
    with a j p s.replace_1[of _ a] t.replace_1[of _ b] have "s = t"
      by (intro ksimplex_eq_bot[of a b]) auto }
  then have "{s'. ksimplex p n s'  (bs'. s' - {b} = s - {a})} = {s}"
    using s a  s by auto
  then show ?thesis
    by simp
qed

lemma ksimplex_replace_2:
  assumes s: "ksimplex p n s" and "a  s" and "n  0"
    and lb: "j<n. xs - {a}. x j  0"
    and ub: "j<n. xs - {a}. x j  p"
  shows "card {s'. ksimplex p n s'  (bs'. s' - {b} = s - {a})} = 2"
  using s
proof cases
  case (ksimplex base upd)
  then interpret kuhn_simplex p n base upd s .

  from a  s obtain i where "i  n" "a = enum i"
    unfolding s_eq by auto

  from i  n have "i = 0  i = n  (0 < i  i < n)"
    by linarith
  then have "∃!s'. s'  s  ksimplex p n s'  (bs'. s - {a} = s'- {b})"
  proof (elim disjE conjE)
    assume "i = 0"
    define rot where [abs_def]: "rot i = (if i + 1 = n then 0 else i + 1)" for i
    let ?upd = "upd  rot"

    have rot: "bij_betw rot {..< n} {..< n}"
      by (auto simp: bij_betw_def inj_on_def image_iff Ball_def rot_def)
         arith+
    from rot upd have "bij_betw ?upd {..<n} {..<n}"
      by (rule bij_betw_trans)

    define f' where [abs_def]: "f' i j =
      (if j  ?upd`{..< i} then Suc (enum (Suc 0) j) else enum (Suc 0) j)" for i j

    interpret b: kuhn_simplex p n "enum (Suc 0)" "upd  rot" "f' ` {.. n}"
    proof
      from a = enum i ub n  0 i = 0
      obtain i' where "i'  n" "enum i'  enum 0" "enum i' (upd 0)  p"
        unfolding s_eq by (auto intro: upd_space simp: enum_inj)
      then have "enum 1  enum i'" "enum i' (upd 0) < p"
        using enum_le_p[of i' "upd 0"] by (auto simp: enum_inj enum_mono upd_space)
      then have "enum 1 (upd 0) < p"
        by (auto simp: le_fun_def intro: le_less_trans)
      then show "enum (Suc 0)  {..<n}  {..<p}"
        using base n  0 by (auto simp: enum_0 enum_Suc PiE_iff extensional_def upd_space)

      { fix i assume "n  i" then show "enum (Suc 0) i = p"
        using n  0 by (auto simp: enum_eq_p) }
      show "bij_betw ?upd {..<n} {..<n}" by fact
    qed (simp add: f'_def)
    have ks_f': "ksimplex p n (f' ` {.. n})"
      by rule unfold_locales

    have b_enum: "b.enum = f'" unfolding f'_def b.enum_def[abs_def] ..
    with b.inj_enum have inj_f': "inj_on f' {.. n}" by simp

    have f'_eq_enum: "f' j = enum (Suc j)" if "j < n" for j
    proof -
      from that have "rot ` {..< j} = {0 <..< Suc j}"
        by (auto simp: rot_def image_Suc_lessThan cong: image_cong_simp)
      with that n  0 show ?thesis
        by (simp only: f'_def enum_def fun_eq_iff image_comp [symmetric])
          (auto simp add: upd_inj)
    qed
    then have "enum ` Suc ` {..< n} = f' ` {..< n}"
      by (force simp: enum_inj)
    also have "Suc ` {..< n} = {.. n} - {0}"
      by (auto simp: image_iff Ball_def) arith
    also have "{..< n} = {.. n} - {n}"
      by auto
    finally have eq: "s - {a} = f' ` {.. n} - {f' n}"
      unfolding s_eq a = enum i i = 0
      by (simp add: inj_on_image_set_diff[OF inj_enum] inj_on_image_set_diff[OF inj_f'])

    have "enum 0 < f' 0"
      using n  0 by (simp add: enum_strict_mono f'_eq_enum)
    also have " < f' n"
      using n  0 b.enum_strict_mono[of 0 n] unfolding b_enum by simp
    finally have "a  f' n"
      using a = enum i i = 0 by auto

    { fix t c assume "ksimplex p n t" "c  t" and eq_sma: "s - {a} = t - {c}"
      obtain b u where "kuhn_simplex p n b u t"
        using ksimplex p n t by (auto elim: ksimplex.cases)
      then interpret t: kuhn_simplex p n b u t .

      { fix x assume "x  s" "x  a"
         then have "x (upd 0) = enum (Suc 0) (upd 0)"
           by (auto simp: a = enum i i = 0 s_eq enum_def enum_inj) }
      then have eq_upd0: "xt-{c}. x (upd 0) = enum (Suc 0) (upd 0)"
        unfolding eq_sma[symmetric] by auto
      then have "c (upd 0)  enum (Suc 0) (upd 0)"
        using n  0 by (intro t.one_step[OF ct ]) (auto simp: upd_space)
      then have "c (upd 0) < enum (Suc 0) (upd 0)  c (upd 0) > enum (Suc 0) (upd 0)"
        by auto
      then have "t = s  t = f' ` {..n}"
      proof (elim disjE conjE)
        assume *: "c (upd 0) < enum (Suc 0) (upd 0)"
        interpret st: kuhn_simplex_pair p n base upd s b u t ..
        { fix x assume "x  t" with * ct eq_upd0[rule_format, of x] have "c  x"
            by (auto simp: le_less intro!: t.less[of _ _ "upd 0"]) }
        note top = this
        have "s = t"
          using a = enum i i = 0 c  t
          by (intro st.ksimplex_eq_bot[OF _ _ _ _ eq_sma])
             (auto simp: s_eq enum_mono t.s_eq t.enum_mono top)
        then show ?thesis by simp
      next
        assume *: "c (upd 0) > enum (Suc 0) (upd 0)"
        interpret st: kuhn_simplex_pair p n "enum (Suc 0)" "upd  rot" "f' ` {.. n}" b u t ..
        have eq: "f' ` {..n} - {f' n} = t - {c}"
          using eq_sma eq by simp
        { fix x assume "x  t" with * ct eq_upd0[rule_format, of x] have "x  c"
            by (auto simp: le_less intro!: t.less[of _ _ "upd 0"]) }
        note top = this
        have "f' ` {..n} = t"
          using a = enum i i = 0 c  t
          by (intro st.ksimplex_eq_top[OF _ _ _ _ eq])
             (auto simp: b.s_eq b.enum_mono t.s_eq t.enum_mono b_enum[symmetric] top)
        then show ?thesis by simp
      qed }
    with ks_f' eq a  f' n n  0 show ?thesis
      apply (intro ex1I[of _ "f' ` {.. n}"])
      apply auto []
      apply metis
      done
  next
    assume "i = n"
    from n  0 obtain n' where n': "n = Suc n'"
      by (cases n) auto

    define rot where "rot i = (case i of 0  n' | Suc i  i)" for i
    let ?upd = "upd  rot"

    have rot: "bij_betw rot {..< n} {..< n}"
      by (auto simp: bij_betw_def inj_on_def image_iff Bex_def rot_def n' split: nat.splits)
         arith
    from rot upd have "bij_betw ?upd {..<n} {..<n}"
      by (rule bij_betw_trans)

    define b where "b = base (upd n' := base (upd n') - 1)"
    define f' where [abs_def]: "f' i j = (if j  ?upd`{..< i} then Suc (b j) else b j)" for i j

    interpret b: kuhn_simplex p n b "upd  rot" "f' ` {.. n}"
    proof
      { fix i assume "n  i" then show "b i = p"
          using base_out[of i] upd_space[of n'] by (auto simp: b_def n') }
      show "b  {..<n}  {..<p}"
        using base n  0 upd_space[of n']
        by (auto simp: b_def PiE_def Pi_iff Ball_def upd_space extensional_def n')

      show "bij_betw ?upd {..<n} {..<n}" by fact
    qed (simp add: f'_def)
    have f': "b.enum = f'" unfolding f'_def b.enum_def[abs_def] ..
    have ks_f': "ksimplex p n (b.enum ` {.. n})"
      unfolding f' by rule unfold_locales

    have "0 < n"
      using n  0 by auto

    { from a = enum i n  0 i = n lb upd_space[of n']
      obtain i' where "i'  n" "enum i'  enum n" "0 < enum i' (upd n')"
        unfolding s_eq by (auto simp: enum_inj n')
      moreover have "enum i' (upd n') = base (upd n')"
        unfolding enum_def using i'  n enum i'  enum n by (auto simp: n' upd_inj enum_inj)
      ultimately have "0 < base (upd n')"
        by auto }
    then have benum1: "b.enum (Suc 0) = base"
      unfolding b.enum_Suc[OF 0<n] b.enum_0 by (auto simp: b_def rot_def)

    have [simp]: "j. Suc j < n  rot ` {..< Suc j} = {n'}  {..< j}"
      by (auto simp: rot_def image_iff Ball_def split: nat.splits)
    have rot_simps: "j. rot (Suc j) = j" "rot 0 = n'"
      by (simp_all add: rot_def)

    { fix j assume j: "Suc j  n" then have "b.enum (Suc j) = enum j"
        by (induct j) (auto simp: benum1 enum_0 b.enum_Suc enum_Suc rot_simps) }
    note b_enum_eq_enum = this
    then have "enum ` {..< n} = b.enum ` Suc ` {..< n}"
      by (auto simp: image_comp intro!: image_cong)
    also have "Suc ` {..< n} = {.. n} - {0}"
      by (auto simp: image_iff Ball_def) arith
    also have "{..< n} = {.. n} - {n}"
      by auto
    finally have eq: "s - {a} = b.enum ` {.. n} - {b.enum 0}"
      unfolding s_eq a = enum i i = n
      using inj_on_image_set_diff[OF inj_enum Diff_subset, of "{n}"]
            inj_on_image_set_diff[OF b.inj_enum Diff_subset, of "{0}"]
      by (simp add: comp_def)

    have "b.enum 0  b.enum n"
      by (simp add: b.enum_mono)
    also have "b.enum n < enum n"
      using n  0 by (simp add: enum_strict_mono b_enum_eq_enum n')
    finally have "a  b.enum 0"
      using a = enum i i = n by auto

    { fix t c assume "ksimplex p n t" "c  t" and eq_sma: "s - {a} = t - {c}"
      obtain b' u where "kuhn_simplex p n b' u t"
        using ksimplex p n t by (auto elim: ksimplex.cases)
      then interpret t: kuhn_simplex p n b' u t .

      { fix x assume "x  s" "x  a"
         then have "x (upd n') = enum n' (upd n')"
           by (auto simp: a = enum i n' i = n s_eq enum_def enum_inj in_upd_image) }
      then have eq_upd0: "xt-{c}. x (upd n') = enum n' (upd n')"
        unfolding eq_sma[symmetric] by auto
      then have "c (upd n')  enum n' (upd n')"
        using n  0 by (intro t.one_step[OF ct ]) (auto simp: n' upd_space[unfolded n'])
      then have "c (upd n') < enum n' (upd n')  c (upd n') > enum n' (upd n')"
        by auto
      then have "t = s  t = b.enum ` {..n}"
      proof (elim disjE conjE)
        assume *: "c (upd n') > enum n' (upd n')"
        interpret st: kuhn_simplex_pair p n base upd s b' u t ..
        { fix x assume "x  t" with * ct eq_upd0[rule_format, of x] have "x  c"
            by (auto simp: le_less intro!: t.less[of _ _ "upd n'"]) }
        note top = this
        have "s = t"
          using a = enum i i = n c  t
          by (intro st.ksimplex_eq_top[OF _ _ _ _ eq_sma])
             (auto simp: s_eq enum_mono t.s_eq t.enum_mono top)
        then show ?thesis by simp
      next
        assume *: "c (upd n') < enum n' (upd n')"
        interpret st: kuhn_simplex_pair p n b "upd  rot" "f' ` {.. n}" b' u t ..
        have eq: "f' ` {..n} - {b.enum 0} = t - {c}"
          using eq_sma eq f' by simp
        { fix x assume "x  t" with * ct eq_upd0[rule_format, of x] have "c  x"
            by (auto simp: le_less intro!: t.less[of _ _ "upd n'"]) }
        note bot = this
        have "f' ` {..n} = t"
          using a = enum i i = n c  t
          by (intro st.ksimplex_eq_bot[OF _ _ _ _ eq])
             (auto simp: b.s_eq b.enum_mono t.s_eq t.enum_mono bot)
        with f' show ?thesis by simp
      qed }
    with ks_f' eq a  b.enum 0 n  0 show ?thesis
      apply (intro ex1I[of _ "b.enum ` {.. n}"])
      apply auto []
      apply metis
      done
  next
    assume i: "0 < i" "i < n"
    define i' where "i' = i - 1"
    with i have "Suc i' < n"
      by simp
    with i have Suc_i': "Suc i' = i"
      by (simp add: i'_def)

    let ?upd = "Fun.swap i' i upd"
    from i upd have "bij_betw ?upd {..< n} {..< n}"
      by (subst bij_betw_swap_iff) (auto simp: i'_def)

    define f' where [abs_def]: "f' i j = (if j  ?upd`{..< i} then Suc (base j) else base j)"
      for i j
    interpret b: kuhn_simplex p n base ?upd "f' ` {.. n}"
    proof
      show "base  {..<n}  {..<p}" by (rule base)
      { fix i assume "n  i" then show "base i = p" by (rule base_out) }
      show "bij_betw ?upd {..<n} {..<n}" by fact
    qed (simp add: f'_def)
    have f': "b.enum = f'" unfolding f'_def b.enum_def[abs_def] ..
    have ks_f': "ksimplex p n (b.enum ` {.. n})"
      unfolding f' by rule unfold_locales

    have "{i}  {..n}"
      using i by auto
    { fix j assume "j  n"
      moreover have "j < i  i = j  i < j" by arith
      moreover note i
      ultimately have "enum j = b.enum j  j  i"
        apply (simp only: fun_eq_iff enum_def b.enum_def flip: image_comp)
        apply (cases i = j)
         apply simp
         apply (metis Suc_i' i  n imageI in_upd_image lessI lessThan_iff lessThan_subset_iff less_irrefl_nat transpose_apply_second transpose_commute)
        apply (subst transpose_image_eq)
         apply (auto simp add: i'_def)
        done
      }
    note enum_eq_benum = this
    then have "enum ` ({.. n} - {i}) = b.enum ` ({.. n} - {i})"
      by (intro image_cong) auto
    then have eq: "s - {a} = b.enum ` {.. n} - {b.enum i}"
      unfolding s_eq a = enum i
      using inj_on_image_set_diff[OF inj_enum Diff_subset {i}  {..n}]
            inj_on_image_set_diff[OF b.inj_enum Diff_subset {i}  {..n}]
      by (simp add: comp_def)

    have "a  b.enum i"
      using a = enum i enum_eq_benum i by auto

    { fix t c assume "ksimplex p n t" "c  t" and eq_sma: "s - {a} = t - {c}"
      obtain b' u where "kuhn_simplex p n b' u t"
        using ksimplex p n t by (auto elim: ksimplex.cases)
      then interpret t: kuhn_simplex p n b' u t .
      have "enum i'  s - {a}" "enum (i + 1)  s - {a}"
        using a = enum i i enum_in by (auto simp: enum_inj i'_def)
      then obtain l k where
        l: "t.enum l = enum i'" "l  n" "t.enum l  c" and
        k: "t.enum k = enum (i + 1)" "k  n" "t.enum k  c"
        unfolding eq_sma by (auto simp: t.s_eq)
      with i have "t.enum l < t.enum k"
        by (simp add: enum_strict_mono i'_def)
      with l  n k  n have "l < k"
        by (simp add: t.enum_strict_mono)
      { assume "Suc l = k"
        have "enum (Suc (Suc i')) = t.enum (Suc l)"
          using i by (simp add: k Suc l = k i'_def)
        then have False
          using l < k k  n Suc i' < n
          by (auto simp: t.enum_Suc enum_Suc l upd_inj fun_eq_iff split: if_split_asm)
             (metis Suc_lessD n_not_Suc_n upd_inj) }
      with l < k have "Suc l < k"
        by arith
      have c_eq: "c = t.enum (Suc l)"
      proof (rule ccontr)
        assume "c  t.enum (Suc l)"
        then have "t.enum (Suc l)  s - {a}"
          using l < k k  n by (simp add: t.s_eq eq_sma)
        then obtain j where "t.enum (Suc l) = enum j" "j  n" "enum j  enum i"
          unfolding s_eq a = enum i by auto
        with i have "t.enum (Suc l)  t.enum l  t.enum k  t.enum (Suc l)"
          by (auto simp: i'_def enum_mono enum_inj l k)
        with Suc l < k k  n show False
          by (simp add: t.enum_mono)
      qed

      { have "t.enum (Suc (Suc l))  s - {a}"
          unfolding eq_sma c_eq t.s_eq using Suc l < k k  n by (auto simp: t.enum_inj)
        then obtain j where eq: "t.enum (Suc (Suc l)) = enum j" and "j  n" "j  i"
          by (auto simp: s_eq a = enum i)
        moreover have "enum i' < t.enum (Suc (Suc l))"
          unfolding l(1)[symmetric] using Suc l < k k  n by (auto simp: t.enum_strict_mono)
        ultimately have "i' < j"
          using i by (simp add: enum_strict_mono i'_def)
        with j  i j  n have "t.enum k  t.enum (Suc (Suc l))"
          unfolding i'_def by (simp add: enum_mono k eq)
        then have "k  Suc (Suc l)"
          using k  n Suc l < k by (simp add: t.enum_mono) }
      with Suc l < k have "Suc (Suc l) = k" by simp
      then have "enum (Suc (Suc i')) = t.enum (Suc (Suc l))"
        using i by (simp add: k i'_def)
      also have " = (enum i') (u l := Suc (enum i' (u l)), u (Suc l) := Suc (enum i' (u (Suc l))))"
        using Suc l < k k  n by (simp add: t.enum_Suc l t.upd_inj)
      finally have "(u l = upd i'  u (Suc l) = upd (Suc i')) 
        (u l = upd (Suc i')  u (Suc l) = upd i')"
        using Suc i' < n by (auto simp: enum_Suc fun_eq_iff split: if_split_asm)

      then have "t = s  t = b.enum ` {..n}"
      proof (elim disjE conjE)
        assume u: "u l = upd i'"
        have "c = t.enum (Suc l)" unfolding c_eq ..
        also have "t.enum (Suc l) = enum (Suc i')"
          using u l < k k  n Suc i' < n by (simp add: enum_Suc t.enum_Suc l)
        also have " = a"
          using a = enum i i by (simp add: i'_def)
        finally show ?thesis
          using eq_sma a  s c  t by auto
      next
        assume u: "u l = upd (Suc i')"
        define B where "B = b.enum ` {..n}"
        have "b.enum i' = enum i'"
          using enum_eq_benum[of i'] i by (auto simp: i'_def gr0_conv_Suc)
        have "c = t.enum (Suc l)" unfolding c_eq ..
        also have "t.enum (Suc l) = b.enum (Suc i')"
          using u l < k k  n Suc i' < n
          by (simp_all add: enum_Suc t.enum_Suc l b.enum_Suc b.enum i' = enum i')
             (simp add: Suc_i')
        also have " = b.enum i"
          using i by (simp add: i'_def)
        finally have "c = b.enum i" .
        then have "t - {c} = B - {c}" "c  B"
          unfolding eq_sma[symmetric] eq B_def using i by auto
        with c  t have "t = B"
          by auto
        then show ?thesis
          by (simp add: B_def)
      qed }
    with ks_f' eq a  b.enum i n  0 i  n show ?thesis
      apply (intro ex1I[of _ "b.enum ` {.. n}"])
      apply auto []
      apply metis
      done
  qed
  then show ?thesis
    using s a  s by (simp add: card_2_iff' Ex1_def) metis
qed

text Hence another step towards concreteness.

lemma kuhn_simplex_lemma:
  assumes "s. ksimplex p (Suc n) s  rl ` s  {.. Suc n}"
    and "odd (card {f. s a. ksimplex p (Suc n) s  a  s  (f = s - {a}) 
      rl ` f = {..n}  ((jn. xf. x j = 0)  (jn. xf. x j = p))})"
  shows "odd (card {s. ksimplex p (Suc n) s  rl ` s = {..Suc n}})"
proof (rule kuhn_complete_lemma[OF finite_ksimplexes refl, unfolded mem_Collect_eq,
    where bnd="λf. (j{..n}. xf. x j = 0)  (j{..n}. xf. x j = p)"],
    safe del: notI)

  have *: "x y. x = y  odd (card x)  odd (card y)"
    by auto
  show "odd (card {f. (s{s. ksimplex p (Suc n) s}. as. f = s - {a}) 
    rl ` f = {..n}  ((j{..n}. xf. x j = 0)  (j{..n}. xf. x j = p))})"
    apply (rule *[OF _ assms(2)])
    apply (auto simp: atLeast0AtMost)
    done

next

  fix s assume s: "ksimplex p (Suc n) s"
  then show "card s = n + 2"
    by (simp add: ksimplex_card)

  fix a assume a: "a  s" then show "rl a  Suc n"
    using assms(1) s by (auto simp: subset_eq)

  let ?S = "{t. ksimplex p (Suc n) t  (bt. s - {a} = t - {b})}"
  { fix j assume j: "j  n" "xs - {a}. x j = 0"
    with s a show "card ?S = 1"
      using ksimplex_replace_0[of p "n + 1" s a j]
      by (subst eq_commute) simp }

  { fix j assume j: "j  n" "xs -<