[STATEMENT]
lemma resPres:
  fixes P    :: pi
  and   Q    :: pi
  and   Rel  :: "(pi \<times> pi) set"
  and   x    :: name
  and   Rel' :: "(pi \<times> pi) set"

  assumes PSimQ: "P \<leadsto>\<^sup>^<Rel> Q"
  and     ResRel: "\<And>(P::pi) (Q::pi) (x::name). (P, Q) \<in> Rel \<Longrightarrow> (<\<nu>x>P, <\<nu>x>Q) \<in> Rel'"
  and     RelRel': "Rel \<subseteq> Rel'"
  and     EqvtRel: "eqvt Rel"
  and     EqvtRel': "eqvt Rel'"

  shows "<\<nu>x>P \<leadsto>\<^sup>^<Rel'> <\<nu>x>Q"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>P \<leadsto>\<^sup>^<Rel'> <\<nu>x>Q
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. <\<nu>x>P \<leadsto>\<^sup>^<Rel'> <\<nu>x>Q
[PROOF STEP]
from EqvtRel'
[PROOF STATE]
proof (chain)
picking this:
eqvt Rel'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
eqvt Rel'

goal (1 subgoal):
 1. <\<nu>x>P \<leadsto>\<^sup>^<Rel'> <\<nu>x>Q
