[STATEMENT]
lemma ApplyExplainUIPTermination:
assumes
"InvariantUniq (getM state)"
"InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))"
"InvariantCFalse (getConflictFlag state) (getM state) (getC state)"
"InvariantClCurrentLevel (getCl state) (getM state)"
"InvariantClCharacterization (getCl state) (getC state) (getM state)"
"InvariantCnCharacterization (getCn state) (getC state) (getM state)"
"InvariantCEntailed (getConflictFlag state) F0 (getC state)"
"InvariantEquivalentZL (getF state) (getM state) F0"
"getConflictFlag state"
"currentLevel (getM state) > 0"
shows
"applyExplainUIP_dom state"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. applyExplainUIP_dom state
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantUniq (getM state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
InvariantCFalse (getConflictFlag state) (getM state) (getC state)
InvariantClCurrentLevel (getCl state) (getM state)
InvariantClCharacterization (getCl state) (getC state) (getM state)
InvariantCnCharacterization (getCn state) (getC state) (getM state)
InvariantCEntailed (getConflictFlag state) F0 (getC state)
InvariantEquivalentZL (getF state) (getM state) F0
getConflictFlag state
0 < currentLevel (getM state)

goal (1 subgoal):
 1. applyExplainUIP_dom state
[PROOF STEP]
proof (induct rule: wf_induct[of "multLessState"])
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. wf multLessState
 2. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
case 1
[PROOF STATE]
proof (state)
this:

goal (2 subgoals):
 1. wf multLessState
 2. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
thus ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. wf multLessState
[PROOF STEP]
unfolding wf_eq_minimal
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>Q x. x \<in> Q \<longrightarrow> (\<exists>z\<in>Q. \<forall>y. (y, z) \<in> multLessState \<longrightarrow> y \<notin> Q)
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q x. x \<in> Q \<longrightarrow> (\<exists>z\<in>Q. \<forall>y. (y, z) \<in> multLessState \<longrightarrow> y \<notin> Q)
[PROOF STEP]
show "\<forall>Q (state::State). state \<in> Q \<longrightarrow> (\<exists> stateMin \<in> Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
fix Q :: "State set" and state :: State
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
assume "state \<in> Q"
[PROOF STATE]
proof (state)
this:
state \<in> Q

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
let ?M = "(getM state)"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
let ?Q1 = "{C::Clause. \<exists> state. state \<in> Q \<and> (getM state) = ?M \<and> (getC state) = C}"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
from \<open>state \<in> Q\<close>
[PROOF STATE]
proof (chain)
picking this:
state \<in> Q
[PROOF STEP]
have "getC state \<in> ?Q1"
[PROOF STATE]
proof (prove)
using this:
state \<in> Q

goal (1 subgoal):
 1. getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
with wfMultLess[of "?M"]
[PROOF STATE]
proof (chain)
picking this:
wf (multLess (getM state))
getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
[PROOF STEP]
obtain Cmin where "Cmin \<in> ?Q1" "\<forall>C'. (C', Cmin) \<in> multLess ?M \<longrightarrow> C' \<notin> ?Q1"
[PROOF STATE]
proof (prove)
using this:
wf (multLess (getM state))
getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. (\<And>Cmin. \<lbrakk>Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; \<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding wf_eq_minimal
[PROOF STATE]
proof (prove)
using this:
\<forall>Q x. x \<in> Q \<longrightarrow> (\<exists>z\<in>Q. \<forall>y. (y, z) \<in> multLess (getM state) \<longrightarrow> y \<notin> Q)
getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. (\<And>Cmin. \<lbrakk>Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; \<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
apply (erule_tac x="?Q1" in allE)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>\<And>Cmin. \<lbrakk>Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; \<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}\<rbrakk> \<Longrightarrow> thesis; getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; \<forall>x. x \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C} \<longrightarrow> (\<exists>z\<in>{C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}. \<forall>y. (y, z) \<in> multLess (getM state) \<longrightarrow> y \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C})\<rbrakk> \<Longrightarrow> thesis
[PROOF STEP]
apply (erule_tac x="getC state" in allE)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<lbrakk>\<And>Cmin. \<lbrakk>Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; \<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}\<rbrakk> \<Longrightarrow> thesis; getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}; getC state \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C} \<longrightarrow> (\<exists>z\<in>{C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}. \<forall>y. (y, z) \<in> multLess (getM state) \<longrightarrow> y \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C})\<rbrakk> \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
\<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
from \<open>Cmin \<in> ?Q1\<close>
[PROOF STATE]
proof (chain)
picking this:
Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
[PROOF STEP]
obtain stateMin
          where "stateMin \<in> Q" "(getM stateMin) = ?M" "getC stateMin = Cmin"
