Theory Traces

section ‹Trace Theory›

theory Traces
imports "Basics/Word_Prefixes"
begin

  locale traces =
    fixes ind :: "'item ⇒ 'item ⇒ bool"
    assumes independence_symmetric[sym]: "ind a b ⟹ ind b a"
  begin

    abbreviation Ind :: "'item set ⇒ 'item set ⇒ bool"
      where "Ind A B ≡ ∀ a ∈ A. ∀ b ∈ B. ind a b"

    inductive eq_swap :: "'item list ⇒ 'item list ⇒ bool" (infix ‹=S› 50)
      where swap: "ind a b ⟹ u @ [a] @ [b] @ v =S u @ [b] @ [a] @ v"

    declare eq_swap.intros[intro]
    declare eq_swap.cases[elim]

    lemma eq_swap_sym[sym]: "v =S w ⟹ w =S v" using independence_symmetric by auto

    lemma eq_swap_length[dest]: "w1 =S w2 ⟹ length w1 = length w2" by force
    lemma eq_swap_range[dest]: "w1 =S w2 ⟹ set w1 = set w2" by force

    lemma eq_swap_extend:
      assumes "w1 =S w2"
      shows "u @ w1 @ v =S u @ w2 @ v"
    using assms
    proof induct
      case (swap a b u' v')
      have "u @ (u' @ [a] @ [b] @ v') @ v = (u @ u') @ [a] @ [b] @ (v' @ v)" by simp
      also have "… =S (u @ u') @ [b] @ [a] @ (v' @ v)" using swap by blast
      also have "… = u @ (u' @ [b] @ [a] @ v') @ v" by simp
      finally show ?case by this
    qed

    lemma eq_swap_remove1:
      assumes "w1 =S w2"
      obtains (equal) "remove1 c w1 = remove1 c w2" | (swap) "remove1 c w1 =S remove1 c w2"
    using assms
    proof induct
      case (swap a b u v)
      have "c ∉ set (u @ [a] @ [b] @ v) ∨
        c ∈ set u ∨
        c ∉ set u ∧ c = a ∨
        c ∉ set u ∧ c ≠ a ∧ c = b ∨
        c ∉ set u ∧ c ≠ a ∧ c ≠ b ∧ c ∈ set v"
        by auto
      thus ?case
      proof (elim disjE)
        assume 0: "c ∉ set (u @ [a] @ [b] @ v)"
        have 1: "c ∉ set (u @ [b] @ [a] @ v)" using 0 by auto
        have 2: "remove1 c (u @ [a] @ [b] @ v) = u @ [a] @ [b] @ v" using remove1_idem 0 by this
        have 3: "remove1 c (u @ [b] @ [a] @ v) = u @ [b] @ [a] @ v" using remove1_idem 1 by this
        have 4: "remove1 c (u @ [a] @ [b] @ v) =S remove1 c (u @ [b] @ [a] @ v)"
          unfolding 2 3 using eq_swap.intros swap(1) by this
        show thesis using swap(3) 4 by this
      next
        assume 0: "c ∈ set u"
        have 2: "remove1 c (u @ [a] @ [b] @ v) = remove1 c u @ [a] @ [b] @ v"
          unfolding remove1_append using 0 by simp
        have 3: "remove1 c (u @ [b] @ [a] @ v) = remove1 c u @ [b] @ [a] @ v"
          unfolding remove1_append using 0 by simp
        have 4: "remove1 c (u @ [a] @ [b] @ v) =S remove1 c (u @ [b] @ [a] @ v)"
          unfolding 2 3 using eq_swap.intros swap(1) by this
        show thesis using swap(3) 4 by this
      next
        assume 0: "c ∉ set u ∧ c = a"
        have 2: "remove1 c (u @ [a] @ [b] @ v) = u @ [b] @ v"
          unfolding remove1_append using remove1_idem 0 by auto
        have 3: "remove1 c (u @ [b] @ [a] @ v) = u @ [b] @ v"
          unfolding remove1_append using remove1_idem 0 by auto
        have 4: "remove1 c (u @ [a] @ [b] @ v) = remove1 c (u @ [b] @ [a] @ v)"
          unfolding 2 3 by rule
        show thesis using swap(2) 4 by this
      next
        assume 0: "c ∉ set u ∧ c ≠ a ∧ c = b"
        have 2: "remove1 c (u @ [a] @ [b] @ v) = u @ [a] @ v"
          unfolding remove1_append using remove1_idem 0 by auto
        have 3: "remove1 c (u @ [b] @ [a] @ v) = u @ [a] @ v"
          unfolding remove1_append using remove1_idem 0 by auto
        have 4: "remove1 c (u @ [a] @ [b] @ v) = remove1 c (u @ [b] @ [a] @ v)"
          unfolding 2 3 by rule
        show thesis using swap(2) 4 by this
      next
        assume 0: "c ∉ set u ∧ c ≠ a ∧ c ≠ b ∧ c ∈ set v"
        have 2: "remove1 c (u @ [a] @ [b] @ v) = u @ [a] @ [b] @ remove1 c v"
          unfolding remove1_append using 0 by simp
        have 3: "remove1 c (u @ [b] @ [a] @ v) = u @ [b] @ [a] @ remove1 c v"
          unfolding remove1_append using 0 by simp
        have 4: "remove1 c (u @ [a] @ [b] @ v) =S remove1 c (u @ [b] @ [a] @ v)"
          unfolding 2 3 using eq_swap.intros swap(1) by this
        show ?thesis using swap(3) 4 by this
      qed
    qed

    lemma eq_swap_rev:
      assumes "w1 =S w2"
      shows "rev w1 =S rev w2"
    using assms
    proof induct
      case (swap a b u v)
      have 1: "rev v @ [a] @ [b] @ rev u =S rev v @ [b] @ [a] @ rev u" using swap by blast
      have 2: "rev v @ [b] @ [a] @ rev u =S rev v @ [a] @ [b] @ rev u" using 1 eq_swap_sym by blast
      show ?case using 2 by simp
    qed

    abbreviation eq_fin :: "'item list ⇒ 'item list ⇒ bool" (infix ‹=F› 50)
      where "eq_fin ≡ eq_swap**"

    lemma eq_fin_symp[intro, sym]: "u =F v ⟹ v =F u"
      using eq_swap_sym sym_rtrancl[to_pred] unfolding symp_def by metis

    lemma eq_fin_length[dest]: "w1 =F w2 ⟹ length w1 = length w2"
      by (induct rule: rtranclp.induct, auto)
    lemma eq_fin_range[dest]: "w1 =F w2 ⟹ set w1 = set w2"
      by (induct rule: rtranclp.induct, auto)

    lemma eq_fin_remove1:
      assumes "w1 =F w2"
      shows "remove1 c w1 =F remove1 c w2"
    using assms
    proof induct
      case (base)
      show ?case by simp
    next
      case (step w2 w3)
      show ?case
      using step(2)
      proof (cases rule: eq_swap_remove1[where ?c = c])
        case equal
        show ?thesis using step equal by simp
      next
        case swap
        show ?thesis using step swap by auto
      qed
    qed

    lemma eq_fin_rev:
      assumes "w1 =F w2"
      shows "rev w1 =F rev w2"
      using assms by (induct, auto dest: eq_swap_rev)

    lemma eq_fin_concat_eq_fin_start:
      assumes "u @ v1 =F u @ v2"
      shows "v1 =F v2"
    using assms
    proof (induct u arbitrary: v1 v2 rule: rev_induct)
      case (Nil)
      show ?case using Nil by simp
    next
      case (snoc a u)
      have 1: "u @ [a] @ v1 =F u @ [a] @ v2" using snoc(2) by simp
      have 2: "[a] @ v1 =F [a] @ v2" using snoc(1) 1 by this
      show ?case using eq_fin_remove1[OF 2, of a] by simp
    qed

    lemma eq_fin_concat: "u @ w1 @ v =F u @ w2 @ v ⟷ w1 =F w2"
    proof
      assume 0: "u @ w1 @ v =F u @ w2 @ v"
      have 1: "w1 @ v =F w2 @ v" using eq_fin_concat_eq_fin_start 0 by this
      have 2: "rev (w1 @ v) =F rev (w2 @ v)" using 1 by (blast dest: eq_fin_rev)
      have 3: "rev v @ rev w1 =F rev v @ rev w2" using 2 by simp
      have 4: "rev w1 =F rev w2" using eq_fin_concat_eq_fin_start 3 by this
      have 5: "rev (rev w1) =F rev (rev w2)" using 4 by (blast dest: eq_fin_rev)
      show "w1 =F w2" using 5 by simp
    next
      show "u @ w1 @ v =F u @ w2 @ v" if "w1 =F w2"
        using that by (induct, auto dest: eq_swap_extend[of _ _ u v])
    qed
    lemma eq_fin_concat_start[iff]: "w @ w1 =F w @ w2 ⟷ w1 =F w2"
      using eq_fin_concat[of "w" _ "[]"] by simp
    lemma eq_fin_concat_end[iff]: "w1 @ w =F w2 @ w ⟷ w1 =F w2"
      using eq_fin_concat[of "[]" _ "w"] by simp

    lemma ind_eq_fin':
      assumes "Ind {a} (set v)"
      shows "[a] @ v =F v @ [a]"
    using assms
    proof (induct v)
      case (Nil)
      show ?case by simp
    next
      case (Cons b v)
      have 1: "Ind {a} (set v)" using Cons(2) by auto
      have 2: "ind a b" using Cons(2) by auto
      have "[a] @ b # v = [a] @ [b] @ v" by simp
      also have "… =S [b] @ [a] @ v" using eq_swap.intros[OF 2, of "[]"] by auto
      also have "… =F [b] @ v @ [a]" using Cons(1) 1 by blast
      also have "… = (b # v) @ [a]" by simp
      finally show ?case by this
    qed

    lemma ind_eq_fin[intro]:
      assumes "Ind (set u) (set v)"
      shows "u @ v =F v @ u"
    using assms
    proof (induct u)
      case (Nil)
      show ?case by simp
    next
      case (Cons a u)
      have 1: "Ind (set u) (set v)" using Cons(2) by auto
      have 2: "Ind {a} (set v)" using Cons(2) by auto
      have "(a # u) @ v = [a] @ u @ v" by simp
      also have "… =F [a] @ v @ u" using Cons(1) 1 by blast
      also have "… = ([a] @ v) @ u" by simp
      also have "… =F (v @ [a]) @ u" using ind_eq_fin' 2 by blast
      also have "… = v @ (a # u)" by simp
      finally show ?case by this
    qed

    definition le_fin :: "'item list ⇒ 'item list ⇒ bool" (infix ‹≼F› 50)
      where "w1 ≼F w2 ≡ ∃ v1. w1 @ v1 =F w2"

    lemma le_finI[intro 0]:
      assumes "w1 @ v1 =F w2"
      shows "w1 ≼F w2"
      using assms unfolding le_fin_def by auto
    lemma le_finE[elim 0]:
      assumes "w1 ≼F w2"
      obtains v1
      where "w1 @ v1 =F w2"
      using assms unfolding le_fin_def by auto

    lemma le_fin_empty[simp]: "[] ≼F w" by force
    lemma le_fin_trivial[intro]: "w1 =F w2 ⟹ w1 ≼F w2"
    proof
      assume 1: "w1 =F w2"
      show "w1 @ [] =F w2" using 1 by simp
    qed

    lemma le_fin_length[dest]: "w1 ≼F w2 ⟹ length w1 ≤ length w2" by force
    lemma le_fin_range[dest]: "w1 ≼F w2 ⟹ set w1 ⊆ set w2" by force

    lemma eq_fin_alt_def: "w1 =F w2 ⟷ w1 ≼F w2 ∧ w2 ≼F w1"
    proof
      show "w1 ≼F w2 ∧ w2 ≼F w1" if "w1 =F w2" using that by blast
    next
      assume 0: "w1 ≼F w2 ∧ w2 ≼F w1"
      have 1: "w1 ≼F w2" "w2 ≼F w1" using 0 by auto
      have 10: "length w1 = length w2" using 1 by force
      obtain v1 v2 where 2: "w1 @ v1 =F w2" "w2 @ v2 =F w1" using 1 by (elim le_finE)
      have 3: "length w1 = length (w1 @ v1)" using 2 10 by force
      have 4: "w1 = w1 @ v1" using 3 by auto
      have 5: "length w2 = length (w2 @ v2)" using 2 10 by force
      have 6: "w2 = w2 @ v2" using 5 by auto
      show "w1 =F w2" using 4 6 2 by simp
    qed

    lemma le_fin_reflp[simp, intro]: "w ≼F w" by auto
    lemma le_fin_transp[intro, trans]:
      assumes "w1 ≼F w2" "w2 ≼F w3"
      shows "w1 ≼F w3"
    proof -
      obtain v1 where 1: "w1 @ v1 =F w2" using assms(1) by rule
      obtain v2 where 2: "w2 @ v2 =F w3" using assms(2) by rule
      show ?thesis
      proof
        have "w1 @ v1 @ v2 = (w1 @ v1) @ v2" by simp
        also have "… =F w2 @ v2" using 1 by blast
        also have "… =F w3" using 2 by blast
        finally show "w1 @ v1 @ v2 =F w3" by this
      qed
    qed
    lemma eq_fin_le_fin_transp[intro, trans]:
      assumes "w1 =F w2" "w2 ≼F w3"
      shows "w1 ≼F w3"
      using assms by auto
    lemma le_fin_eq_fin_transp[intro, trans]:
      assumes "w1 ≼F w2" "w2 =F w3"
      shows "w1 ≼F w3"
      using assms by auto
    lemma prefix_le_fin_transp[intro, trans]:
      assumes "w1 ≤ w2" "w2 ≼F w3"
      shows "w1 ≼F w3"
    proof -
      obtain v1 where 1: "w2 = w1 @ v1" using assms(1) by rule
      obtain v2 where 2: "w2 @ v2 =F w3" using assms(2) by rule
      show ?thesis
      proof
        show "w1 @ v1 @ v2 =F w3" using 1 2 by simp
      qed
    qed
    lemma le_fin_prefix_transp[intro, trans]:
      assumes "w1 ≼F w2" "w2 ≤ w3"
      shows "w1 ≼F w3"
    proof -
      obtain v1 where 1: "w1 @ v1 =F w2" using assms(1) by rule
      obtain v2 where 2: "w3 = w2 @ v2" using assms(2) by rule
      show ?thesis
      proof
        have "w1 @ v1 @ v2 = (w1 @ v1) @ v2" by simp
        also have "… =F w2 @ v2" using 1 by blast
        also have "… = w3" using 2 by simp
        finally show "w1 @ v1 @ v2 =F w3" by this
      qed
    qed
    lemma prefix_eq_fin_transp[intro, trans]:
      assumes "w1 ≤ w2" "w2 =F w3"
      shows "w1 ≼F w3"
      using assms by auto

    lemma le_fin_concat_start[iff]: "w @ w1 ≼F w @ w2 ⟷ w1 ≼F w2"
    proof
      assume 0: "w @ w1 ≼F w @ w2"
      obtain v1 where 1: "w @ w1 @ v1 =F w @ w2" using 0 by auto
      show "w1 ≼F w2" using 1 by auto
    next
      assume 0: "w1 ≼F w2"
      obtain v1 where 1: "w1 @ v1 =F w2" using 0 by auto
      have 2: "(w @ w1) @ v1 =F w @ w2" using 1 by auto
      show "w @ w1 ≼F w @ w2" using 2 by blast
    qed
    lemma le_fin_concat_end[dest]:
      assumes "w1 ≼F w2"
      shows "w1 ≼F w2 @ w"
    proof -
      obtain v1 where 1: "w1 @ v1 =F w2" using assms by rule
      show ?thesis
      proof
        have "w1 @ v1 @ w = (w1 @ v1) @ w" by simp
        also have "… =F w2 @ w" using 1 by blast
        finally show "w1 @ v1 @ w =F w2 @ w" by this
      qed
    qed

    definition le_fininf :: "'item list ⇒ 'item stream ⇒ bool" (infix ‹≼FI› 50)
      where "w1 ≼FI w2 ≡ ∃ v2. v2 ≤FI w2 ∧ w1 ≼F v2"

    lemma le_fininfI[intro 0]:
      assumes "v2 ≤FI w2" "w1 ≼F v2"
      shows "w1 ≼FI w2"
      using assms unfolding le_fininf_def by auto
    lemma le_fininfE[elim 0]:
      assumes "w1 ≼FI w2"
      obtains v2
      where "v2 ≤FI w2" "w1 ≼F v2"
      using assms unfolding le_fininf_def by auto

    lemma le_fininf_empty[simp]: "[] ≼FI w" by force

    lemma le_fininf_range[dest]: "w1 ≼FI w2 ⟹ set w1 ⊆ sset w2" by force

    lemma eq_fin_le_fininf_transp[intro, trans]:
      assumes "w1 =F w2" "w2 ≼FI w3"
      shows "w1 ≼FI w3"
      using assms by blast
    lemma le_fin_le_fininf_transp[intro, trans]:
      assumes "w1 ≼F w2" "w2 ≼FI w3"
      shows "w1 ≼FI w3"
      using assms by blast
    lemma prefix_le_fininf_transp[intro, trans]:
      assumes "w1 ≤ w2" "w2 ≼FI w3"
      shows "w1 ≼FI w3"
      using assms by auto
    lemma le_fin_prefix_fininf_transp[intro, trans]:
      assumes "w1 ≼F w2" "w2 ≤FI w3"
      shows "w1 ≼FI w3"
      using assms by auto
    lemma eq_fin_prefix_fininf_transp[intro, trans]:
      assumes "w1 =F w2" "w2 ≤FI w3"
      shows "w1 ≼FI w3"
      using assms by auto

    lemma le_fininf_concat_start[iff]: "w @ w1 ≼FI w @- w2 ⟷ w1 ≼FI w2"
    proof
      assume 0: "w @ w1 ≼FI w @- w2"
      obtain v2 where 1: "v2 ≤FI w @- w2" "w @ w1 ≼F v2" using 0 by rule
      have 2: "length w ≤ length v2" using 1(2) by force
      have 4: "w ≤ v2" using prefix_fininf_extend[OF 1(1) 2] by this
      obtain v1 where 5: "v2 = w @ v1" using 4 by rule
      show "w1 ≼FI w2"
      proof
        show "v1 ≤FI w2" using 1(1) unfolding 5 by auto
        show "w1 ≼F v1" using 1(2) unfolding 5 by simp
      qed
    next
      assume 0: "w1 ≼FI w2"
      obtain v2 where 1: "v2 ≤FI w2" "w1 ≼F v2" using 0 by rule
      show "w @ w1 ≼FI w @- w2"
      proof
        show "w @ v2 ≤FI (w @- w2)" using 1(1) by auto
        show "w @ w1 ≼F w @ v2" using 1(2) by auto
      qed
    qed

    lemma le_fininf_singleton[intro, simp]: "[shd v] ≼FI v"
    proof -
      have "[shd v] ≼FI shd v ## sdrop 1 v" by blast
      also have "… = v" by simp
      finally show ?thesis by this
    qed

    definition le_inf :: "'item stream ⇒ 'item stream ⇒ bool" (infix ‹≼I› 50)
      where "w1 ≼I w2 ≡ ∀ v1. v1 ≤FI w1 ⟶ v1 ≼FI w2"

    lemma le_infI[intro 0]:
      assumes "⋀ v1. v1 ≤FI w1 ⟹ v1 ≼FI w2"
      shows "w1 ≼I w2"
      using assms unfolding le_inf_def by auto
    lemma le_infE[elim 0]:
      assumes "w1 ≼I w2" "v1 ≤FI w1"
      obtains "v1 ≼FI w2"
      using assms unfolding le_inf_def by auto

    lemma le_inf_range[dest]:
      assumes "w1 ≼I w2"
      shows "sset w1 ⊆ sset w2"
    proof
      fix a
      assume 1: "a ∈ sset w1"
      obtain i where 2: "a = w1 !! i" using 1 by (metis imageE sset_range)
      have 3: "stake (Suc i) w1 ≤FI w1" by rule
      have 4: "stake (Suc i) w1 ≼FI w2" using assms 3 by rule
      have 5: "w1 !! i ∈ set (stake (Suc i) w1)" by (meson lessI set_stake_snth)
      show "a ∈ sset w2" unfolding 2 using 5 4 by fastforce
    qed

    lemma le_inf_reflp[simp, intro]: "w ≼I w" by auto
    lemma prefix_fininf_le_inf_transp[intro, trans]:
      assumes "w1 ≤FI w2" "w2 ≼I w3"
      shows "w1 ≼FI w3"
      using assms by blast
    lemma le_fininf_le_inf_transp[intro, trans]:
      assumes "w1 ≼FI w2" "w2 ≼I w3"
      shows "w1 ≼FI w3"
      using assms by blast
    lemma le_inf_transp[intro, trans]:
      assumes "w1 ≼I w2" "w2 ≼I w3"
      shows "w1 ≼I w3"
      using assms by blast

    lemma le_infI':
      assumes "⋀ k. ∃ v. v ≤FI w1 ∧ k < length v ∧ v ≼FI w2"
      shows "w1 ≼I w2"
    proof
      fix u
      assume 1: "u ≤FI w1"
      obtain v where 2: "v ≤FI w1" "length u < length v" "v ≼FI w2" using assms by auto
      have 3: "length u ≤ length v" using 2(2) by auto
      have 4: "u ≤ v" using prefix_fininf_length 1 2(1) 3 by this
      show "u ≼FI w2" using 4 2(3) by rule
    qed

    lemma le_infI_chain_left:
      assumes "chain w" "⋀ k. w k ≼FI v"
      shows "limit w ≼I v"
    proof (rule le_infI')
      fix k
      obtain l where 1: "k < length (w l)" using assms(1) by rule
      show "∃ va. va ≤FI limit w ∧ k < length va ∧ va ≼FI v"
      proof (intro exI conjI)
        show "w l ≤FI limit w" using chain_prefix_limit assms(1) by this
        show "k < length (w l)" using 1 by this
        show "w l ≼FI v" using assms(2) by this
      qed
    qed
    lemma le_infI_chain_right:
      assumes "chain w" "⋀ u. u ≤FI v ⟹ u ≼F w (l u)"
      shows "v ≼I limit w"
    proof
      fix u
      assume 1: "u ≤FI v"
      show "u ≼FI limit w"
      proof
        show "w (l u) ≤FI limit w" using chain_prefix_limit assms(1) by this
        show "u ≼F w (l u)" using assms(2) 1 by this
      qed
    qed
    lemma le_infI_chain_right':
      assumes "chain w" "⋀ k. stake k v ≼F w (l k)"
      shows "v ≼I limit w"
    proof (rule le_infI_chain_right)
      show "chain w" using assms(1) by this
    next
      fix u
      assume 1: "u ≤FI v"
      have 2: "stake (length u) v = u" using 1 by (simp add: prefix_fininf_def shift_eq)
      have 3: "stake (length u) v ≼F w (l (length u))" using assms(2) by this
      show "u ≼F w (l (length u))" using 3 unfolding 2 by this
    qed

    definition eq_inf :: "'item stream ⇒ 'item stream ⇒ bool" (infix ‹=I› 50)
      where "w1 =I w2 ≡ w1 ≼I w2 ∧ w2 ≼I w1"

    lemma eq_infI[intro 0]:
      assumes "w1 ≼I w2" "w2 ≼I w1"
      shows "w1 =I w2"
      using assms unfolding eq_inf_def by auto
    lemma eq_infE[elim 0]:
      assumes "w1 =I w2"
      obtains "w1 ≼I w2" "w2 ≼I w1"
      using assms unfolding eq_inf_def by auto

    lemma eq_inf_range[dest]: "w1 =I w2 ⟹ sset w1 = sset w2" by force

    lemma eq_inf_reflp[simp, intro]: "w =I w" by auto
    lemma eq_inf_symp[intro]: "w1 =I w2 ⟹ w2 =I w1" by auto
    lemma eq_inf_transp[intro, trans]:
      assumes "w1 =I w2" "w2 =I w3"
      shows "w1 =I w3"
      using assms by blast
    lemma le_fininf_eq_inf_transp[intro, trans]:
      assumes "w1 ≼FI w2" "w2 =I w3"
      shows "w1 ≼FI w3"
      using assms by blast
    lemma le_inf_eq_inf_transp[intro, trans]:
      assumes "w1 ≼I w2" "w2 =I w3"
      shows "w1 ≼I w3"
      using assms by blast
    lemma eq_inf_le_inf_transp[intro, trans]:
      assumes "w1 =I w2" "w2 ≼I w3"
      shows "w1 ≼I w3"
      using assms by blast
    lemma prefix_fininf_eq_inf_transp[intro, trans]:
      assumes "w1 ≤FI w2" "w2 =I w3"
      shows "w1 ≼FI w3"
      using assms by blast

    lemma le_inf_concat_start[iff]: "w @- w1 ≼I w @- w2 ⟷ w1 ≼I w2"
    proof
      assume 1: "w @- w1 ≼I w @- w2"
      show "w1 ≼I w2"
      proof
        fix v1
        assume 2: "v1 ≤FI w1"
        have "w @ v1 ≤FI w @- w1" using 2 by auto
        also have "… ≼I w @- w2" using 1 by this
        finally show "v1 ≼FI w2" by rule
      qed
    next
      assume 1: "w1 ≼I w2"
      show "w @- w1 ≼I w @- w2"
      proof
        fix v1
        assume 2: "v1 ≤FI w @- w1"
        then show "v1 ≼FI w @- w2"
        proof (cases rule: prefix_fininf_append)
          case (absorb)
          show ?thesis using absorb by auto
        next
          case (extend z)
          show ?thesis using 1 extend by auto
        qed
      qed
    qed
    lemma eq_fin_le_inf_concat_end[dest]: "w1 =F w2 ⟹ w1 @- w ≼I w2 @- w"
    proof
      fix v1
      assume 1: "w1 =F w2" "v1 ≤FI w1 @- w"
      show "v1 ≼FI w2 @- w"
      using 1(2)
      proof (cases rule: prefix_fininf_append)
        case (absorb)
        show ?thesis
        proof
          show "w2 ≤FI (w2 @- w)" by auto
          show "v1 ≼F w2" using absorb 1(1) by auto
        qed
      next
        case (extend w')
        show ?thesis
        proof
          show "w2 @ w' ≤FI (w2 @- w)" using extend(2) by auto
          show "v1 ≼F w2 @ w'" unfolding extend(1) using 1(1) by auto
        qed
      qed
    qed

    lemma eq_inf_concat_start[iff]: "w @- w1 =I w @- w2 ⟷ w1 =I w2" by blast
    lemma eq_inf_concat_end[dest]: "w1 =F w2 ⟹ w1 @- w =I w2 @- w"
    proof -
      assume 0: "w1 =F w2"
      have 1: "w2 =F w1" using 0 by auto
      show "w1 @- w =I w2 @- w"
        using eq_fin_le_inf_concat_end[OF 0] eq_fin_le_inf_concat_end[OF 1] by auto
    qed

    lemma le_fininf_suffixI[intro]:
      assumes "w =I w1 @- w2"
      shows "w1 ≼FI w"
      using assms by blast
    lemma le_fininf_suffixE[elim]:
      assumes "w1 ≼FI w"
      obtains w2
      where "w =I w1 @- w2"
    proof -
      obtain v2 where 1: "v2 ≤FI w" "w1 ≼F v2" using assms(1) by rule
      obtain u1 where 2: "w1 @ u1 =F v2" using 1(2) by rule
      obtain v2' where 3: "w = v2 @- v2'" using 1(1) by rule
      show ?thesis
      proof
        show "w =I w1 @- u1 @- v2'" unfolding 3 using 2 by fastforce
      qed
    qed

    lemma subsume_fin:
      assumes "u1 ≼FI w" "v1 ≼FI w"
      obtains w1
      where "u1 ≼F w1" "v1 ≼F w1"
    proof -
      obtain u2 where 2: "u2 ≤FI w" "u1 ≼F u2" using assms(1) by rule
      obtain v2 where 3: "v2 ≤FI w" "v1 ≼F v2" using assms(2) by rule
      show ?thesis
      proof (cases "length u2" "length v2" rule: le_cases)
        case le
        show ?thesis
        proof
          show "u1 ≼F v2" using 2(2) prefix_fininf_length[OF 2(1) 3(1) le] by auto
          show "v1 ≼F v2" using 3(2) by this
        qed
      next
        case ge
        show ?thesis
        proof
          show "u1 ≼F u2" using 2(2) by this
          show "v1 ≼F u2" using 3(2) prefix_fininf_length[OF 3(1) 2(1) ge] by auto
        qed
      qed
    qed

    lemma eq_fin_end:
      assumes "u1 =F u2" "u1 @ v1 =F u2 @ v2"
      shows "v1 =F v2"
    proof -
      have "u1 @ v2 =F u2 @ v2" using assms(1) by blast
      also have "… =F u1 @ v1" using assms(2) by blast
      finally show ?thesis by blast
    qed

    definition indoc :: "'item ⇒ 'item list ⇒ bool"
      where "indoc a u ≡ ∃ u1 u2. u = u1 @ [a] @ u2 ∧ a ∉ set u1 ∧ Ind {a} (set u1)"

    lemma indoc_set: "indoc a u ⟹ a ∈ set u" unfolding indoc_def by auto

    lemma indoc_appendI1[intro]:
      assumes "indoc a u"
      shows "indoc a (u @ v)"
      using assms unfolding indoc_def by force
    lemma indoc_appendI2[intro]:
      assumes "a ∉ set u" "Ind {a} (set u)" "indoc a v"
      shows "indoc a (u @ v)"
    proof -
      obtain v1 v2 where 1: "v = v1 @ [a] @ v2" "a ∉ set v1" "Ind {a} (set v1)"
        using assms(3) unfolding indoc_def by blast
      show ?thesis
      proof (unfold indoc_def, intro exI conjI)
        show "u @ v = (u @ v1) @ [a] @ v2" unfolding 1(1) by simp
        show "a ∉ set (u @ v1)" using assms(1) 1(2) by auto
        show "Ind {a} (set (u @ v1))" using assms(2) 1(3) by auto
      qed
    qed
    lemma indoc_appendE[elim!]:
      assumes "indoc a (u @ v)"
      obtains (first) "a ∈ set u" "indoc a u" | (second)  "a ∉ set u" "Ind {a} (set u)" "indoc a v"
    proof -
      obtain w1 w2 where 1: "u @ v = w1 @ [a] @ w2" "a ∉ set w1" "Ind {a} (set w1)"
        using assms unfolding indoc_def by blast
      show ?thesis
      proof (cases "a ∈ set u")
        case True
        obtain u1 u2 where 2: "u = u1 @ [a] @ u2" "a ∉ set u1"
          using split_list_first[OF True] by auto
        have 3: "w1 = u1"
        proof (rule split_list_first_unique)
          show "w1 @ [a] @ w2 = u1 @ [a] @ u2 @ v" using 1(1) unfolding 2(1) by simp
          show "a ∉ set w1" using 1(2) by auto
          show "a ∉ set u1" using 2(2) by this
        qed
        show ?thesis
        proof (rule first)
          show "a ∈ set u" using True by this
          show "indoc a u"
          proof (unfold indoc_def, intro exI conjI)
            show "u = u1 @ [a] @ u2" using 2(1) by this
            show "a ∉ set u1" using 1(2) unfolding 3 by this
            show "Ind {a} (set u1)" using 1(3) unfolding 3 by this
          qed
        qed
      next
        case False
        have 2: "a ∈ set v" using indoc_set assms False by fastforce
        obtain v1 v2 where 3: "v = v1 @ [a] @ v2" "a ∉ set v1"
          using split_list_first[OF 2] by auto
        have 4: "w1 = u @ v1"
        proof (rule split_list_first_unique)
          show "w1 @ [a] @ w2 = (u @ v1) @ [a] @ v2" using 1(1) unfolding 3(1) by simp
          show "a ∉ set w1" using 1(2) by auto
          show "a ∉ set (u @ v1)" using False 3(2) by auto
        qed
        show ?thesis
        proof (rule second)
          show "a ∉ set u" using False by this
          show "Ind {a} (set u)" using 1(3) 4 by auto
          show "indoc a v"
          proof (unfold indoc_def, intro exI conjI)
            show "v = v1 @ [a] @ v2" using 3(1) by this
            show "a ∉ set v1" using 1(2) unfolding 4 by auto
            show "Ind {a} (set v1)" using 1(3) unfolding 4 by auto
          qed
        qed
      qed
    qed

    lemma indoc_single: "indoc a [b] ⟷ a = b"
    proof
      assume 1: "indoc a [b]"
      obtain u1 u2 where 2: "[b] = u1 @ [a] @ u2" "Ind {a} (set u1)"
        using 1 unfolding indoc_def by auto
      show "a = b" using 2(1)
        by (metis append_eq_Cons_conv append_is_Nil_conv list.distinct(2) list.inject)
    next
      assume 1: "a = b"
      show "indoc a [b]"
      unfolding indoc_def 1
      proof (intro exI conjI)
        show "[b] = [] @ [b] @ []" by simp
        show "b ∉ set []" by simp
        show "Ind {b} (set [])" by simp
      qed
    qed

    lemma indoc_append[simp]: "indoc a (u @ v) ⟷
      indoc a u ∨ a ∉ set u ∧ Ind {a} (set u) ∧ indoc a v" by blast 
    lemma indoc_Nil[simp]: "indoc a [] ⟷ False" unfolding indoc_def by auto
    lemma indoc_Cons[simp]: "indoc a (b # v) ⟷ a = b ∨ a ≠ b ∧ ind a b ∧ indoc a v"
    proof -
      have "indoc a (b # v) ⟷ indoc a ([b] @ v)" by simp
      also have "… ⟷ indoc a [b] ∨ a ∉ set [b] ∧ Ind {a} (set [b]) ∧ indoc a v"
        unfolding indoc_append by rule
      also have "… ⟷ a = b ∨ a ≠ b ∧ ind a b ∧ indoc a v" unfolding indoc_single by simp
      finally show ?thesis by this
    qed

    lemma eq_swap_indoc: "u =S v ⟹ indoc c u ⟹ indoc c v" by auto
    lemma eq_fin_indoc: "u =F v ⟹ indoc c u ⟹ indoc c v" by (induct rule: rtranclp.induct, auto)

    lemma eq_fin_ind':
      assumes "[a] @ u =F u1 @ [a] @ u2" "a ∉ set u1"
      shows "Ind {a} (set u1)"
    proof -
      have 1: "indoc a ([a] @ u)" by simp
      have 2: "indoc a (u1 @ [a] @ u2)" using eq_fin_indoc assms(1) 1 by this
      show ?thesis using assms(2) 2 by blast
    qed
    lemma eq_fin_ind:
      assumes "u @ v =F v @ u" "set u ∩ set v = {}"
      shows "Ind (set u) (set v)"
    using assms
    proof (induct u)
      case Nil
      show ?case by simp
    next
      case (Cons a u)
      have 1: "Ind {a} (set v)"
      proof (rule eq_fin_ind')
        show "[a] @ u @ v =F v @ [a] @ u" using Cons(2) by simp
        show "a ∉ set v" using Cons(3) by simp
      qed
      have 2: "Ind (set [a]) (set v)" using 1 by simp
      have 4: "Ind (set u) (set v)"
      proof (rule Cons(1))
        have "[a] @ u @ v = (a # u) @ v" by simp
        also have "… =F v @ a # u" using Cons(2) by this
        also have "… = (v @ [a]) @ u" by simp
        also have "… =F ([a] @ v) @ u" using 2 by blast
        also have "… = [a] @ v @ u" by simp
        finally show "u @ v =F v @ u" by blast
        show "set u ∩ set v = {}" using Cons(3) by auto
      qed
      show ?case using 1 4 by auto
    qed

    lemma le_fin_member':
      assumes "[a] ≼F u @ v" "a ∈ set u"
      shows "[a] ≼F u"
    proof -
      obtain w where 1: "[a] @ w =F u @ v" using assms(1) by rule
      obtain u1 u2 where 2: "u = u1 @ [a] @ u2" "a ∉ set u1"
        using split_list_first[OF assms(2)] by auto
      have 3: "Ind {a} (set u1)"
      proof (rule eq_fin_ind')
        show "[a] @ w =F u1 @ [a] @ u2 @ v" using 1 unfolding 2(1) by simp
        show "a ∉ set u1" using 2(2) by this
      qed
      have 4: "Ind (set [a]) (set u1)" using 3 by simp
      have "[a] ≤ [a] @ u1 @ u2" by auto
      also have "… = ([a] @ u1) @ u2" by simp
      also have "… =F (u1 @ [a]) @ u2" using 4 by blast
      also have "… = u" unfolding 2(1) by simp
      finally show ?thesis by this
    qed
    lemma le_fin_not_member':
      assumes "[a] ≼F u @ v" "a ∉ set u"
      shows "[a] ≼F v"
    proof -
      obtain w where 1: "[a] @ w =F u @ v" using assms(1) by rule
      have 3: "a ∈ set v" using assms by auto
      obtain v1 v2 where 4: "v = v1 @ [a] @ v2" "a ∉ set v1" using split_list_first[OF 3] by auto
      have 5: "[a] @ w =F u @ v1 @ [a] @ v2" using 1 unfolding 4(1) by this
      have 6: "Ind {a} (set (u @ v1))"
      proof (rule eq_fin_ind')
        show "[a] @ w =F (u @ v1) @ [a] @ v2" using 5 by simp
        show "a ∉ set (u @ v1)" using assms(2) 4(2) by auto
      qed
      have 9: "Ind (set [a]) (set v1)" using 6 by auto
      have "[a] ≤ [a] @ v1 @ v2" by auto
      also have "… = ([a] @ v1) @ v2" by simp
      also have "… =F (v1 @ [a]) @ v2" using 9 by blast
      also have "… = v1 @ [a] @ v2" by simp
      also have "… = v" unfolding 4(1) by rule
      finally show ?thesis by this
    qed
    lemma le_fininf_not_member':
      assumes "[a] ≼FI u @- v" "a ∉ set u"
      shows "[a] ≼FI v"
    proof -
      obtain v2 where 1: "v2 ≤FI u @- v" "[a] ≼F v2" using le_fininfE assms(1) by this
      show ?thesis
      using 1(1)
      proof (cases rule: prefix_fininf_append)
        case absorb
        have "[a] ≼F v2" using 1(2) by this
        also have "… ≤ u" using absorb by this
        finally have 2: "a ∈ set u" by force
        show ?thesis using assms(2) 2 by simp
      next
        case (extend z)
        have "[a] ≼F v2" using 1(2) by this
        also have "… = u @ z" using extend(1) by this
        finally have 2: "[a] ≼F u @ z" by this
        have "[a] ≼F z" using le_fin_not_member' 2 assms(2) by this
        also have "… ≤FI v" using extend(2) by this
        finally show ?thesis by this
      qed
    qed

    lemma le_fin_ind'':
      assumes "[a] ≼F w" "[b] ≼F w" "a ≠ b"
      shows "ind a b"
    proof -
      obtain u where 1: "[a] @ u =F w" using assms(1) by rule
      obtain v where 2: "[b] @ v =F w" using assms(2) by rule
      have 3: "[a] @ u =F [b] @ v" using 1 2[symmetric] by auto
      have 4: "a ∈ set v" using 3 assms(3)
        by (metis append_Cons append_Nil eq_fin_range list.set_intros(1) set_ConsD)
      obtain v1 v2 where 5: "v = v1 @ [a] @ v2" "a ∉ set v1" using split_list_first[OF 4] by auto
      have 7: "Ind {a} (set ([b] @ v1))"
      proof (rule eq_fin_ind')
        show "[a] @ u =F ([b] @ v1) @ [a] @ v2" using 3 unfolding 5(1) by simp
        show "a ∉ set ([b] @ v1)" using assms(3) 5(2) by auto
      qed
      show ?thesis using 7 by auto
    qed
    lemma le_fin_ind':
      assumes "[a] ≼F w" "v ≼F w" "a ∉ set v"
      shows "Ind {a} (set v)"
    using assms
    proof (induct v arbitrary: w)
      case Nil
      show ?case by simp
    next
      case (Cons b v)
      have 1: "ind a b"
      proof (rule le_fin_ind'')
        show "[a] ≼F w" using Cons(2) by this
        show "[b] ≼F w" using Cons(3) by auto
        show "a ≠ b" using Cons(4) by auto
      qed
      obtain w' where 2: "[b] @ w' =F w" using Cons(3) by auto
      have 3: "Ind {a} (set v)"
      proof (rule Cons(1))
        show "[a] ≼F w'"
        proof (rule le_fin_not_member')
          show "[a] ≼F [b] @ w'" using Cons(2) 2 by auto
          show "a ∉ set [b]" using Cons(4) by auto
        qed
        have "[b] @ v = b # v" by simp
        also have "… ≼F w" using Cons(3) by this
        also have "… =F [b] @ w'" using 2 by auto
        finally show "v ≼F w'" by blast
        show "a ∉ set v" using Cons(4) by auto
      qed
      show ?case using 1 3 by auto
    qed
    lemma le_fininf_ind'':
      assumes "[a] ≼FI w" "[b] ≼FI w" "a ≠ b"
      shows "ind a b"
      using subsume_fin le_fin_ind'' assms by metis
    lemma le_fininf_ind':
      assumes "[a] ≼FI w" "v ≼FI w" "a ∉ set v"
      shows "Ind {a} (set v)"
      using subsume_fin le_fin_ind' assms by metis

    lemma indoc_alt_def: "indoc a v ⟷ v =F [a] @ remove1 a v"
    proof
      assume 0: "indoc a v"
      obtain v1 v2 where 1: "v = v1 @ [a] @ v2" "a ∉ set v1" "Ind {a} (set v1)"
        using 0 unfolding indoc_def by blast
      have 2: "Ind (set [a]) (set v1)" using 1(3) by simp
      have "v = v1 @ [a] @ v2" using 1(1) by this
      also have "… = (v1 @ [a]) @ v2" by simp
      also have "… =F ([a] @ v1) @ v2" using 2 by blast
      also have "… = [a] @ v1 @ v2" by simp
      also have "… = [a] @ remove1 a v" unfolding 1(1) remove1_append using 1(2) by auto
      finally show "v =F [a] @ remove1 a v" by this
    next
      assume 0: "v =F [a] @ remove1 a v"
      have 1: "indoc a ([a] @ remove1 a v)" by simp
      show "indoc a v" using eq_fin_indoc 0  1 by blast
    qed

    lemma levi_lemma:
      assumes "t @ u =F v @ w"
      obtains p r s q
      where "t =F p @ r" "u =F s @ q" "v =F p @ s" "w =F r @ q" "Ind (set r) (set s)"
    using assms
    proof (induct t arbitrary: thesis v w)
      case Nil
      show ?case
      proof (rule Nil(1))
        show "[] =F [] @ []" by simp
        show "v =F [] @ v" by simp
        show "u =F v @ w" using Nil(2) by simp
        show "w =F [] @ w" by simp
        show "Ind (set []) (set v)" by simp
      qed
    next
      case (Cons a t')
      have 1: "[a] ≼F v @ w" using Cons(3) by blast
      show ?case
      proof (cases "a ∈ set v")
        case False
        have 2: "[a] ≼F w" using le_fin_not_member' 1 False by this
        obtain w' where 3: "w =F [a] @ w'" using 2 by blast
        have 4: "v ≼F v @ w" by auto
        have 5: "Ind (set [a]) (set v)" using le_fin_ind'[OF 1 4] False by simp
        have "[a] @ t' @ u = (a # t') @ u" by simp
        also have "… =F v @ w" using Cons(3) by this
        also have "… =F v @ [a] @ w'" using 3 by blast
        also have "… = (v @ [a]) @ w'" by simp
        also have "… =F ([a] @ v) @ w'" using 5 by blast
        also have "… = [a] @ v @ w'" by simp
        finally have 6: "t' @ u =F v @ w'" by blast
        obtain p r' s q where 7: "t' =F p @ r'" "u =F s @ q" "v =F p @ s" "w' =F r' @ q"
          "Ind (set r') (set s)" using Cons(1)[OF _ 6] by this
        have 8: "set v = set p ∪ set s" using eq_fin_range 7(3) by auto
        have 9: "Ind (set [a]) (set p)" using 5 8 by auto
        have 10: "Ind (set [a]) (set s)" using 5 8 by auto
        show ?thesis
        proof (rule Cons(2))
          have "a # t' = [a] @ t'" by simp
          also have "… =F [a] @ p @ r'" using 7(1) by blast
          also have "… = ([a] @ p) @ r'" by simp
          also have "… =F (p @ [a]) @ r'" using 9 by blast
          also have "… = p @ [a] @ r'" by simp
          finally show "a # t' =F p @ [a] @ r'" by this
          show "u =F s @ q" using 7(2) by this
          show "v =F p @ s" using 7(3) by this
          have "w =F [a] @ w'" using 3 by this
          also have "… =F [a] @ r' @ q" using 7(4) by blast
          also have "… = ([a] @ r') @ q" by simp
          finally show "w =F ([a] @ r') @ q" by this
          show "Ind (set ([a] @ r')) (set s)" using 7(5) 10 by auto
        qed
      next
        case True
        have 2: "[a] ≼F v" using le_fin_member' 1 True by this
        obtain v' where 3: "v =F [a] @ v'" using 2 by blast
        have "[a] @ t' @ u = (a # t') @ u" by simp
        also have "… =F v @ w" using Cons(3) by this
        also have "… =F ([a] @ v') @ w" using 3 by blast
        also have "… = [a] @ v' @ w" by simp
        finally have 4: "t' @ u =F v' @ w" by blast
        obtain p' r s q where 7: "t' =F p' @ r" "u =F s @ q" "v' =F p' @ s" "w =F r @ q"
          "Ind (set r) (set s)" using Cons(1)[OF _ 4] by this
        show ?thesis
        proof (rule Cons(2))
          have "a # t' = [a] @ t'" by simp
          also have "… =F [a] @ p' @ r" using 7(1) by blast
          also have "… = ([a] @ p') @ r" by simp
          finally show "a # t' =F ([a] @ p') @ r" by this
          show "u =F s @ q" using 7(2) by this
          have "v =F [a] @ v'" using 3 by this
          also have "… =F [a] @ p' @ s" using 7(3) by blast
          also have "… = ([a] @ p') @ s" by simp
          finally show "v =F ([a] @ p') @ s" by this
          show "w =F r @ q" using 7(4) by this
          show "Ind (set r) (set s)" using 7(5) by this
        qed
      qed
    qed

  end

end