[PROOF STEP]
proof(induct rule: simCasesCont[of _ "(P, Q, x)"])
[PROOF STATE]
proof (state)
goal (3 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<\<nu>xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>xa> \<prec> P' \<and> (P', Q') \<in> Rel'
 2. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 3. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
case(Bound Q' a y)
[PROOF STATE]
proof (state)
this:
y \<sharp> (P, Q, x)
<\<nu>x>Q \<longmapsto> a<\<nu>y> \<prec> Q'

goal (3 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<\<nu>xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>xa> \<prec> P' \<and> (P', Q') \<in> Rel'
 2. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 3. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
have Trans: "<\<nu>x>Q \<longmapsto>a<\<nu>y> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>Q \<longmapsto> a<\<nu>y> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
<\<nu>x>Q \<longmapsto> a<\<nu>y> \<prec> Q'

goal (3 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<\<nu>xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>xa> \<prec> P' \<and> (P', Q') \<in> Rel'
 2. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 3. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
have "y \<sharp> (P, Q, x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. y \<sharp> (P, Q, x)
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
y \<sharp> (P, Q, x)

goal (3 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<\<nu>xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>xa> \<prec> P' \<and> (P', Q') \<in> Rel'
 2. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 3. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
hence yineqx: "y \<noteq> x" and yFreshP: "y \<sharp> P" and "y \<sharp> Q"
[PROOF STATE]
proof (prove)
using this:
y \<sharp> (P, Q, x)

goal (1 subgoal):
 1. y \<noteq> x &&& y \<sharp> P &&& y \<sharp> Q
[PROOF STEP]
by(simp add: fresh_prod)+
[PROOF STATE]
proof (state)
this:
y \<noteq> x
y \<sharp> P
y \<sharp> Q

goal (3 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<\<nu>xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>xa> \<prec> P' \<and> (P', Q') \<in> Rel'
 2. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 3. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
from Trans \<open>y \<noteq> x\<close> \<open>y \<sharp> Q\<close>
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>Q \<longmapsto> a<\<nu>y> \<prec> Q'
y \<noteq> x
y \<sharp> Q
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>Q \<longmapsto> a<\<nu>y> \<prec> Q'
y \<noteq> x
y \<sharp> Q

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
proof(induct rule: resCasesB)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
case(cOpen a Q')
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a[x] \<prec> Q'
a \<noteq> x
BoundOutputS a__ = BoundOutputS a

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
have QTrans: "Q \<longmapsto>a[x] \<prec> Q'" and aineqx: "a \<noteq> x"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Q \<longmapsto> a[x] \<prec> Q' &&& a \<noteq> x
[PROOF STEP]
by fact+
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a[x] \<prec> Q'
a \<noteq> x

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from PSimQ QTrans
[PROOF STATE]
proof (chain)
picking this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> a[x] \<prec> Q'
[PROOF STEP]
obtain P' where PTrans: "P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'"
                                    and P'RelQ': "(P', Q') \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> a[x] \<prec> Q'

goal (1 subgoal):
 1. (\<And>P'. \<lbrakk>P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'; (P', Q') \<in> Rel\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(blast dest: simE)
[PROOF STATE]
proof (state)
this:
P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'
(P', Q') \<in> Rel

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> ([(y, x)] \<bullet> P')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
from PTrans aineqx
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'
a \<noteq> x
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'"
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'
a \<noteq> x

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'
[PROOF STEP]
by(rule Weak_Late_Semantics.Open)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
from PTrans yFreshP
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'
y \<sharp> P
[PROOF STEP]
have "y \<sharp> P'"
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>l\<^sup>^a[x] \<prec> P'
y \<sharp> P

goal (1 subgoal):
 1. y \<sharp> P'
[PROOF STEP]
by(force intro: freshTransition)
[PROOF STATE]
proof (state)
this:
y \<sharp> P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'
y \<sharp> P'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>x> \<prec> P'
y \<sharp> P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
[PROOF STEP]
by(simp add: alphaBoundResidual name_swap)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from EqvtRel P'RelQ' RelRel'
[PROOF STATE]
proof (chain)
picking this:
eqvt Rel
(P', Q') \<in> Rel
Rel \<subseteq> Rel'
[PROOF STEP]
have "([(y, x)] \<bullet> P', [(y, x)] \<bullet> Q') \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
eqvt Rel
(P', Q') \<in> Rel
Rel \<subseteq> Rel'

goal (1 subgoal):
 1. ([(y, x)] \<bullet> P', [(y, x)] \<bullet> Q') \<in> Rel'
[PROOF STEP]
by(blast intro: eqvtRelI)
[PROOF STATE]
proof (state)
this:
([(y, x)] \<bullet> P', [(y, x)] \<bullet> Q') \<in> Rel'

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; BoundOutputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^b<\<nu>y> \<prec> P'a \<and> (P'a, [(y, x)] \<bullet> P') \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
([(y, x)] \<bullet> P', [(y, x)] \<bullet> Q') \<in> Rel'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> [(y, x)] \<bullet> P'
([(y, x)] \<bullet> P', [(y, x)] \<bullet> Q') \<in> Rel'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', [(y, x)] \<bullet> Q') \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', [(y, x)] \<bullet> Q') \<in> Rel'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a__<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a__\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a__<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
case(cRes Q')
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a<\<nu>y> \<prec> Q'
x \<sharp> BoundOutputS a

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
have QTrans: "Q \<longmapsto>a<\<nu>y> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Q \<longmapsto> a<\<nu>y> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a<\<nu>y> \<prec> Q'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from \<open>x \<sharp> BoundOutputS a\<close>
[PROOF STATE]
proof (chain)
picking this:
x \<sharp> BoundOutputS a
[PROOF STEP]
have "x \<noteq> a"
[PROOF STATE]
proof (prove)
using this:
x \<sharp> BoundOutputS a

goal (1 subgoal):
 1. x \<noteq> a
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x \<noteq> a

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from PSimQ yFreshP QTrans
[PROOF STATE]
proof (chain)
picking this:
P \<leadsto>\<^sup>^<Rel> Q
y \<sharp> P
Q \<longmapsto> a<\<nu>y> \<prec> Q'
[PROOF STEP]
obtain P' where PTrans: "P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'"
                                            and P'RelQ': "(P', Q') \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
P \<leadsto>\<^sup>^<Rel> Q
y \<sharp> P
Q \<longmapsto> a<\<nu>y> \<prec> Q'

goal (1 subgoal):
 1. (\<And>P'. \<lbrakk>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'; (P', Q') \<in> Rel\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(blast dest: simE)
[PROOF STATE]
proof (state)
this:
P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'
(P', Q') \<in> Rel

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from PTrans \<open>x \<noteq> a\<close> yineqx yFreshP
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'
x \<noteq> a
y \<noteq> x
y \<sharp> P
[PROOF STEP]
have ResTrans: "<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> (<\<nu>x>P')"
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'
x \<noteq> a
y \<noteq> x
y \<sharp> P

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> <\<nu>x>P'
[PROOF STEP]
by(blast intro: Weak_Late_Semantics.ResB)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from P'RelQ'
[PROOF STATE]
proof (chain)
picking this:
(P', Q') \<in> Rel
[PROOF STEP]
have "((<\<nu>x>P'), (<\<nu>x>Q')) \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
(P', Q') \<in> Rel

goal (1 subgoal):
 1. (<\<nu>x>P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
by(rule ResRel)
[PROOF STATE]
proof (state)
this:
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<\<nu>y> \<prec> P'; x \<sharp> BoundOutputS a\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', <\<nu>x>Q') \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^a<\<nu>y> \<prec> P' \<and> (P', Q') \<in> Rel'

goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
case(Input Q' a y)
[PROOF STATE]
proof (state)
this:
y \<sharp> (P, Q, x)
<\<nu>x>Q \<longmapsto> a<y> \<prec> Q'

goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
have "y \<sharp> (P, Q, x)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. y \<sharp> (P, Q, x)
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
y \<sharp> (P, Q, x)

goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
hence yineqx: "y \<noteq> x" and yFreshP: "y \<sharp> P" and "y \<sharp> Q"
[PROOF STATE]
proof (prove)
using this:
y \<sharp> (P, Q, x)

goal (1 subgoal):
 1. y \<noteq> x &&& y \<sharp> P &&& y \<sharp> Q
[PROOF STEP]
by(simp add: fresh_prod)+
[PROOF STATE]
proof (state)
this:
y \<noteq> x
y \<sharp> P
y \<sharp> Q

goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
have "<\<nu>x>Q \<longmapsto>a<y> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>Q \<longmapsto> a<y> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
<\<nu>x>Q \<longmapsto> a<y> \<prec> Q'

goal (2 subgoals):
 1. \<And>Q' a xa. \<lbrakk>xa \<sharp> (P, Q, x); <\<nu>x>Q \<longmapsto> a<xa> \<prec> Q'\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<xa> \<prec> P' \<and> (P', Q'[xa::=u]) \<in> Rel'
 2. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>Q \<longmapsto> a<y> \<prec> Q'

goal (1 subgoal):
 1. \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel'
[PROOF STEP]
using yineqx \<open>y \<sharp> Q\<close>
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>Q \<longmapsto> a<y> \<prec> Q'
y \<noteq> x
y \<sharp> Q

goal (1 subgoal):
 1. \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel'
[PROOF STEP]
proof(induct rule: resCasesB)
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; InputS a = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, ([(y, x)] \<bullet> P')[y::=u]) \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
case(cOpen a Q')
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a[x] \<prec> Q'
a \<noteq> x
InputS a__ = BoundOutputS a

goal (2 subgoals):
 1. \<And>b P'. \<lbrakk>Q \<longmapsto> b[x] \<prec> P'; b \<noteq> x; InputS a__ = BoundOutputS b\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a__<y> \<prec> P'a \<and> (P'a, ([(y, x)] \<bullet> P')[y::=u]) \<in> Rel'
 2. \<And>P'. \<lbrakk>Q \<longmapsto> a__<y> \<prec> P'; x \<sharp> InputS a__\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a__<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
Q \<longmapsto> a[x] \<prec> Q'
a \<noteq> x
InputS a__ = BoundOutputS a

goal (1 subgoal):
 1. \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a__<y> \<prec> P' \<and> (P', ([(y, x)] \<bullet> Q')[y::=u]) \<in> Rel'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a__<y> \<prec> P' \<and> (P', ([(y, x)] \<bullet> Q')[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a__<y> \<prec> P'; x \<sharp> InputS a__\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a__<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
case(cRes Q')
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a<y> \<prec> Q'
x \<sharp> InputS a

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
have QTrans: "Q \<longmapsto>a<y> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Q \<longmapsto> a<y> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> a<y> \<prec> Q'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
from \<open>x \<sharp> InputS a\<close>
[PROOF STATE]
proof (chain)
picking this:
x \<sharp> InputS a
[PROOF STEP]
have "x \<noteq> a"
[PROOF STATE]
proof (prove)
using this:
x \<sharp> InputS a

goal (1 subgoal):
 1. x \<noteq> a
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
x \<noteq> a

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
from PSimQ QTrans yFreshP
[PROOF STATE]
proof (chain)
picking this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> a<y> \<prec> Q'
y \<sharp> P
[PROOF STEP]
obtain P''
        where L1: "\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> a<y> \<prec> Q'
y \<sharp> P

goal (1 subgoal):
 1. (\<And>P''. \<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(blast dest: simE)
[PROOF STATE]
proof (state)
this:
\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
have "\<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in (<\<nu>x>P'')\<rightarrow>a<y> \<prec> P' \<and> (P', (<\<nu>x>Q')[y::=u]) \<in> Rel'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
proof(rule allI)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
fix u
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
show "\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', (<\<nu>x>Q')[y::=u]) \<in> Rel'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
proof(cases "x=u")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
assume xequ: "x=u"
[PROOF STATE]
proof (state)
this:
x = u

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
have "\<exists>c::name. c \<sharp> (P, P'', Q', x, y, a)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<exists>c. c \<sharp> (P, P'', Q', x, y, a)
[PROOF STEP]
by(blast intro: name_exists_fresh)
[PROOF STATE]
proof (state)
this:
\<exists>c. c \<sharp> (P, P'', Q', x, y, a)

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<exists>c. c \<sharp> (P, P'', Q', x, y, a)
[PROOF STEP]
obtain c::name where cFreshP: "c \<sharp> P" and cFreshP'': "c \<sharp> P''" and cFreshQ': "c \<sharp> Q'"
                                and cineqx: "c \<noteq> x" and cineqy: "c \<noteq> y" and cineqa: "c \<noteq> a"
[PROOF STATE]
proof (prove)
using this:
\<exists>c. c \<sharp> (P, P'', Q', x, y, a)

goal (1 subgoal):
 1. (\<And>c. \<lbrakk>c \<sharp> P; c \<sharp> P''; c \<sharp> Q'; c \<noteq> x; c \<noteq> y; c \<noteq> a\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(force simp add: fresh_prod)
[PROOF STATE]
proof (state)
this:
c \<sharp> P
c \<sharp> P''
c \<sharp> Q'
c \<noteq> x
c \<noteq> y
c \<noteq> a

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
from L1
[PROOF STATE]
proof (chain)
picking this:
\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel
[PROOF STEP]
obtain P' where PTrans: "P \<Longrightarrow>\<^sub>lc in P''\<rightarrow>a<y> \<prec> P'"
                              and P'RelQ': "(P', Q'[y::=c]) \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel

goal (1 subgoal):
 1. (\<And>P'. \<lbrakk>P \<Longrightarrow>\<^sub>lc in P''\<rightarrow>a<y> \<prec> P'; (P', Q'[y::=c]) \<in> Rel\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
P \<Longrightarrow>\<^sub>lc in P''\<rightarrow>a<y> \<prec> P'
(P', Q'[y::=c]) \<in> Rel

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>lu in (<\<nu>x>P'')\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
from PTrans yineqx \<open>x \<noteq> a\<close> cineqx
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>lc in P''\<rightarrow>a<y> \<prec> P'
y \<noteq> x
x \<noteq> a
c \<noteq> x
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>lc in (<\<nu>x>P'')\<rightarrow>a<y> \<prec> <\<nu>x>P'"
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>lc in P''\<rightarrow>a<y> \<prec> P'
y \<noteq> x
x \<noteq> a
c \<noteq> x

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lc in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'
[PROOF STEP]
by(blast intro: Weak_Late_Step_Semantics.ResB)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lc in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
hence "([(x, c)] \<bullet> <\<nu>x>P) \<Longrightarrow>\<^sub>l([(x, c)] \<bullet> c) in ([(x, c)] \<bullet> <\<nu>x>P'')\<rightarrow>([(x, c)] \<bullet> a)<([(x, c)] \<bullet> y)> \<prec> [(x, c)] \<bullet> <\<nu>x>P'"
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>lc in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. [(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'
[PROOF STEP]
by(rule Weak_Late_Step_Semantics.eqvtI)
[PROOF STATE]
proof (state)
this:
[(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
[(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
from cFreshP
[PROOF STATE]
proof (chain)
picking this:
c \<sharp> P
[PROOF STEP]
have "<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P"
[PROOF STATE]
proof (prove)
using this:
c \<sharp> P

goal (1 subgoal):
 1. <\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P
[PROOF STEP]
by(simp add: alphaRes)
[PROOF STATE]
proof (state)
this:
<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
from cFreshP''
[PROOF STATE]
proof (chain)
picking this:
c \<sharp> P''
[PROOF STEP]
have "<\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''"
[PROOF STATE]
proof (prove)
using this:
c \<sharp> P''

goal (1 subgoal):
 1. <\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''
[PROOF STEP]
by(simp add: alphaRes)
[PROOF STATE]
proof (state)
this:
<\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
[(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'
<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P
<\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
[(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'
<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P
<\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
using \<open>x \<noteq> a\<close> cineqa yineqx cineqy cineqx xequ
[PROOF STATE]
proof (prove)
using this:
[(x, c)] \<bullet> <\<nu>x>P \<Longrightarrow>\<^sub>l[(x, c)] \<bullet> c in [(x, c)] \<bullet> <\<nu>x>P''\<rightarrow>[(x, c)] \<bullet> a<[(x, c)] \<bullet> y> \<prec> [(x, c)] \<bullet> <\<nu>x>P'
<\<nu>c>([(x, c)] \<bullet> P) = <\<nu>x>P
<\<nu>c>([(x, c)] \<bullet> P'') = <\<nu>x>P''
x \<noteq> a
c \<noteq> a
y \<noteq> x
c \<noteq> y
c \<noteq> x
x = u

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
[PROOF STEP]
by(simp add: name_calc)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
have "(<\<nu>c>([(x, c)] \<bullet> P'), (<\<nu>x>Q')[y::=u]) \<in> Rel'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
from P'RelQ'
[PROOF STATE]
proof (chain)
picking this:
(P', Q'[y::=c]) \<in> Rel
[PROOF STEP]
have "(<\<nu>x>P', <\<nu>x>(Q'[y::=c])) \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
(P', Q'[y::=c]) \<in> Rel

goal (1 subgoal):
 1. (<\<nu>x>P', <\<nu>x>Q'[y::=c]) \<in> Rel'
[PROOF STEP]
by(rule ResRel)
[PROOF STATE]
proof (state)
this:
(<\<nu>x>P', <\<nu>x>Q'[y::=c]) \<in> Rel'

goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
with EqvtRel'
[PROOF STATE]
proof (chain)
picking this:
eqvt Rel'
(<\<nu>x>P', <\<nu>x>Q'[y::=c]) \<in> Rel'
[PROOF STEP]
have "([(x, c)] \<bullet> <\<nu>x>P', [(x, c)] \<bullet> <\<nu>x>(Q'[y::=c])) \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
eqvt Rel'
(<\<nu>x>P', <\<nu>x>Q'[y::=c]) \<in> Rel'

goal (1 subgoal):
 1. ([(x, c)] \<bullet> <\<nu>x>P', [(x, c)] \<bullet> <\<nu>x>Q'[y::=c]) \<in> Rel'
[PROOF STEP]
by(rule eqvtRelI)
[PROOF STATE]
proof (state)
this:
([(x, c)] \<bullet> <\<nu>x>P', [(x, c)] \<bullet> <\<nu>x>Q'[y::=c]) \<in> Rel'

goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
with cineqy yineqx cineqx
[PROOF STATE]
proof (chain)
picking this:
c \<noteq> y
y \<noteq> x
c \<noteq> x
([(x, c)] \<bullet> <\<nu>x>P', [(x, c)] \<bullet> <\<nu>x>Q'[y::=c]) \<in> Rel'
[PROOF STEP]
have "(<\<nu>c>([(x, c)] \<bullet> P'), (<\<nu>c>([(x, c)] \<bullet> Q'))[y::=x]) \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
c \<noteq> y
y \<noteq> x
c \<noteq> x
([(x, c)] \<bullet> <\<nu>x>P', [(x, c)] \<bullet> <\<nu>x>Q'[y::=c]) \<in> Rel'

goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>c>([(x, c)] \<bullet> Q')[y::=x]) \<in> Rel'
[PROOF STEP]
by(simp add: name_calc eqvt_subs)
[PROOF STATE]
proof (state)
this:
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>c>([(x, c)] \<bullet> Q')[y::=x]) \<in> Rel'

goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
with cFreshQ' xequ
[PROOF STATE]
proof (chain)
picking this:
c \<sharp> Q'
x = u
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>c>([(x, c)] \<bullet> Q')[y::=x]) \<in> Rel'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
c \<sharp> Q'
x = u
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>c>([(x, c)] \<bullet> Q')[y::=x]) \<in> Rel'

goal (1 subgoal):
 1. (<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
by(simp add: alphaRes)
[PROOF STATE]
proof (state)
this:
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (2 subgoals):
 1. x = u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
 2. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>c>([(x, c)] \<bullet> P')
(<\<nu>c>([(x, c)] \<bullet> P'), <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
assume xinequ: "x \<noteq> u"
[PROOF STATE]
proof (state)
this:
x \<noteq> u

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
from L1
[PROOF STATE]
proof (chain)
picking this:
\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel
[PROOF STEP]
obtain P' where PTrans: "P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'"
                             and P'RelQ': "(P', Q'[y::=u]) \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
\<forall>u. \<exists>P'. P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel

goal (1 subgoal):
 1. (\<And>P'. \<lbrakk>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'; (P', Q'[y::=u]) \<in> Rel\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'
(P', Q'[y::=u]) \<in> Rel

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
from PTrans \<open>x \<noteq> a\<close> yineqx xinequ
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'
x \<noteq> a
y \<noteq> x
x \<noteq> u
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>lu in (<\<nu>x>P'')\<rightarrow>a<y> \<prec> <\<nu>x>P'"
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'
x \<noteq> a
y \<noteq> x
x \<noteq> u

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'
[PROOF STEP]
by(blast intro: Weak_Late_Step_Semantics.ResB)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
from P'RelQ' xinequ yineqx
[PROOF STATE]
proof (chain)
picking this:
(P', Q'[y::=u]) \<in> Rel
x \<noteq> u
y \<noteq> x
[PROOF STEP]
have "(<\<nu>x>P', (<\<nu>x>Q')[y::=u]) \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
(P', Q'[y::=u]) \<in> Rel
x \<noteq> u
y \<noteq> x

goal (1 subgoal):
 1. (<\<nu>x>P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
by(force intro: ResRel)
[PROOF STATE]
proof (state)
this:
(<\<nu>x>P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. x \<noteq> u \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> a<y> \<prec> P'; x \<sharp> InputS a\<rbrakk> \<Longrightarrow> \<exists>P''. \<forall>u. \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P'a \<and> (P'a, <\<nu>x>P'[y::=u]) \<in> Rel'
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
\<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in <\<nu>x>P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', <\<nu>x>Q'[y::=u]) \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>P''. \<forall>u. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>lu in P''\<rightarrow>a<y> \<prec> P' \<and> (P', Q'[y::=u]) \<in> Rel'

goal (1 subgoal):
 1. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
case(Free Q' \<alpha>)
[PROOF STATE]
proof (state)
this:
<\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q'

goal (1 subgoal):
 1. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
have "<\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
<\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q'

goal (1 subgoal):
 1. \<And>Q' \<alpha>. <\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q' \<Longrightarrow> \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>Q \<longmapsto> \<alpha> \<prec> Q'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'
[PROOF STEP]
proof(induct rule: resCasesF)
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
case(cRes Q')
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> \<alpha> \<prec> Q'
x \<sharp> \<alpha>

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
have "Q \<longmapsto>\<alpha> \<prec> Q'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Q \<longmapsto> \<alpha> \<prec> Q'
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
Q \<longmapsto> \<alpha> \<prec> Q'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
with PSimQ
[PROOF STATE]
proof (chain)
picking this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> \<alpha> \<prec> Q'
[PROOF STEP]
obtain P' where PTrans: "P \<Longrightarrow>\<^sub>l\<^sup>^ \<alpha> \<prec> P'"
                             and P'RelQ': "(P', Q') \<in> Rel"
[PROOF STATE]
proof (prove)
using this:
P \<leadsto>\<^sup>^<Rel> Q
Q \<longmapsto> \<alpha> \<prec> Q'

goal (1 subgoal):
 1. (\<And>P'. \<lbrakk>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'; (P', Q') \<in> Rel\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by(blast dest: simE)
[PROOF STATE]
proof (state)
this:
P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'
(P', Q') \<in> Rel

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
have "<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
[PROOF STEP]
proof -
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
[PROOF STEP]
have xFreshAlpha: "x \<sharp> \<alpha>"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. x \<sharp> \<alpha>
[PROOF STEP]
by fact
[PROOF STATE]
proof (state)
this:
x \<sharp> \<alpha>

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
[PROOF STEP]
with PTrans
[PROOF STATE]
proof (chain)
picking this:
P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'
x \<sharp> \<alpha>
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'
x \<sharp> \<alpha>

goal (1 subgoal):
 1. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
[PROOF STEP]
by(rule ResF)
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
from P'RelQ'
[PROOF STATE]
proof (chain)
picking this:
(P', Q') \<in> Rel
[PROOF STEP]
have "(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'"
[PROOF STATE]
proof (prove)
using this:
(P', Q') \<in> Rel

goal (1 subgoal):
 1. (<\<nu>x>P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
by(rule ResRel)
[PROOF STATE]
proof (state)
this:
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'

goal (1 subgoal):
 1. \<And>P'. \<lbrakk>Q \<longmapsto> \<alpha> \<prec> P'; x \<sharp> \<alpha>\<rbrakk> \<Longrightarrow> \<exists>P'a. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P'a \<and> (P'a, <\<nu>x>P') \<in> Rel'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
using this:
<\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> <\<nu>x>P'
(<\<nu>x>P', <\<nu>x>Q') \<in> Rel'

goal (1 subgoal):
 1. \<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', <\<nu>x>Q') \<in> Rel'
[PROOF STEP]
by blast
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', <\<nu>x>Q') \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>P'. <\<nu>x>P \<Longrightarrow>\<^sub>l\<^sup>^\<alpha> \<prec> P' \<and> (P', Q') \<in> Rel'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
<\<nu>x>P \<leadsto>\<^sup>^<Rel'> <\<nu>x>Q

goal:
No subgoals!
[PROOF STEP]
qed


[STATEMENT]
lemma InvariantConflictFlagCharacterizationAfterApplyUnitPropagate:
assumes
  "InvariantConsistent (getM state)"
  "InvariantUniq (getM state)"
  "InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)" and
  "InvariantWatchListsUniq (getWatchList state)" and
  "InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)"
  "InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)" and
  "InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)" and
  "InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)"
  "InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)"
  "InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)"
  "\<not> getConflictFlag state"
  "getQ state \<noteq> []"
shows
  "let state' = (applyUnitPropagate state) in
      InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
let ?uLiteral = "hd (getQ state)"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
let ?state' = "assertLiteral ?uLiteral False state"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
let ?state'' = "applyUnitPropagate state"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
have "InvariantConsistent (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []

goal (1 subgoal):
 1. InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
using InvariantConsistentAfterApplyUnitPropagate[of "state"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantConsistent (getM state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); getQ state \<noteq> []; \<not> getConflictFlag state\<rbrakk> \<Longrightarrow> let state' = applyUnitPropagate state in InvariantConsistent (getM state')

goal (1 subgoal):
 1. InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
unfolding applyUnitPropagate_def
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantConsistent (getM state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); getQ state \<noteq> []; \<not> getConflictFlag state\<rbrakk> \<Longrightarrow> let state' = let state' = assertLiteral (hd (getQ state)) False state in state'\<lparr>getQ := tl (getQ state')\<rparr> in InvariantConsistent (getM state')

goal (1 subgoal):
 1. InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
have "InvariantUniq (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []

goal (1 subgoal):
 1. InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
using InvariantUniqAfterApplyUnitPropagate[of "state"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantUniq (getM state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); getQ state \<noteq> []; \<not> getConflictFlag state\<rbrakk> \<Longrightarrow> let state' = applyUnitPropagate state in InvariantUniq (getM state')

goal (1 subgoal):
 1. InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
unfolding applyUnitPropagate_def
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantUniq (getM state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); getQ state \<noteq> []; \<not> getConflictFlag state\<rbrakk> \<Longrightarrow> let state' = let state' = assertLiteral (hd (getQ state)) False state in state'\<lparr>getQ := tl (getQ state')\<rparr> in InvariantUniq (getM state')

goal (1 subgoal):
 1. InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
using InvariantConflictFlagCharacterizationAfterAssertLiteral[of "state" "?uLiteral" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantConsistent (getM state @ [(hd (getQ state), False)]); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (getQ state)) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
using assertLiteralEffect
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantConsistent (getM state @ [(hd (getQ state), False)]); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (getQ state)) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getM (assertLiteral ?l ?d ?state) = getM ?state @ [(?l, ?d)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getF (assertLiteral ?l ?d ?state) = getF ?state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral ?l ?d ?state) = getSATFlag ?state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> isPrefix (getQ ?state) (getQ (assertLiteral ?l ?d ?state))

goal (1 subgoal):
 1. let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
unfolding applyUnitPropagate_def
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM (assertLiteral (hd (getQ state)) False state))
InvariantUniq (getM (assertLiteral (hd (getQ state)) False state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
\<not> getConflictFlag state
getQ state \<noteq> []
\<lbrakk>InvariantConsistent (getM state @ [(hd (getQ state), False)]); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (getQ state)) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getM (assertLiteral ?l ?d ?state) = getM ?state @ [(?l, ?d)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getF (assertLiteral ?l ?d ?state) = getF ?state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral ?l ?d ?state) = getSATFlag ?state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state) (getF ?state); InvariantWatchesEl (getF ?state) (getWatch1 ?state) (getWatch2 ?state)\<rbrakk> \<Longrightarrow> isPrefix (getQ ?state) (getQ (assertLiteral ?l ?d ?state))

goal (1 subgoal):
 1. let state' = let state' = assertLiteral (hd (getQ state)) False state in state'\<lparr>getQ := tl (getQ state')\<rparr> in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
let state' = applyUnitPropagate state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')

goal:
No subgoals!
[PROOF STEP]
qed