[PROOF STATE]
proof (prove)
using this:
Cmin \<in> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. (\<And>stateMin. \<lbrakk>stateMin \<in> Q; getM stateMin = getM state; getC stateMin = Cmin\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
stateMin \<in> Q
getM stateMin = getM state
getC stateMin = Cmin

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
have "\<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
fix state'
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
show "(state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
proof
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (state', stateMin) \<in> multLessState \<Longrightarrow> state' \<notin> Q
[PROOF STEP]
assume "(state', stateMin) \<in> multLessState"
[PROOF STATE]
proof (state)
this:
(state', stateMin) \<in> multLessState

goal (1 subgoal):
 1. (state', stateMin) \<in> multLessState \<Longrightarrow> state' \<notin> Q
[PROOF STEP]
with \<open>getM stateMin = ?M\<close>
[PROOF STATE]
proof (chain)
picking this:
getM stateMin = getM state
(state', stateMin) \<in> multLessState
[PROOF STEP]
have "getM state' = getM stateMin" "(getC state', getC stateMin) \<in> multLess ?M"
[PROOF STATE]
proof (prove)
using this:
getM stateMin = getM state
(state', stateMin) \<in> multLessState

goal (1 subgoal):
 1. getM state' = getM stateMin &&& (getC state', getC stateMin) \<in> multLess (getM state)
[PROOF STEP]
unfolding multLessState_def
[PROOF STATE]
proof (prove)
using this:
getM stateMin = getM state
(state', stateMin) \<in> {(state1, state2). getM state1 = getM state2 \<and> (getC state1, getC state2) \<in> multLess (getM state1)}

goal (1 subgoal):
 1. getM state' = getM stateMin &&& (getC state', getC stateMin) \<in> multLess (getM state)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
getM state' = getM stateMin
(getC state', getC stateMin) \<in> multLess (getM state)

goal (1 subgoal):
 1. (state', stateMin) \<in> multLessState \<Longrightarrow> state' \<notin> Q
[PROOF STEP]
from \<open>\<forall>C'. (C', Cmin) \<in> multLess ?M \<longrightarrow> C' \<notin> ?Q1\<close>
              \<open>(getC state', getC stateMin) \<in> multLess ?M\<close> \<open>getC stateMin = Cmin\<close>
[PROOF STATE]
proof (chain)
picking this:
\<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
(getC state', getC stateMin) \<in> multLess (getM state)
getC stateMin = Cmin
[PROOF STEP]
have "getC state' \<notin> ?Q1"
[PROOF STATE]
proof (prove)
using this:
\<forall>C'. (C', Cmin) \<in> multLess (getM state) \<longrightarrow> C' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
(getC state', getC stateMin) \<in> multLess (getM state)
getC stateMin = Cmin

goal (1 subgoal):
 1. getC state' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
getC state' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. (state', stateMin) \<in> multLessState \<Longrightarrow> state' \<notin> Q
[PROOF STEP]
with \<open>getM state' = getM stateMin\<close> \<open>getM stateMin = ?M\<close>
[PROOF STATE]
proof (chain)
picking this:
getM state' = getM stateMin
getM stateMin = getM state
getC state' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}
[PROOF STEP]
show "state' \<notin> Q"
[PROOF STATE]
proof (prove)
using this:
getM state' = getM stateMin
getM stateMin = getM state
getC state' \<notin> {C. \<exists>state. state \<in> Q \<and> getM state = getM state \<and> getC state = C}

goal (1 subgoal):
 1. state' \<notin> Q
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
state' \<notin> Q

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
with \<open>stateMin \<in> Q\<close>
[PROOF STATE]
proof (chain)
picking this:
stateMin \<in> Q
\<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
have "\<exists> stateMin \<in> Q. (\<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)"
[PROOF STATE]
proof (prove)
using this:
stateMin \<in> Q
\<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q

goal (1 subgoal):
 1. \<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
?statea2 \<in> ?Q2 \<Longrightarrow> \<exists>stateMin\<in>?Q2. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> ?Q2

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
?statea2 \<in> ?Q2 \<Longrightarrow> \<exists>stateMin\<in>?Q2. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> ?Q2

goal (1 subgoal):
 1. \<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<forall>Q state. state \<in> Q \<longrightarrow> (\<exists>stateMin\<in>Q. \<forall>state'. (state', stateMin) \<in> multLessState \<longrightarrow> state' \<notin> Q)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
wf multLessState

goal (1 subgoal):
 1. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
case (2 state')
[PROOF STATE]
proof (state)
this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
note ih = this
[PROOF STATE]
proof (state)
this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. \<And>x. \<lbrakk>\<forall>y. (y, x) \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y; InvariantUniq (getM x); InvariantGetReasonIsReason (getReason x) (getF x) (getM x) (set (getQ x)); InvariantCFalse (getConflictFlag x) (getM x) (getC x); InvariantClCurrentLevel (getCl x) (getM x); InvariantClCharacterization (getCl x) (getC x) (getM x); InvariantCnCharacterization (getCn x) (getC x) (getM x); InvariantCEntailed (getConflictFlag x) F0 (getC x); InvariantEquivalentZL (getF x) (getM x) F0; getConflictFlag x; 0 < currentLevel (getM x)\<rbrakk> \<Longrightarrow> applyExplainUIP_dom x
[PROOF STEP]
show ?case
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. applyExplainUIP_dom state'
[PROOF STEP]
proof (cases "getCn state' = 1")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getCn state' = 1 \<Longrightarrow> applyExplainUIP_dom state'
 2. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getCn state' = 1

goal (2 subgoals):
 1. getCn state' = 1 \<Longrightarrow> applyExplainUIP_dom state'
 2. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. applyExplainUIP_dom state'
[PROOF STEP]
apply (rule applyExplainUIP_dom.intros)
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom (applyExplain (getCl state') state')
[PROOF STEP]
using True
[PROOF STATE]
proof (prove)
using this:
getCn state' = 1

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom (applyExplain (getCl state') state')
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
applyExplainUIP_dom state'

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
getCn state' \<noteq> 1

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
let ?state'' = "applyExplain (getCl state') state'"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
have "InvariantGetReasonIsReason (getReason ?state'') (getF ?state'') (getM ?state'') (set (getQ ?state''))"
      "InvariantUniq (getM ?state'')"
      "InvariantEquivalentZL (getF ?state'') (getM ?state'') F0"
      "getConflictFlag ?state''"
      "currentLevel (getM ?state'') > 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state'))) &&& InvariantUniq (getM (applyExplain (getCl state') state'))) &&& InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0 &&& getConflictFlag (applyExplain (getCl state') state') &&& 0 < currentLevel (getM (applyExplain (getCl state') state'))
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state'))) &&& InvariantUniq (getM (applyExplain (getCl state') state'))) &&& InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0 &&& getConflictFlag (applyExplain (getCl state') state') &&& 0 < currentLevel (getM (applyExplain (getCl state') state'))
[PROOF STEP]
unfolding applyExplain_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (InvariantGetReasonIsReason (getReason (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state')) (getF (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state')) (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state')) (set (getQ (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state'))) &&& InvariantUniq (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state'))) &&& InvariantEquivalentZL (getF (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state')) (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state')) F0 &&& getConflictFlag (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state') &&& 0 < currentLevel (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state'))
[PROOF STEP]
unfolding setConflictAnalysisClause_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (InvariantGetReasonIsReason (getReason (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state'))) (getF (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state'))) (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state'))) (set (getQ (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')))) &&& InvariantUniq (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')))) &&& InvariantEquivalentZL (getF (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state'))) (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state'))) F0 &&& getConflictFlag (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')) &&& 0 < currentLevel (getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')))
[PROOF STEP]
by (auto split: option.split simp add: findLastAssertedLiteral_def countCurrentLevelLiterals_def Let_def)
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state')))
InvariantUniq (getM (applyExplain (getCl state') state'))
InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0
getConflictFlag (applyExplain (getCl state') state')
0 < currentLevel (getM (applyExplain (getCl state') state'))

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state')))
InvariantUniq (getM (applyExplain (getCl state') state'))
InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0
getConflictFlag (applyExplain (getCl state') state')
0 < currentLevel (getM (applyExplain (getCl state') state'))

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
have "InvariantCFalse (getConflictFlag ?state'') (getM ?state'') (getC ?state'')"
      "InvariantClCharacterization (getCl ?state'') (getC ?state'') (getM ?state'')"
      "InvariantCnCharacterization (getCn ?state'') (getC ?state'') (getM ?state'')"
      "InvariantClCurrentLevel (getCl ?state'') (getM ?state'')"
      "InvariantCEntailed (getConflictFlag ?state'') F0 (getC ?state'')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) &&& InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))) &&& InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
[PROOF STEP]
using InvariantsClAfterApplyExplain[of "state'" "F0"]
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM state'); InvariantCFalse (getConflictFlag state') (getM state') (getC state'); InvariantClCharacterization (getCl state') (getC state') (getM state'); InvariantClCurrentLevel (getCl state') (getM state'); InvariantCEntailed (getConflictFlag state') F0 (getC state'); InvariantCnCharacterization (getCn state') (getC state') (getM state'); InvariantEquivalentZL (getF state') (getM state') F0; InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')); getCn state' \<noteq> 1; getConflictFlag state'; 0 < currentLevel (getM state')\<rbrakk> \<Longrightarrow> let state' = applyExplain (getCl state') state' in InvariantCFalse (getConflictFlag state') (getM state') (getC state') \<and> InvariantCEntailed (getConflictFlag state') F0 (getC state') \<and> InvariantClCharacterization (getCl state') (getC state') (getM state') \<and> InvariantClCurrentLevel (getCl state') (getM state') \<and> InvariantCnCharacterization (getCn state') (getC state') (getM state') \<and> InvariantUniqC (getC state')

goal (1 subgoal):
 1. (InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) &&& InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))) &&& InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM state'); InvariantCFalse (getConflictFlag state') (getM state') (getC state'); InvariantClCharacterization (getCl state') (getC state') (getM state'); InvariantClCurrentLevel (getCl state') (getM state'); InvariantCEntailed (getConflictFlag state') F0 (getC state'); InvariantCnCharacterization (getCn state') (getC state') (getM state'); InvariantEquivalentZL (getF state') (getM state') F0; InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')); getCn state' \<noteq> 1; getConflictFlag state'; 0 < currentLevel (getM state')\<rbrakk> \<Longrightarrow> let state' = applyExplain (getCl state') state' in InvariantCFalse (getConflictFlag state') (getM state') (getC state') \<and> InvariantCEntailed (getConflictFlag state') F0 (getC state') \<and> InvariantClCharacterization (getCl state') (getC state') (getM state') \<and> InvariantClCurrentLevel (getCl state') (getM state') \<and> InvariantCnCharacterization (getCn state') (getC state') (getM state') \<and> InvariantUniqC (getC state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) &&& InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))) &&& InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
[PROOF STEP]
using False
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM state'); InvariantCFalse (getConflictFlag state') (getM state') (getC state'); InvariantClCharacterization (getCl state') (getC state') (getM state'); InvariantClCurrentLevel (getCl state') (getM state'); InvariantCEntailed (getConflictFlag state') F0 (getC state'); InvariantCnCharacterization (getCn state') (getC state') (getM state'); InvariantEquivalentZL (getF state') (getM state') F0; InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')); getCn state' \<noteq> 1; getConflictFlag state'; 0 < currentLevel (getM state')\<rbrakk> \<Longrightarrow> let state' = applyExplain (getCl state') state' in InvariantCFalse (getConflictFlag state') (getM state') (getC state') \<and> InvariantCEntailed (getConflictFlag state') F0 (getC state') \<and> InvariantClCharacterization (getCl state') (getC state') (getM state') \<and> InvariantClCurrentLevel (getCl state') (getM state') \<and> InvariantCnCharacterization (getCn state') (getC state') (getM state') \<and> InvariantUniqC (getC state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
getCn state' \<noteq> 1

goal (1 subgoal):
 1. (InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) &&& InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))) &&& InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) &&& InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
[PROOF STEP]
by (auto simp add:Let_def)
[PROOF STATE]
proof (state)
this:
InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state'))
InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state'))
InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
have "(?state'', state') \<in> multLessState"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "getM ?state'' = getM state'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getM (applyExplain (getCl state') state') = getM state'
[PROOF STEP]
unfolding applyExplain_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state') = getM state'
[PROOF STEP]
unfolding setConflictAnalysisClause_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getM (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')) = getM state'
[PROOF STEP]
by (auto split: option.split simp add: findLastAssertedLiteral_def countCurrentLevelLiterals_def Let_def)
[PROOF STATE]
proof (state)
this:
getM (applyExplain (getCl state') state') = getM state'

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
let ?Cl = "getCl state'"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
let ?oppM0 = "oppositeLiteralList (elements (prefixToLevel 0 (getM state')))"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "isLastAssertedLiteral ?Cl (oppositeLiteralList (getC state')) (elements (getM state'))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
[PROOF STEP]
unfolding InvariantClCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> isLastAssertedLiteral (getCl y) (oppositeLiteralList (getC y)) (elements (getM y)) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
hence "literalTrue ?Cl (elements (getM state'))" "?Cl el (oppositeLiteralList (getC state'))"
[PROOF STATE]
proof (prove)
using this:
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))

goal (1 subgoal):
 1. literalTrue (getCl state') (elements (getM state')) &&& getCl state' el oppositeLiteralList (getC state')
[PROOF STEP]
unfolding isLastAssertedLiteral_def
[PROOF STATE]
proof (prove)
using this:
getCl state' el oppositeLiteralList (getC state') \<and> literalTrue (getCl state') (elements (getM state')) \<and> (\<forall>literal'. literal' el oppositeLiteralList (getC state') \<and> literal' \<noteq> getCl state' \<longrightarrow> \<not> precedes (getCl state') literal' (elements (getM state')))

goal (1 subgoal):
 1. literalTrue (getCl state') (elements (getM state')) &&& getCl state' el oppositeLiteralList (getC state')
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
literalTrue (getCl state') (elements (getM state'))
getCl state' el oppositeLiteralList (getC state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
hence "opposite ?Cl el getC state'"
[PROOF STATE]
proof (prove)
using this:
literalTrue (getCl state') (elements (getM state'))
getCl state' el oppositeLiteralList (getC state')

goal (1 subgoal):
 1. opposite (getCl state') el getC state'
[PROOF STEP]
using literalElListIffOppositeLiteralElOppositeLiteralList[of "opposite ?Cl" "getC state'"]
[PROOF STATE]
proof (prove)
using this:
literalTrue (getCl state') (elements (getM state'))
getCl state' el oppositeLiteralList (getC state')
opposite (getCl state') el getC state' = opposite (opposite (getCl state')) el oppositeLiteralList (getC state')

goal (1 subgoal):
 1. opposite (getCl state') el getC state'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
opposite (getCl state') el getC state'

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "clauseFalse (getC state') (elements (getM state'))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. clauseFalse (getC state') (elements (getM state'))
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. clauseFalse (getC state') (elements (getM state'))
[PROOF STEP]
unfolding InvariantCFalse_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> (getConflictFlag y \<longrightarrow> clauseFalse (getC y) (elements (getM y))) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
getConflictFlag state' \<longrightarrow> clauseFalse (getC state') (elements (getM state'))
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. clauseFalse (getC state') (elements (getM state'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
clauseFalse (getC state') (elements (getM state'))

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "\<not> ?Cl el (decisions (getM state'))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
assume "\<not> ?thesis"
[PROOF STATE]
proof (state)
this:
\<not> \<not> getCl state' el decisions (getM state')

goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
hence "isUIP (opposite ?Cl) (getC state') (getM state')"
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
using \<open>isLastAssertedLiteral ?Cl (oppositeLiteralList (getC state')) (elements (getM state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
using \<open>clauseFalse (getC state') (elements (getM state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
clauseFalse (getC state') (elements (getM state'))

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
using lastDecisionThenUIP[of "getM state'" "opposite ?Cl" "getC state'"]
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
clauseFalse (getC state') (elements (getM state'))
\<lbrakk>uniq (elements (getM state')); opposite (opposite (getCl state')) el decisions (getM state'); clauseFalse (getC state') (elements (getM state')); isLastAssertedLiteral (opposite (opposite (getCl state'))) (oppositeLiteralList (getC state')) (elements (getM state'))\<rbrakk> \<Longrightarrow> isUIP (opposite (getCl state')) (getC state') (getM state')

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> uniq (elements (getM y)) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
uniq (elements (getM state'))
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
clauseFalse (getC state') (elements (getM state'))
\<lbrakk>uniq (elements (getM state')); opposite (opposite (getCl state')) el decisions (getM state'); clauseFalse (getC state') (elements (getM state')); isLastAssertedLiteral (opposite (opposite (getCl state'))) (oppositeLiteralList (getC state')) (elements (getM state'))\<rbrakk> \<Longrightarrow> isUIP (opposite (getCl state')) (getC state') (getM state')

goal (1 subgoal):
 1. isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
unfolding isUIP_def
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> uniq (elements (getM y)) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
uniq (elements (getM state'))
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
isLastAssertedLiteral (getCl state') (oppositeLiteralList (getC state')) (elements (getM state'))
clauseFalse (getC state') (elements (getM state'))
\<lbrakk>uniq (elements (getM state')); opposite (opposite (getCl state')) el decisions (getM state'); clauseFalse (getC state') (elements (getM state')); isLastAssertedLiteral (opposite (opposite (getCl state'))) (oppositeLiteralList (getC state')) (elements (getM state'))\<rbrakk> \<Longrightarrow> isLastAssertedLiteral (opposite (opposite (getCl state'))) (oppositeLiteralList (getC state')) (elements (getM state')) \<and> (\<forall>l'. l' el getC state' \<and> l' \<noteq> opposite (getCl state') \<longrightarrow> elementLevel (opposite l') (getM state') < elementLevel (opposite (opposite (getCl state'))) (getM state'))

goal (1 subgoal):
 1. isLastAssertedLiteral (opposite (opposite (getCl state'))) (oppositeLiteralList (getC state')) (elements (getM state')) \<and> (\<forall>l'. l' el getC state' \<and> l' \<noteq> opposite (getCl state') \<longrightarrow> elementLevel (opposite l') (getM state') < elementLevel (opposite (opposite (getCl state'))) (getM state'))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
isUIP (opposite (getCl state')) (getC state') (getM state')

goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
with \<open>getCn state' \<noteq> 1\<close>
[PROOF STATE]
proof (chain)
picking this:
getCn state' \<noteq> 1
isUIP (opposite (getCl state')) (getC state') (getM state')
[PROOF STEP]
have "False"
[PROOF STATE]
proof (prove)
using this:
getCn state' \<noteq> 1
isUIP (opposite (getCl state')) (getC state') (getM state')

goal (1 subgoal):
 1. False
[PROOF STEP]
using CnEqual1IffUIP[of "state'"]
[PROOF STATE]
proof (prove)
using this:
getCn state' \<noteq> 1
isUIP (opposite (getCl state')) (getC state') (getM state')
\<lbrakk>InvariantClCharacterization (getCl state') (getC state') (getM state'); InvariantClCurrentLevel (getCl state') (getM state'); InvariantCnCharacterization (getCn state') (getC state') (getM state')\<rbrakk> \<Longrightarrow> (getCn state' = 1) = isUIP (opposite (getCl state')) (getC state') (getM state')

goal (1 subgoal):
 1. False
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
getCn state' \<noteq> 1
isUIP (opposite (getCl state')) (getC state') (getM state')
\<lbrakk>InvariantClCharacterization (getCl state') (getC state') (getM state'); InvariantClCurrentLevel (getCl state') (getM state'); InvariantCnCharacterization (getCn state') (getC state') (getM state')\<rbrakk> \<Longrightarrow> (getCn state' = 1) = isUIP (opposite (getCl state')) (getC state') (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. False
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
False

goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<not> \<not> getCl state' el decisions (getM state') \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> getCl state' el decisions (getM state') \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> getCl state' el decisions (getM state')
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<not> getCl state' el decisions (getM state')

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<not> getCl state' el decisions (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "elementLevel ?Cl (getM state') = currentLevel (getM state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. elementLevel (getCl state') (getM state') = currentLevel (getM state')
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. elementLevel (getCl state') (getM state') = currentLevel (getM state')
[PROOF STEP]
unfolding InvariantClCurrentLevel_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> elementLevel (getCl y) (getM y) = currentLevel (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
elementLevel (getCl state') (getM state') = currentLevel (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. elementLevel (getCl state') (getM state') = currentLevel (getM state')
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
elementLevel (getCl state') (getM state') = currentLevel (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
hence "elementLevel ?Cl (getM state') > 0"
[PROOF STATE]
proof (prove)
using this:
elementLevel (getCl state') (getM state') = currentLevel (getM state')

goal (1 subgoal):
 1. 0 < elementLevel (getCl state') (getM state')
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
elementLevel (getCl state') (getM state') = currentLevel (getM state')
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. 0 < elementLevel (getCl state') (getM state')
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
0 < elementLevel (getCl state') (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
obtain reason
        where "isReason (nth (getF state') reason) ?Cl (elements (getM state'))"
        "getReason state' ?Cl = Some reason" "0 \<le> reason \<and> reason < length (getF state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding InvariantGetReasonIsReason_def
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> (\<forall>literal. (literal el elements (getM y) \<and> \<not> literal el decisions (getM y) \<and> 0 < elementLevel literal (getM y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> isReason (getF y ! reason) literal (elements (getM y)))) \<and> (0 < currentLevel (getM y) \<and> literal \<in> set (getQ y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> (isUnitClause (getF y ! reason) literal (elements (getM y)) \<or> clauseFalse (getF y ! reason) (elements (getM y)))))) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
\<forall>literal. (literal el elements (getM state') \<and> \<not> literal el decisions (getM state') \<and> 0 < elementLevel literal (getM state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> isReason (getF state' ! reason) literal (elements (getM state')))) \<and> (0 < currentLevel (getM state') \<and> literal \<in> set (getQ state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> (isUnitClause (getF state' ! reason) literal (elements (getM state')) \<or> clauseFalse (getF state' ! reason) (elements (getM state')))))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using \<open>literalTrue ?Cl (elements (getM state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> (\<forall>literal. (literal el elements (getM y) \<and> \<not> literal el decisions (getM y) \<and> 0 < elementLevel literal (getM y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> isReason (getF y ! reason) literal (elements (getM y)))) \<and> (0 < currentLevel (getM y) \<and> literal \<in> set (getQ y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> (isUnitClause (getF y ! reason) literal (elements (getM y)) \<or> clauseFalse (getF y ! reason) (elements (getM y)))))) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
\<forall>literal. (literal el elements (getM state') \<and> \<not> literal el decisions (getM state') \<and> 0 < elementLevel literal (getM state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> isReason (getF state' ! reason) literal (elements (getM state')))) \<and> (0 < currentLevel (getM state') \<and> literal \<in> set (getQ state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> (isUnitClause (getF state' ! reason) literal (elements (getM state')) \<or> clauseFalse (getF state' ! reason) (elements (getM state')))))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
literalTrue (getCl state') (elements (getM state'))

goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using \<open>\<not> ?Cl el (decisions (getM state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> (\<forall>literal. (literal el elements (getM y) \<and> \<not> literal el decisions (getM y) \<and> 0 < elementLevel literal (getM y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> isReason (getF y ! reason) literal (elements (getM y)))) \<and> (0 < currentLevel (getM y) \<and> literal \<in> set (getQ y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> (isUnitClause (getF y ! reason) literal (elements (getM y)) \<or> clauseFalse (getF y ! reason) (elements (getM y)))))) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
\<forall>literal. (literal el elements (getM state') \<and> \<not> literal el decisions (getM state') \<and> 0 < elementLevel literal (getM state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> isReason (getF state' ! reason) literal (elements (getM state')))) \<and> (0 < currentLevel (getM state') \<and> literal \<in> set (getQ state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> (isUnitClause (getF state' ! reason) literal (elements (getM state')) \<or> clauseFalse (getF state' ! reason) (elements (getM state')))))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
literalTrue (getCl state') (elements (getM state'))
\<not> getCl state' el decisions (getM state')

goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using \<open>elementLevel ?Cl (getM state') > 0\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> (\<forall>literal. (literal el elements (getM y) \<and> \<not> literal el decisions (getM y) \<and> 0 < elementLevel literal (getM y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> isReason (getF y ! reason) literal (elements (getM y)))) \<and> (0 < currentLevel (getM y) \<and> literal \<in> set (getQ y) \<longrightarrow> (\<exists>reason. getReason y literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF y) \<and> (isUnitClause (getF y ! reason) literal (elements (getM y)) \<or> clauseFalse (getF y ! reason) (elements (getM y)))))) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
\<forall>literal. (literal el elements (getM state') \<and> \<not> literal el decisions (getM state') \<and> 0 < elementLevel literal (getM state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> isReason (getF state' ! reason) literal (elements (getM state')))) \<and> (0 < currentLevel (getM state') \<and> literal \<in> set (getQ state') \<longrightarrow> (\<exists>reason. getReason state' literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF state') \<and> (isUnitClause (getF state' ! reason) literal (elements (getM state')) \<or> clauseFalse (getF state' ! reason) (elements (getM state')))))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')
literalTrue (getCl state') (elements (getM state'))
\<not> getCl state' el decisions (getM state')
0 < elementLevel (getCl state') (getM state')

goal (1 subgoal):
 1. (\<And>reason. \<lbrakk>isReason (getF state' ! reason) (getCl state') (elements (getM state')); getReason state' (getCl state') = Some reason; 0 \<le> reason \<and> reason < length (getF state')\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
isReason (getF state' ! reason) (getCl state') (elements (getM state'))
getReason state' (getCl state') = Some reason
0 \<le> reason \<and> reason < length (getF state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
let ?res = "resolve (getC state') (getF state' ! reason) (opposite ?Cl)"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "getC ?state'' = (remdups (list_diff ?res ?oppM0))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getC (applyExplain (getCl state') state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
[PROOF STEP]
unfolding applyExplain_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getC (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')) in setConflictAnalysisClause res state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
[PROOF STEP]
unfolding setConflictAnalysisClause_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. getC (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')) = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
[PROOF STEP]
using \<open>getReason state' ?Cl = Some reason\<close>
[PROOF STATE]
proof (prove)
using this:
getReason state' (getCl state') = Some reason

goal (1 subgoal):
 1. getC (case getReason state' (getCl state') of None \<Rightarrow> state' | Some reason \<Rightarrow> let res = resolve (getC state') (getF state' ! reason) (opposite (getCl state')); oppM0 = oppositeLiteralList (elements (prefixToLevel 0 (getM state'))); state' = state'\<lparr>getC := remdups (list_diff res oppM0)\<rparr> in countCurrentLevelLiterals (findLastAssertedLiteral state')) = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
[PROOF STEP]
by (simp add: Let_def findLastAssertedLiteral_def countCurrentLevelLiterals_def)
[PROOF STATE]
proof (state)
this:
getC (applyExplain (getCl state') state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "(?res, getC state') \<in> multLess (getM state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
[PROOF STEP]
using multLessResolve[of "?Cl" "getC state'" "nth (getF state') reason" "getM state'"]
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>opposite (getCl state') el getC state'; isReason (getF state' ! reason) (getCl state') (elements (getM state'))\<rbrakk> \<Longrightarrow> (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
[PROOF STEP]
using \<open>opposite ?Cl el (getC state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>opposite (getCl state') el getC state'; isReason (getF state' ! reason) (getCl state') (elements (getM state'))\<rbrakk> \<Longrightarrow> (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
opposite (getCl state') el getC state'

goal (1 subgoal):
 1. (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
[PROOF STEP]
using \<open>isReason (nth (getF state') reason) ?Cl (elements (getM state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>opposite (getCl state') el getC state'; isReason (getF state' ! reason) (getCl state') (elements (getM state'))\<rbrakk> \<Longrightarrow> (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
opposite (getCl state') el getC state'
isReason (getF state' ! reason) (getCl state') (elements (getM state'))

goal (1 subgoal):
 1. (resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
hence "(list_diff ?res ?oppM0, getC state') \<in> multLess (getM state')"
[PROOF STATE]
proof (prove)
using this:
(resolve (getC state') (getF state' ! reason) (opposite (getCl state')), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))), getC state') \<in> multLess (getM state')
[PROOF STEP]
by (simp add: multLessListDiff)
[PROOF STATE]
proof (state)
this:
(list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "(remdups (list_diff ?res ?oppM0), getC state') \<in> multLess (getM state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')
[PROOF STEP]
using \<open>(list_diff ?res ?oppM0, getC state') \<in> multLess (getM state')\<close>
[PROOF STATE]
proof (prove)
using this:
(list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')
[PROOF STEP]
by (simp add: multLessRemdups)
[PROOF STATE]
proof (state)
this:
(remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
(remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
using \<open>getC ?state'' = (remdups (list_diff ?res ?oppM0))\<close>
[PROOF STATE]
proof (prove)
using this:
(remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')
getC (applyExplain (getCl state') state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
using \<open>getM ?state'' = getM state'\<close>
[PROOF STATE]
proof (prove)
using this:
(remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')
getC (applyExplain (getCl state') state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
getM (applyExplain (getCl state') state') = getM state'

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
unfolding multLessState_def
[PROOF STATE]
proof (prove)
using this:
(remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state'))))), getC state') \<in> multLess (getM state')
getC (applyExplain (getCl state') state') = remdups (list_diff (resolve (getC state') (getF state' ! reason) (opposite (getCl state'))) (oppositeLiteralList (elements (prefixToLevel 0 (getM state')))))
getM (applyExplain (getCl state') state') = getM state'

goal (1 subgoal):
 1. (applyExplain (getCl state') state', state') \<in> {(state1, state2). getM state1 = getM state2 \<and> (getC state1, getC state2) \<in> multLess (getM state1)}
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
(applyExplain (getCl state') state', state') \<in> multLessState

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
(applyExplain (getCl state') state', state') \<in> multLessState

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state')))
InvariantUniq (getM (applyExplain (getCl state') state'))
InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0
getConflictFlag (applyExplain (getCl state') state')
0 < currentLevel (getM (applyExplain (getCl state') state'))
InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state'))
InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
(applyExplain (getCl state') state', state') \<in> multLessState
[PROOF STEP]
have "applyExplainUIP_dom ?state''"
[PROOF STATE]
proof (prove)
using this:
InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state')))
InvariantUniq (getM (applyExplain (getCl state') state'))
InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0
getConflictFlag (applyExplain (getCl state') state')
0 < currentLevel (getM (applyExplain (getCl state') state'))
InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state'))
InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
(applyExplain (getCl state') state', state') \<in> multLessState

goal (1 subgoal):
 1. applyExplainUIP_dom (applyExplain (getCl state') state')
[PROOF STEP]
using ih
[PROOF STATE]
proof (prove)
using this:
InvariantGetReasonIsReason (getReason (applyExplain (getCl state') state')) (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (set (getQ (applyExplain (getCl state') state')))
InvariantUniq (getM (applyExplain (getCl state') state'))
InvariantEquivalentZL (getF (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) F0
getConflictFlag (applyExplain (getCl state') state')
0 < currentLevel (getM (applyExplain (getCl state') state'))
InvariantCFalse (getConflictFlag (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state'))
InvariantClCharacterization (getCl (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCnCharacterization (getCn (applyExplain (getCl state') state')) (getC (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantClCurrentLevel (getCl (applyExplain (getCl state') state')) (getM (applyExplain (getCl state') state'))
InvariantCEntailed (getConflictFlag (applyExplain (getCl state') state')) F0 (getC (applyExplain (getCl state') state'))
(applyExplain (getCl state') state', state') \<in> multLessState
\<forall>y. (y, state') \<in> multLessState \<longrightarrow> InvariantUniq (getM y) \<longrightarrow> InvariantGetReasonIsReason (getReason y) (getF y) (getM y) (set (getQ y)) \<longrightarrow> InvariantCFalse (getConflictFlag y) (getM y) (getC y) \<longrightarrow> InvariantClCurrentLevel (getCl y) (getM y) \<longrightarrow> InvariantClCharacterization (getCl y) (getC y) (getM y) \<longrightarrow> InvariantCnCharacterization (getCn y) (getC y) (getM y) \<longrightarrow> InvariantCEntailed (getConflictFlag y) F0 (getC y) \<longrightarrow> InvariantEquivalentZL (getF y) (getM y) F0 \<longrightarrow> getConflictFlag y \<longrightarrow> 0 < currentLevel (getM y) \<longrightarrow> applyExplainUIP_dom y
InvariantUniq (getM state')
InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantCFalse (getConflictFlag state') (getM state') (getC state')
InvariantClCurrentLevel (getCl state') (getM state')
InvariantClCharacterization (getCl state') (getC state') (getM state')
InvariantCnCharacterization (getCn state') (getC state') (getM state')
InvariantCEntailed (getConflictFlag state') F0 (getC state')
InvariantEquivalentZL (getF state') (getM state') F0
getConflictFlag state'
0 < currentLevel (getM state')

goal (1 subgoal):
 1. applyExplainUIP_dom (applyExplain (getCl state') state')
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
applyExplainUIP_dom (applyExplain (getCl state') state')

goal (1 subgoal):
 1. getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom state'
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
applyExplainUIP_dom (applyExplain (getCl state') state')

goal (1 subgoal):
 1. applyExplainUIP_dom state'
[PROOF STEP]
using applyExplainUIP_dom.intros[of "state'"]
[PROOF STATE]
proof (prove)
using this:
applyExplainUIP_dom (applyExplain (getCl state') state')
(getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom (applyExplain (getCl state') state')) \<Longrightarrow> applyExplainUIP_dom state'

goal (1 subgoal):
 1. applyExplainUIP_dom state'
[PROOF STEP]
using False
[PROOF STATE]
proof (prove)
using this:
applyExplainUIP_dom (applyExplain (getCl state') state')
(getCn state' \<noteq> 1 \<Longrightarrow> applyExplainUIP_dom (applyExplain (getCl state') state')) \<Longrightarrow> applyExplainUIP_dom state'
getCn state' \<noteq> 1

goal (1 subgoal):
 1. applyExplainUIP_dom state'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
applyExplainUIP_dom state'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
applyExplainUIP_dom state'

goal:
No subgoals!
[PROOF STEP]
qed