[STATEMENT]
lemma InvariantsAfterAddClause:
fixes state::State and clause :: Clause and Vbl :: "Variable set"
assumes
  "InvariantConsistent (getM state)"
  "InvariantUniq (getM state)"
  "InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)" and
  "InvariantWatchListsUniq (getWatchList state)" and
  "InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)"
  "InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)" and
  "InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)" and
  "InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)"
  "InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)"
  "InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)"
  "InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)"
  "InvariantUniqQ (getQ state)"
  "InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))"
  "currentLevel (getM state) = 0"
  "(getConflictFlag state) \<or> (getQ state) = []"
  "InvariantVarsM (getM state) F0 Vbl"
  "InvariantVarsQ (getQ state) F0 Vbl"
  "InvariantVarsF (getF state) F0 Vbl"
  "finite Vbl"
  "vars clause \<subseteq> vars F0"
shows
  "let state' = (addClause clause state) in
      InvariantConsistent (getM state') \<and>
      InvariantUniq (getM state') \<and>
      InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and>
      InvariantWatchListsUniq (getWatchList state') \<and>
      InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and>
      InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and>
      InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and>
      InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and>
      InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and>
      InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and>
      InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and>
      InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and>
      InvariantUniqQ (getQ state') \<and>
      InvariantVarsQ (getQ state') F0 Vbl \<and>
      InvariantVarsM (getM state') F0 Vbl \<and>
      InvariantVarsF (getF state') F0 Vbl \<and>
      currentLevel (getM state') = 0 \<and>
      ((getConflictFlag state') \<or> (getQ state') = [])
"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
let ?clause' = "remdups (removeFalseLiterals clause (elements (getM state)))"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have *: "\<forall> l. l el ?clause' \<longrightarrow> \<not> literalFalse l (elements (getM state))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>l. l el remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause) \<longrightarrow> \<not> literalFalse l (elements (getM state))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "vars ?clause' \<subseteq> vars clause"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause
[PROOF STEP]
using varsSubsetValuation[of "?clause'" "clause"]
[PROOF STATE]
proof (prove)
using this:
set (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> set clause \<Longrightarrow> vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause

goal (1 subgoal):
 1. vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
set (remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)) \<subseteq> set clause \<Longrightarrow> vars (remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)) \<subseteq> vars clause

goal (1 subgoal):
 1. vars (remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)) \<subseteq> vars clause
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "vars ?clause' \<subseteq> vars F0"
[PROOF STATE]
proof (prove)
using this:
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause

goal (1 subgoal):
 1. vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
[PROOF STEP]
using \<open>vars clause \<subseteq> vars F0\<close>
[PROOF STATE]
proof (prove)
using this:
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars clause
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
proof (cases "clauseTrue ?clause' (elements (getM state))")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (2 subgoals):
 1. clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = setWatch1 clauseIndex (clause' ! 0) state'; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal (1 subgoal):
 1. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
proof (cases "?clause' = []")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. remdups (removeFalseLiterals clause (elements (getM state))) = [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
remdups (removeFalseLiterals clause (elements (getM state))) = []

goal (2 subgoals):
 1. remdups (removeFalseLiterals clause (elements (getM state))) = [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) = []

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) = []
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) = []
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) = []
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = setWatch1 clauseIndex (clause' ! 0) state'; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
proof (cases "length ?clause' = 1")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
let ?state' = "assertLiteral (hd ?clause') False state"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "addClause clause state = exhaustiveUnitPropagate ?state'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>length ?clause' = 1\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1

goal (1 subgoal):
 1. addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1

goal (1 subgoal):
 1. (let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = setWatch1 clauseIndex (clause' ! 0) state'; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''') = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
from \<open>?clause' \<noteq> []\<close>
[PROOF STATE]
proof (chain)
picking this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
[PROOF STEP]
have "hd ?clause' \<in> set ?clause'"
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
using hd_in_set[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
with *
[PROOF STATE]
proof (chain)
picking this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
have "\<not> literalFalse (hd ?clause') (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "consistent (elements ((getM state) @ [(hd ?clause', False)]))"
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))

goal (1 subgoal):
 1. consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
[PROOF STEP]
using consistentAppendElement[of "elements (getM state)" "hd ?clause'"]
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state)); \<not> literalFalse (hd (remdups (removeFalseLiterals clause (elements (getM state))))) (elements (getM state))\<rbrakk> \<Longrightarrow> consistent (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])

goal (1 subgoal):
 1. consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "consistent (elements (getM ?state'))"
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))

goal (1 subgoal):
 1. consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
from \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (chain)
picking this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
[PROOF STEP]
have "uniq (elements (getM ?state'))"
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
using \<open>hd ?clause' \<in> set ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConsistent (getM state)
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
by (simp add: uniqAppendIff clauseTrueIffContainsTrueLiteral)
[PROOF STATE]
proof (state)
this:
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state') (getF ?state')" and
          "InvariantWatchListsUniq (getWatchList ?state')" and
          "InvariantWatchListsCharacterization (getWatchList ?state') (getWatch1 ?state') (getWatch2 ?state')"
          "InvariantWatchesEl (getF ?state') (getWatch1 ?state') (getWatch2 ?state')" and
          "InvariantWatchesDiffer (getF ?state') (getWatch1 ?state') (getWatch2 ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. (InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& (InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. (InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& (InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using WatchInvariantsAfterAssertLiteral[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state')

goal (1 subgoal):
 1. (InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& (InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) &&& InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) &&& InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchCharacterization (getF ?state') (getWatch1 ?state') (getWatch2 ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using InvariantWatchCharacterizationAfterAssertLiteral[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using \<open>uniq (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); uniq (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); uniq (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state')
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantConflictFlagCharacterization (getConflictFlag ?state') (getF ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using InvariantConflictFlagCharacterizationAfterAssertLiteral[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state')
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantConflictClauseCharacterization (getConflictFlag ?state') (getConflictClause ?state') (getF ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using InvariantConflictClauseCharacterizationAfterAssertLiteral[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchListsUniq (getWatchList state); InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')

goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
let ?state'' = "?state'\<lparr> getM := (getM ?state') @ [(hd ?clause', False)] \<rparr>"
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantQCharacterization (getConflictFlag ?state') (getQ ?state') (getF ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
proof (cases "getConflictFlag state")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
 2. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getConflictFlag state

goal (2 subgoals):
 1. getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
 2. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
hence "getConflictFlag ?state'"
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using assertLiteralConflictFlagEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>uniq (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); uniq (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); uniq (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in getConflictFlag state' = (getConflictFlag state \<or> (\<exists>clausea. clausea el getF state \<and> opposite (hd (remdups (removeFalseLiterals clause (elements (getM state))))) el clausea \<and> clauseFalse clausea (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))])))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (2 subgoals):
 1. getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
 2. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantQCharacterization_def
[PROOF STATE]
proof (prove)
using this:
getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
\<not> getConflictFlag state \<longrightarrow> (\<forall>l. l el getQ state = (\<exists>c. c el getF state \<and> isUnitClause c l (elements (getM state))))
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. \<not> getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<longrightarrow> (\<forall>l. l el getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = (\<exists>c. c el getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<and> isUnitClause c l (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> getConflictFlag state

goal (1 subgoal):
 1. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
with \<open>(getConflictFlag state) \<or> (getQ state) = []\<close>
[PROOF STATE]
proof (chain)
picking this:
getConflictFlag state \<or> getQ state = []
\<not> getConflictFlag state
[PROOF STEP]
have "getQ state = []"
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state \<or> getQ state = []
\<not> getConflictFlag state

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

goal (1 subgoal):
 1. \<not> getConflictFlag state \<Longrightarrow> InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getQ state = []

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

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using \<open>uniq (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
getQ state = []
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state); InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state); \<not> hd (remdups (removeFalseLiterals clause (elements (getM state)))) el getQ state\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state')
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantUniqQ (getQ ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
using InvariantUniqQAfterAssertLiteral[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantUniqQ (getQ state)\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantUniqQ (getQ state')

goal (1 subgoal):
 1. InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "currentLevel (getM ?state') = 0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
[PROOF STEP]
unfolding currentLevel_def
[PROOF STATE]
proof (prove)
using this:
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
length (decisions (getM state)) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. length (decisions (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) = 0
[PROOF STEP]
by (simp add:Let_def markedElementsAppend)
[PROOF STATE]
proof (state)
this:
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "InvariantGetReasonIsReason (getReason ?state') (getF ?state') (getM ?state') (set (getQ ?state'))"
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0

goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
[PROOF STEP]
unfolding InvariantGetReasonIsReason_def
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0

goal (1 subgoal):
 1. \<forall>literal. (literal el elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> \<not> literal el decisions (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> 0 < elementLevel literal (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<longrightarrow> (\<exists>reason. getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> isReason (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) literal (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))))) \<and> (0 < currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> literal \<in> set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<longrightarrow> (\<exists>reason. getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> (isUnitClause (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) literal (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<or> clauseFalse (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))))))
[PROOF STEP]
using elementLevelLeqCurrentLevel[of _ "getM ?state'"]
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
elementLevel ?a (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<le> currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. \<forall>literal. (literal el elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> \<not> literal el decisions (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> 0 < elementLevel literal (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<longrightarrow> (\<exists>reason. getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> isReason (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) literal (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))))) \<and> (0 < currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> literal \<in> set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<longrightarrow> (\<exists>reason. getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) \<and> (isUnitClause (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) literal (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<or> clauseFalse (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) ! reason) (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))))))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "var (hd ?clause') \<in> vars F0"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
[PROOF STEP]
using \<open>?clause' \<noteq> []\<close>
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
[PROOF STEP]
using hd_in_set[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
[PROOF STEP]
using \<open>vars ?clause' \<subseteq> vars F0\<close>
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0

goal (1 subgoal):
 1. var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
[PROOF STEP]
using clauseContainsItsLiteralsVariable[of "hd ?clause'" "?clause'"]
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> hd (remdups (removeFalseLiterals clause (elements (getM state)))) \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
hd (remdups (removeFalseLiterals clause (elements (getM state)))) el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "InvariantVarsQ (getQ ?state') F0 Vbl"
          "InvariantVarsM (getM ?state') F0 Vbl"
          "InvariantVarsF (getF ?state') F0 Vbl"
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchListsUniq (getWatchList state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantVarsF (getF state) F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantVarsM (getM state) F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>InvariantVarsQ (getQ state) F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using \<open>uniq (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using varsAppendValuation[of "elements (getM state)" "[hd ?clause']"]
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
vars (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))]) = vars (elements (getM state)) \<union> vars [hd (remdups (removeFalseLiterals clause (elements (getM state))))]

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
using InvariantVarsQAfterAssertLiteral[of "state" "hd ?clause'" "False" "F0" "Vbl"]
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
vars (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))]) = vars (elements (getM state)) \<union> vars [hd (remdups (removeFalseLiterals clause (elements (getM state))))]
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantVarsQ (getQ state) F0 Vbl; InvariantVarsF (getF state) F0 Vbl\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantVarsQ (getQ state') F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
unfolding InvariantVarsM_def
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
vars (elements (getM state)) \<subseteq> vars F0 \<union> Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
vars (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))]) = vars (elements (getM state)) \<union> vars [hd (remdups (removeFalseLiterals clause (elements (getM state))))]
\<lbrakk>InvariantConsistent (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantVarsQ (getQ state) F0 Vbl; InvariantVarsF (getF state) F0 Vbl\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantVarsQ (getQ state') F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
vars (elements (getM state)) \<subseteq> vars F0 \<union> Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
vars (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))]) = vars (elements (getM state)) \<union> vars [hd (remdups (removeFalseLiterals clause (elements (getM state))))]
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantUniq (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantVarsQ (getQ state) F0 Vbl; InvariantVarsF (getF state) F0 Vbl\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantVarsQ (getQ state') F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
var (hd (remdups (removeFalseLiterals clause (elements (getM state))))) \<in> vars F0
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantVarsF (getF state) F0 Vbl
vars (elements (getM state)) \<subseteq> vars F0 \<union> Vbl
InvariantVarsQ (getQ state) F0 Vbl
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
vars (elements (getM state) @ [hd (remdups (removeFalseLiterals clause (elements (getM state))))]) = vars (elements (getM state)) \<union> vars [hd (remdups (removeFalseLiterals clause (elements (getM state))))]
\<lbrakk>consistent (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); uniq (elements (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)])); InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchListsUniq (getWatchList state); InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state); InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state); InvariantVarsQ (getQ state) F0 Vbl; InvariantVarsF (getF state) F0 Vbl\<rbrakk> \<Longrightarrow> let state' = assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state in InvariantVarsQ (getQ state') F0 Vbl

goal (1 subgoal):
 1. InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl &&& vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> Vbl &&& InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "exhaustiveUnitPropagate_dom ?state'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using exhaustiveUnitPropagateTermination[of "?state'" "F0" "Vbl"]
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantUniqQ (getQ ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state') (getF ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchListsUniq (getWatchList ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchListsCharacterization (getWatchList ?state') (getWatch1 ?state') (getWatch2 ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchesEl (getF ?state') (getWatch1 ?state') (getWatch2 ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchesDiffer (getF ?state') (getWatch1 ?state') (getWatch2 ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantQCharacterization (getConflictFlag ?state') (getQ ?state') (getF ?state') (getM ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantWatchCharacterization (getF ?state') (getWatch1 ?state') (getWatch2 ?state') (getM ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantConflictFlagCharacterization (getConflictFlag ?state') (getF ?state') (getM ?state')\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>consistent (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>uniq (elements (getM ?state'))\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>finite Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantVarsQ (getQ ?state') F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantVarsM (getM ?state') F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
using \<open>InvariantVarsF (getF ?state') F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl; finite Vbl\<rbrakk> \<Longrightarrow> exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
finite Vbl
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl

goal (1 subgoal):
 1. exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (2 subgoals):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>exhaustiveUnitPropagate_dom ?state'\<close>
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using InvariantsAfterExhaustiveUnitPropagate[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using InvariantConflictClauseCharacterizationAfterExhaustivePropagate[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using conflictFlagOrQEmptyAfterExhaustiveUnitPropagate[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using exhaustiveUnitPropagatePreservesCurrentLevel[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using InvariantGetReasonIsReasonAfterExhaustiveUnitPropagate[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantConsistent (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in consistent (elements (getM state')) \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantUniq (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
consistent (elements (getM state))
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. let state' = addClause clause state in consistent (elements (getM state')) \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
addClause clause state = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = 0
InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))
InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) F0 Vbl
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantVarsQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsM (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl; InvariantVarsF (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) ?F0.0 ?Vbl\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in consistent (elements (getM state')) \<and> uniq (elements (getM state')) \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') ?F0.0 ?Vbl \<and> InvariantVarsM (getM state') ?F0.0 ?Vbl \<and> InvariantVarsF (getF state') ?F0.0 ?Vbl
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictClauseCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getConflictClause (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state')
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in getConflictFlag state' \<or> getQ state' = []
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in currentLevel (getM state') = currentLevel (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))
\<lbrakk>exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state); consistent (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); uniq (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))); InvariantWatchListsContainOnlyClausesFromF (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsUniq (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchListsCharacterization (getWatchList (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesEl (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchesDiffer (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantWatchCharacterization (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch1 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getWatch2 (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantConflictFlagCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantQCharacterization (getConflictFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantUniqQ (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)); InvariantGetReasonIsReason (getReason (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (set (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state'))
consistent (elements (getM state))
uniq (elements (getM state))
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getF state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = getSATFlag state
\<lbrakk>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state); InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<rbrakk> \<Longrightarrow> isPrefix (getQ state) (getQ (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))

goal (1 subgoal):
 1. let state' = addClause clause state in consistent (elements (getM state')) \<and> uniq (elements (getM state')) \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
by (auto simp only:Let_def)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal (1 subgoal):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. \<lbrakk>remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []; length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
proof (cases "clauseTautology ?clause'")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (2 subgoals):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
 2. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = setWatch1 clauseIndex (clause' ! 0) state'; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
from \<open>\<not> ?clause' = []\<close> \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (chain)
picking this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1
[PROOF STEP]
have "length ?clause' > 1"
[PROOF STATE]
proof (prove)
using this:
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. 1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
by (induct (?clause')) auto
[PROOF STATE]
proof (state)
this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "nth ?clause' 0 \<noteq> nth ?clause' 1"
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1
[PROOF STEP]
using distinct_remdups[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
distinct (remdups (remdups (removeFalseLiterals clause (elements (getM state)))))

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1
[PROOF STEP]
using nth_eq_iff_index_eq[of "?clause'" "0" "1"]
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
distinct (remdups (remdups (removeFalseLiterals clause (elements (getM state)))))
\<lbrakk>distinct (remdups (removeFalseLiterals clause (elements (getM state)))); 0 < length (remdups (removeFalseLiterals clause (elements (getM state)))); 1 < length (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> (remdups (removeFalseLiterals clause (elements (getM state))) ! 0 = remdups (removeFalseLiterals clause (elements (getM state))) ! 1) = (0 = 1)

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
distinct (remdups (remdups (removeFalseLiterals clause (elements (getM state)))))
\<lbrakk>distinct (remdups (removeFalseLiterals clause (elements (getM state)))); 0 < length (remdups (removeFalseLiterals clause (elements (getM state)))); 1 < length (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> (remdups (removeFalseLiterals clause (elements (getM state))) ! 0 = remdups (removeFalseLiterals clause (elements (getM state))) ! 1) = (0 = 1)
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
let ?state' = "let clauseIndex = length (getF state) in
                         let state'   = state\<lparr> getF := (getF state) @ [?clause']\<rparr> in
                         let state''  = setWatch1 clauseIndex (nth ?clause' 0) state' in
                         let state''' = setWatch2 clauseIndex (nth ?clause' 1) state'' in
                         state'''"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchesEl (getF ?state') (getWatch1 ?state') (getWatch2 ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>length ?clause' > 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>?clause' \<noteq> []\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using nth_mem[of "0" "?clause'"]
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
0 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using nth_mem[of "1" "?clause'"]
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
0 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
1 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 1 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchesEl_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> (\<exists>w1 w2. getWatch1 state clause = Some w1 \<and> getWatch2 state clause = Some w2 \<and> w1 el getF state ! clause \<and> w2 el getF state ! clause)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
0 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
1 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 1 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea)
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> (\<exists>w1 w2. getWatch1 state clause = Some w1 \<and> getWatch2 state clause = Some w2 \<and> w1 el getF state ! clause \<and> w2 el getF state ! clause)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
0 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
1 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 1 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea)
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> (\<exists>w1 w2. getWatch1 state clause = Some w1 \<and> getWatch2 state clause = Some w2 \<and> w1 el getF state ! clause \<and> w2 el getF state ! clause)
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
0 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))
1 < length (remdups (removeFalseLiterals clause (elements (getM state)))) \<Longrightarrow> remdups (removeFalseLiterals clause (elements (getM state))) ! 1 \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea)
[PROOF STEP]
by (auto simp add: Let_def nth_append)
[PROOF STATE]
proof (state)
this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchesDiffer (getF ?state') (getWatch1 ?state') (getWatch2 ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>nth ?clause' 0 \<noteq> nth ?clause' 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchesDiffer_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> getWatch1 state clause \<noteq> getWatch2 state clause
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<longrightarrow> getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea \<noteq> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> getWatch1 state clause \<noteq> getWatch2 state clause
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<longrightarrow> getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea \<noteq> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clause. 0 \<le> clause \<and> clause < length (getF state) \<longrightarrow> getWatch1 state clause \<noteq> getWatch2 state clause
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea \<noteq> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchListsContainOnlyClausesFromF (getWatchList ?state') (getF ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchListsContainOnlyClausesFromF_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)

goal (1 subgoal):
 1. \<forall>l c. c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l) \<longrightarrow> 0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)

goal (1 subgoal):
 1. \<forall>l c. c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l) \<longrightarrow> 0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)

goal (1 subgoal):
 1. \<forall>l c. c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') l) \<longrightarrow> 0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
[PROOF STEP]
by (auto simp add:Let_def) (force)+
[PROOF STATE]
proof (state)
this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchListsCharacterization (getWatchList ?state') (getWatch1 ?state') (getWatch2 ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>nth ?clause' 0 \<noteq> nth ?clause' 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchListsCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<forall>c l. (c \<in> set (getWatchList state l)) = (Some l = getWatch1 state c \<or> Some l = getWatch2 state c)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>c l. (c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l)) = (Some l = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c \<or> Some l = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c)
[PROOF STEP]
unfolding InvariantWatchListsContainOnlyClausesFromF_def
[PROOF STATE]
proof (prove)
using this:
\<forall>c l. (c \<in> set (getWatchList state l)) = (Some l = getWatch1 state c \<or> Some l = getWatch2 state c)
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>c l. (c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l)) = (Some l = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c \<or> Some l = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c)
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>c l. (c \<in> set (getWatchList state l)) = (Some l = getWatch1 state c \<or> Some l = getWatch2 state c)
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>c l. (c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l)) = (Some l = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c \<or> Some l = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c)
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>c l. (c \<in> set (getWatchList state l)) = (Some l = getWatch1 state c \<or> Some l = getWatch2 state c)
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>c l. (c \<in> set (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') l)) = (Some l = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') c \<or> Some l = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') c)
[PROOF STEP]
by (auto simp add:Let_def)
[PROOF STATE]
proof (state)
this:
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantWatchCharacterization (getF ?state') (getWatch1 ?state') (getWatch2 ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
fix c
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
assume "0 \<le> c \<and> c < length (getF ?state')"
[PROOF STATE]
proof (state)
this:
0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
fix www1 www2
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
assume "Some www1 = (getWatch1 ?state' c)" "Some www2 = (getWatch2 ?state' c)"
[PROOF STATE]
proof (state)
this:
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
have "watchCharacterizationCondition www1 www2 (getM ?state') (nth (getF ?state') c) \<and>
                    watchCharacterizationCondition www2 www1 (getM ?state') (nth (getF ?state') c)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
proof (cases "c < length (getF state)")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
 2. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
c < length (getF state)

goal (2 subgoals):
 1. c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
 2. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
hence "(nth (getF ?state') c) = (nth (getF state) c)"
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)

goal (1 subgoal):
 1. getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)

goal (1 subgoal):
 1. getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)

goal (1 subgoal):
 1. getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c = getF state ! c
[PROOF STEP]
by (auto simp add: Let_def nth_append)
[PROOF STATE]
proof (state)
this:
getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c

goal (2 subgoals):
 1. c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
 2. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
have "Some www1 = (getWatch1 state c)" "Some www2 = (getWatch2 state c)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. Some www1 = getWatch1 state c &&& Some www2 = getWatch2 state c
[PROOF STEP]
using True
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)

goal (1 subgoal):
 1. Some www1 = getWatch1 state c &&& Some www2 = getWatch2 state c
[PROOF STEP]
using \<open>Some www1 = (getWatch1 ?state' c)\<close> \<open>Some www2 = (getWatch2 ?state' c)\<close>
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c

goal (1 subgoal):
 1. Some www1 = getWatch1 state c &&& Some www2 = getWatch2 state c
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c

goal (1 subgoal):
 1. Some www1 = getWatch1 state c &&& Some www2 = getWatch2 state c
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
c < length (getF state)
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') c

goal (1 subgoal):
 1. Some www1 = getWatch1 state c &&& Some www2 = getWatch2 state c
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c

goal (2 subgoals):
 1. c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
 2. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
using \<open>InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
unfolding InvariantWatchCharacterization_def
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
\<forall>c w1 w2. 0 \<le> c \<and> c < length (getF state) \<and> Some w1 = getWatch1 state c \<and> Some w2 = getWatch2 state c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM state) (getF state ! c) \<and> watchCharacterizationCondition w2 w1 (getM state) (getF state ! c)

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
using \<open>(nth (getF ?state') c) = (nth (getF state) c)\<close>
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
\<forall>c w1 w2. 0 \<le> c \<and> c < length (getF state) \<and> Some w1 = getWatch1 state c \<and> Some w2 = getWatch2 state c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM state) (getF state ! c) \<and> watchCharacterizationCondition w2 w1 (getM state) (getF state ! c)
getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
using True
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
\<forall>c w1 w2. 0 \<le> c \<and> c < length (getF state) \<and> Some w1 = getWatch1 state c \<and> Some w2 = getWatch2 state c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM state) (getF state ! c) \<and> watchCharacterizationCondition w2 w1 (getM state) (getF state ! c)
getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c
c < length (getF state)

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
\<forall>c w1 w2. 0 \<le> c \<and> c < length (getF state) \<and> Some w1 = getWatch1 state c \<and> Some w2 = getWatch2 state c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM state) (getF state ! c) \<and> watchCharacterizationCondition w2 w1 (getM state) (getF state ! c)
getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c = getF state ! c
c < length (getF state)

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
Some www1 = getWatch1 state c
Some www2 = getWatch2 state c
\<forall>c w1 w2. 0 \<le> c \<and> c < length (getF state) \<and> Some w1 = getWatch1 state c \<and> Some w2 = getWatch2 state c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM state) (getF state ! c) \<and> watchCharacterizationCondition w2 w1 (getM state) (getF state ! c)
getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c = getF state ! c
c < length (getF state)

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c)
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> c < length (getF state)

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
with \<open>0 \<le> c \<and> c < length (getF ?state')\<close>
[PROOF STATE]
proof (chain)
picking this:
0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
\<not> c < length (getF state)
[PROOF STEP]
have "c = length (getF state)"
[PROOF STATE]
proof (prove)
using this:
0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
\<not> c < length (getF state)

goal (1 subgoal):
 1. c = length (getF state)
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
\<not> c < length (getF state)

goal (1 subgoal):
 1. c = length (getF state)
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
\<not> c < length (getF state)

goal (1 subgoal):
 1. c = length (getF state)
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
c = length (getF state)

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
from \<open>InvariantWatchesEl (getF ?state') (getWatch1 ?state') (getWatch2 ?state')\<close>
[PROOF STATE]
proof (chain)
picking this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
obtain w1 w2
                  where
                  "w1 el ?clause'" "w2 el ?clause'"
                  "getWatch1 ?state' (length (getF state)) = Some w1"
                  "getWatch2 ?state' (length (getF state)) = Some w2"
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. (\<And>w1 w2. \<lbrakk>w1 el remdups (removeFalseLiterals clause (elements (getM state))); w2 el remdups (removeFalseLiterals clause (elements (getM state))); getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1; getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding InvariantWatchesEl_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! clausea)

goal (1 subgoal):
 1. (\<And>w1 w2. \<lbrakk>w1 el remdups (removeFalseLiterals clause (elements (getM state))); w2 el remdups (removeFalseLiterals clause (elements (getM state))); getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1; getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea)

goal (1 subgoal):
 1. (\<And>w1 w2. \<lbrakk>w1 el remdups (removeFalseLiterals clause (elements (getM state))); w2 el remdups (removeFalseLiterals clause (elements (getM state))); getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') (length (getF state)) = Some w1; getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') (length (getF state)) = Some w2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>clausea. 0 \<le> clausea \<and> clausea < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> (\<exists>w1 w2. getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w1 \<and> getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') clausea = Some w2 \<and> w1 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea \<and> w2 el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! clausea)

goal (1 subgoal):
 1. (\<And>w1 w2. \<lbrakk>w1 el remdups (removeFalseLiterals clause (elements (getM state))); w2 el remdups (removeFalseLiterals clause (elements (getM state))); getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') (length (getF state)) = Some w1; getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') (length (getF state)) = Some w2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1
getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
hence "w1 = www1" and "w2 = www2"
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1
getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2

goal (1 subgoal):
 1. w1 = www1 &&& w2 = www2
[PROOF STEP]
using \<open>Some www1 = (getWatch1 ?state' c)\<close> \<open>Some www2 = (getWatch2 ?state' c)\<close>
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1
getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c

goal (1 subgoal):
 1. w1 = www1 &&& w2 = www2
[PROOF STEP]
using \<open>c = length (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w1
getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') (length (getF state)) = Some w2
Some www1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
Some www2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c
c = length (getF state)

goal (1 subgoal):
 1. w1 = www1 &&& w2 = www2
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
w1 = www1
w2 = www2

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
have "\<not> literalFalse  w1 (elements (getM ?state'))"
                  "\<not> literalFalse w2 (elements (getM ?state'))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) &&& \<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
using \<open>w1 el ?clause'\<close> \<open>w2 el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) &&& \<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))

goal (1 subgoal):
 1. \<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) &&& \<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))

goal (1 subgoal):
 1. \<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) &&& \<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
w1 el remdups (removeFalseLiterals clause (elements (getM state)))
w2 el remdups (removeFalseLiterals clause (elements (getM state)))
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))

goal (1 subgoal):
 1. \<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) &&& \<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))

goal (1 subgoal):
 1. \<not> c < length (getF state) \<Longrightarrow> watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
using \<open>w1 = www1\<close> \<open>w2 = www2\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
w1 = www1
w2 = www2

goal (1 subgoal):
 1. watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
unfolding watchCharacterizationCondition_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
w1 = www1
w2 = www2

goal (1 subgoal):
 1. (literalFalse www1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c \<and> l \<noteq> www1 \<and> l \<noteq> www2 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))) \<and> (literalFalse www2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c \<and> l \<noteq> www2 \<and> l \<noteq> www1 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
w1 = www1
w2 = www2

goal (1 subgoal):
 1. (literalFalse www1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> l \<noteq> www1 \<and> l \<noteq> www2 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))) \<and> (literalFalse www2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> l \<noteq> www2 \<and> l \<noteq> www1 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse w1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
\<not> literalFalse w2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
w1 = www1
w2 = www2

goal (1 subgoal):
 1. (literalFalse www1 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> l \<noteq> www1 \<and> l \<noteq> www2 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www1) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))) \<and> (literalFalse www2 (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<longrightarrow> (\<exists>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> literalTrue l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel l (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<or> (\<forall>l. l el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! c \<and> l \<noteq> www2 \<and> l \<noteq> www1 \<longrightarrow> literalFalse l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<and> elementLevel (opposite l) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<le> elementLevel (opposite www2) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
watchCharacterizationCondition www1 www2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition www2 www1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<lbrakk>0 \<le> ?c2 \<and> ?c2 < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')); Some ?www1.2 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2; Some ?www2.2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2\<rbrakk> \<Longrightarrow> watchCharacterizationCondition ?www1.2 ?www2.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2) \<and> watchCharacterizationCondition ?www2.2 ?www1.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2)

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>0 \<le> ?c2 \<and> ?c2 < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')); Some ?www1.2 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2; Some ?www2.2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2\<rbrakk> \<Longrightarrow> watchCharacterizationCondition ?www1.2 ?www2.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2) \<and> watchCharacterizationCondition ?www2.2 ?www1.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2)

goal (1 subgoal):
 1. InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<lbrakk>0 \<le> ?c2 \<and> ?c2 < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')); Some ?www1.2 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2; Some ?www2.2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ?c2\<rbrakk> \<Longrightarrow> watchCharacterizationCondition ?www1.2 ?www2.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2) \<and> watchCharacterizationCondition ?www2.2 ?www1.2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! ?c2)

goal (1 subgoal):
 1. \<forall>c w1 w2. 0 \<le> c \<and> c < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) \<and> Some w1 = getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c \<and> Some w2 = getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') c \<longrightarrow> watchCharacterizationCondition w1 w2 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c) \<and> watchCharacterizationCondition w2 w1 (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') ! c)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "\<forall> l. length (getF state) \<notin> set (getWatchList state l)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>l. length (getF state) \<notin> set (getWatchList state l)
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. \<forall>l. length (getF state) \<notin> set (getWatchList state l)
[PROOF STEP]
unfolding InvariantWatchListsContainOnlyClausesFromF_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l c. c \<in> set (getWatchList state l) \<longrightarrow> 0 \<le> c \<and> c < length (getF state)

goal (1 subgoal):
 1. \<forall>l. length (getF state) \<notin> set (getWatchList state l)
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "InvariantWatchListsUniq (getWatchList ?state')"
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)

goal (1 subgoal):
 1. InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantWatchListsUniq (getWatchList state)\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)
InvariantWatchListsUniq (getWatchList state)

goal (1 subgoal):
 1. InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>nth ?clause' 0 \<noteq> nth ?clause' 1\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)
InvariantWatchListsUniq (getWatchList state)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantWatchListsUniq_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)
\<forall>l. uniq (getWatchList state l)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>l. uniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l)
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)
\<forall>l. uniq (getWatchList state l)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>l. uniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') l)
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<forall>l. length (getF state) \<notin> set (getWatchList state l)
\<forall>l. uniq (getWatchList state l)
remdups (removeFalseLiterals clause (elements (getM state))) ! 0 \<noteq> remdups (removeFalseLiterals clause (elements (getM state))) ! 1

goal (1 subgoal):
 1. \<forall>l. uniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') l)
[PROOF STEP]
by (auto simp add:Let_def uniqAppendIff)
[PROOF STATE]
proof (state)
this:
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
from *
[PROOF STATE]
proof (chain)
picking this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
[PROOF STEP]
have "\<not> clauseFalse ?clause' (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))

goal (1 subgoal):
 1. \<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
[PROOF STEP]
using \<open>?clause' \<noteq> []\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. \<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
[PROOF STEP]
by (auto simp add: clauseFalseIffAllLiteralsAreFalse)
[PROOF STATE]
proof (state)
this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "InvariantConflictFlagCharacterization (getConflictFlag ?state') (getF ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
using this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using \<open>InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)

goal (1 subgoal):
 1. InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantConflictFlagCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
getConflictFlag state = formulaFalse (getF state) (elements (getM state))

goal (1 subgoal):
 1. getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') = formulaFalse (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
getConflictFlag state = formulaFalse (getF state) (elements (getM state))

goal (1 subgoal):
 1. getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') = formulaFalse (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<not> clauseFalse (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
getConflictFlag state = formulaFalse (getF state) (elements (getM state))

goal (1 subgoal):
 1. getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') = formulaFalse (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
[PROOF STEP]
by (auto simp add: Let_def formulaFalseIffContainsFalseClause)
[PROOF STATE]
proof (state)
this:
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "\<not> (\<exists> l. isUnitClause ?clause' l (elements (getM state)))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
assume "\<not> ?thesis"
[PROOF STATE]
proof (state)
this:
\<not> (\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state)))

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<not> (\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state)))
[PROOF STEP]
obtain l
                where "isUnitClause ?clause' l (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
\<not> (\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state)))

goal (1 subgoal):
 1. (\<And>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state)) \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
hence "l el ?clause'"
[PROOF STATE]
proof (prove)
using this:
isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal (1 subgoal):
 1. l el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
unfolding isUnitClause_def
[PROOF STATE]
proof (prove)
using this:
l el remdups (removeFalseLiterals clause (elements (getM state))) \<and> \<not> literalTrue l (elements (getM state)) \<and> \<not> literalFalse l (elements (getM state)) \<and> (\<forall>literal. literal el remdups (removeFalseLiterals clause (elements (getM state))) \<and> literal \<noteq> l \<longrightarrow> literalFalse literal (elements (getM state)))

goal (1 subgoal):
 1. l el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
l el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
have "\<exists> l'. l' el ?clause' \<and> l \<noteq> l'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
from \<open>length ?clause' > 1\<close>
[PROOF STATE]
proof (chain)
picking this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
obtain a1::Literal and a2::Literal
                  where "a1 el ?clause'" "a2 el ?clause'" "a1 \<noteq> a2"
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. (\<And>a1 a2. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
using lengthGtOneTwoDistinctElements[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
\<lbrakk>uniq (remdups (removeFalseLiterals clause (elements (getM state)))); 1 < length (remdups (removeFalseLiterals clause (elements (getM state)))); remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []\<rbrakk> \<Longrightarrow> \<exists>a1 a2. a1 \<in> set (remdups (removeFalseLiterals clause (elements (getM state)))) \<and> a2 \<in> set (remdups (removeFalseLiterals clause (elements (getM state)))) \<and> a1 \<noteq> a2

goal (1 subgoal):
 1. (\<And>a1 a2. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (auto simp add: uniqDistinct) (force)
[PROOF STATE]
proof (state)
this:
a1 el remdups (removeFalseLiterals clause (elements (getM state)))
a2 el remdups (removeFalseLiterals clause (elements (getM state)))
a1 \<noteq> a2

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
a1 el remdups (removeFalseLiterals clause (elements (getM state)))
a2 el remdups (removeFalseLiterals clause (elements (getM state)))
a1 \<noteq> a2

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
proof (cases "a1 = l")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 = l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
 2. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 \<noteq> l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
a1 = l

goal (2 subgoals):
 1. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 = l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
 2. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 \<noteq> l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
a1 = l

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
using \<open>a1 \<noteq> a2\<close> \<open>a2 el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
a1 = l
a1 \<noteq> a2
a2 el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'

goal (1 subgoal):
 1. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 \<noteq> l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 \<noteq> l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
a1 \<noteq> l

goal (1 subgoal):
 1. \<lbrakk>a1 el remdups (removeFalseLiterals clause (elements (getM state))); a2 el remdups (removeFalseLiterals clause (elements (getM state))); a1 \<noteq> a2; a1 \<noteq> l\<rbrakk> \<Longrightarrow> \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
a1 \<noteq> l

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
using \<open>a1 el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
a1 \<noteq> l
a1 el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'
[PROOF STEP]
obtain l'::Literal
                where "l \<noteq> l'" "l' el ?clause'"
[PROOF STATE]
proof (prove)
using this:
\<exists>l'. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<and> l \<noteq> l'

goal (1 subgoal):
 1. (\<And>l'. \<lbrakk>l \<noteq> l'; l' el remdups (removeFalseLiterals clause (elements (getM state)))\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
l \<noteq> l'
l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
with *
[PROOF STATE]
proof (chain)
picking this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
l \<noteq> l'
l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
have "\<not> literalFalse l' (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
\<forall>l. l el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> \<not> literalFalse l (elements (getM state))
l \<noteq> l'
l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. \<not> literalFalse l' (elements (getM state))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<not> literalFalse l' (elements (getM state))

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
hence "False"
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse l' (elements (getM state))

goal (1 subgoal):
 1. False
[PROOF STEP]
using \<open>isUnitClause ?clause' l (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse l' (elements (getM state))
isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal (1 subgoal):
 1. False
[PROOF STEP]
using \<open>l \<noteq> l'\<close> \<open>l' el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse l' (elements (getM state))
isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
l \<noteq> l'
l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. False
[PROOF STEP]
unfolding isUnitClause_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse l' (elements (getM state))
l el remdups (removeFalseLiterals clause (elements (getM state))) \<and> \<not> literalTrue l (elements (getM state)) \<and> \<not> literalFalse l (elements (getM state)) \<and> (\<forall>literal. literal el remdups (removeFalseLiterals clause (elements (getM state))) \<and> literal \<noteq> l \<longrightarrow> literalFalse literal (elements (getM state)))
l \<noteq> l'
l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<not> (\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))) \<Longrightarrow> False

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> (\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))) \<Longrightarrow> False

goal (1 subgoal):
 1. \<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
hence "InvariantQCharacterization (getConflictFlag ?state') (getQ ?state') (getF ?state') (getM ?state')"
[PROOF STATE]
proof (prove)
using this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
[PROOF STEP]
unfolding InvariantQCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
\<not> getConflictFlag state \<longrightarrow> (\<forall>l. l el getQ state = (\<exists>c. c el getF state \<and> isUnitClause c l (elements (getM state))))
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. \<not> getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') \<longrightarrow> (\<forall>l. l el getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') = (\<exists>c. c el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''') \<and> isUnitClause c l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
\<not> getConflictFlag state \<longrightarrow> (\<forall>l. l el getQ state = (\<exists>c. c el getF state \<and> isUnitClause c l (elements (getM state))))
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. \<not> getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') \<longrightarrow> (\<forall>l. l el getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') = (\<exists>c. c el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') \<and> isUnitClause c l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
\<nexists>l. isUnitClause (remdups (removeFalseLiterals clause (elements (getM state)))) l (elements (getM state))
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
\<not> getConflictFlag state \<longrightarrow> (\<forall>l. l el getQ state = (\<exists>c. c el getF state \<and> isUnitClause c l (elements (getM state))))
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. \<not> getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') \<longrightarrow> (\<forall>l. l el getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') = (\<exists>c. c el getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') \<and> isUnitClause c l (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))))
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [?clause']) (getM state)"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
proof (cases "getConflictFlag state")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
 2. \<not> getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> getConflictFlag state

goal (2 subgoals):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
 2. \<not> getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> getConflictFlag state

goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
unfolding InvariantConflictClauseCharacterization_def
[PROOF STATE]
proof (prove)
using this:
\<not> getConflictFlag state

goal (1 subgoal):
 1. getConflictFlag state \<longrightarrow> getConflictClause state < length (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) \<and> clauseFalse ((getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state) (elements (getM state))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)

goal (1 subgoal):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getConflictFlag state

goal (1 subgoal):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
hence "getConflictClause state < length (getF state)"
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state

goal (1 subgoal):
 1. getConflictClause state < length (getF state)
[PROOF STEP]
using \<open>InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)

goal (1 subgoal):
 1. getConflictClause state < length (getF state)
[PROOF STEP]
unfolding InvariantConflictClauseCharacterization_def
[PROOF STATE]
proof (prove)
using this:
getConflictFlag state
getConflictFlag state \<longrightarrow> getConflictClause state < length (getF state) \<and> clauseFalse (getF state ! getConflictClause state) (elements (getM state))

goal (1 subgoal):
 1. getConflictClause state < length (getF state)
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
getConflictClause state < length (getF state)

goal (1 subgoal):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
hence "nth ((getF state) @ [?clause']) (getConflictClause state) =
                   nth (getF state) (getConflictClause state)"
[PROOF STATE]
proof (prove)
using this:
getConflictClause state < length (getF state)

goal (1 subgoal):
 1. (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state = getF state ! getConflictClause state
[PROOF STEP]
by (simp add: nth_append)
[PROOF STATE]
proof (state)
this:
(getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state = getF state ! getConflictClause state

goal (1 subgoal):
 1. getConflictFlag state \<Longrightarrow> InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
(getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state = getF state ! getConflictClause state

goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
using \<open>InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
(getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state = getF state ! getConflictClause state
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)

goal (1 subgoal):
 1. InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
[PROOF STEP]
unfolding InvariantConflictClauseCharacterization_def
[PROOF STATE]
proof (prove)
using this:
(getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state = getF state ! getConflictClause state
getConflictFlag state \<longrightarrow> getConflictClause state < length (getF state) \<and> clauseFalse (getF state ! getConflictClause state) (elements (getM state))

goal (1 subgoal):
 1. getConflictFlag state \<longrightarrow> getConflictClause state < length (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) \<and> clauseFalse ((getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) ! getConflictClause state) (elements (getM state))
[PROOF STEP]
by (auto simp add: Let_def clauseFalseAppendValuation)
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantGetReasonIsReason (getReason ?state') (getF ?state') (getM ?state') (set (getQ ?state'))"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
using \<open>currentLevel (getM state) = 0\<close>
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0

goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
using elementLevelLeqCurrentLevel[of _ "getM state"]
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0
elementLevel ?a (getM state) \<le> currentLevel (getM state)

goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0
elementLevel ?a (getM state) \<le> currentLevel (getM state)

goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0
elementLevel ?a (getM state) \<le> currentLevel (getM state)

goal (1 subgoal):
 1. InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
[PROOF STEP]
unfolding InvariantGetReasonIsReason_def
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0
elementLevel ?a (getM state) \<le> currentLevel (getM state)

goal (1 subgoal):
 1. \<forall>literal. (literal el elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<and> \<not> literal el decisions (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<and> 0 < elementLevel literal (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> (\<exists>reason. getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<and> isReason (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! reason) literal (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))))) \<and> (0 < currentLevel (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<and> literal \<in> set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<longrightarrow> (\<exists>reason. getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') literal = Some reason \<and> 0 \<le> reason \<and> reason < length (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<and> (isUnitClause (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! reason) literal (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))) \<or> clauseFalse (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''') ! reason) (elements (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))))))
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
have "InvariantVarsF (getF ?state') F0 Vbl"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
[PROOF STEP]
using \<open>InvariantVarsF (getF state) F0 Vbl\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantVarsF (getF state) F0 Vbl

goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
[PROOF STEP]
using \<open>vars ?clause' \<subseteq> vars F0\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantVarsF (getF state) F0 Vbl
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0

goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
[PROOF STEP]
using varsAppendFormulae[of "getF state" "[?clause']"]
[PROOF STATE]
proof (prove)
using this:
InvariantVarsF (getF state) F0 Vbl
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
vars (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) = vars (getF state) \<union> vars [remdups (removeFalseLiterals clause (elements (getM state)))]

goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
InvariantVarsF (getF state) F0 Vbl
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
vars (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) = vars (getF state) \<union> vars [remdups (removeFalseLiterals clause (elements (getM state)))]

goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) F0 Vbl
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
InvariantVarsF (getF state) F0 Vbl
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
vars (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) = vars (getF state) \<union> vars [remdups (removeFalseLiterals clause (elements (getM state)))]

goal (1 subgoal):
 1. InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) F0 Vbl
[PROOF STEP]
unfolding InvariantVarsF_def
[PROOF STATE]
proof (prove)
using this:
vars (getF state) \<subseteq> vars F0 \<union> Vbl
vars (remdups (removeFalseLiterals clause (elements (getM state)))) \<subseteq> vars F0
vars (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) = vars (getF state) \<union> vars [remdups (removeFalseLiterals clause (elements (getM state)))]

goal (1 subgoal):
 1. vars (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) \<subseteq> vars F0 \<union> Vbl
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl

goal (1 subgoal):
 1. \<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1; \<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>length ?clause' > 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
using \<open>\<not> clauseTautology ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1
\<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = setWatch1 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 0) state'; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1
\<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = setWatch1 clauseIndex (clause' ! 0) state'; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = setWatch2 clauseIndex (remdups (removeFalseLiterals clause (elements (getM state))) ! 1) state'' in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1
\<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> clause' ! 0), getWatchList := (getWatchList state')(clause' ! 0 := clauseIndex # getWatchList state' (clause' ! 0))\<rparr>; state''' = setWatch2 clauseIndex (clause' ! 1) state'' in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
InvariantWatchesEl (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantWatchesDiffer (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantWatchListsContainOnlyClausesFromF (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantWatchListsCharacterization (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantWatchCharacterization (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch1 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getWatch2 (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantWatchListsUniq (getWatchList (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantConflictFlagCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantQCharacterization (getConflictFlag (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state'''))
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (getM state)
InvariantGetReasonIsReason (getReason (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (getM (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) (set (getQ (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')))
InvariantVarsF (getF (let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))]\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 0), getWatchList := (getWatchList state')(remdups (removeFalseLiterals clause (elements (getM state))) ! 0 := clauseIndex # getWatchList state' (remdups (removeFalseLiterals clause (elements (getM state))) ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> remdups (removeFalseLiterals clause (elements (getM state))) ! 1), getWatchList := (getWatchList state'')(remdups (removeFalseLiterals clause (elements (getM state))) ! 1 := clauseIndex # getWatchList state'' (remdups (removeFalseLiterals clause (elements (getM state))) ! 1))\<rparr> in state''')) F0 Vbl
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
InvariantWatchListsUniq (getWatchList state)
InvariantWatchListsCharacterization (getWatchList state) (getWatch1 state) (getWatch2 state)
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchesDiffer (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchCharacterization (getF state) (getWatch1 state) (getWatch2 state) (getM state)
InvariantConflictFlagCharacterization (getConflictFlag state) (getF state) (getM state)
InvariantConflictClauseCharacterization (getConflictFlag state) (getConflictClause state) (getF state) (getM state)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
InvariantGetReasonIsReason (getReason state) (getF state) (getM state) (set (getQ state))
currentLevel (getM state) = 0
getConflictFlag state \<or> getQ state = []
InvariantVarsM (getM state) F0 Vbl
InvariantVarsQ (getQ state) F0 Vbl
InvariantVarsF (getF state) F0 Vbl
finite Vbl
vars clause \<subseteq> vars F0
1 < length (remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
length (remdups (removeFalseLiterals clause (elements (getM state)))) \<noteq> 1
\<not> clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. let state' = let clause' = remdups (removeFalseLiterals clause (elements (getM state))) in if clauseTrue clause' (elements (getM state)) then state else if clause' = [] then state\<lparr>getSATFlag := FALSE\<rparr> else if length clause' = 1 then Let (assertLiteral (hd clause') False state) exhaustiveUnitPropagate else if clauseTautology clause' then state else let clauseIndex = length (getF state); state' = state\<lparr>getF := getF state @ [clause']\<rparr>; state'' = state'\<lparr>getWatch1 := getWatch1 state'(clauseIndex \<mapsto> clause' ! 0), getWatchList := (getWatchList state')(clause' ! 0 := clauseIndex # getWatchList state' (clause' ! 0))\<rparr>; state''' = state''\<lparr>getWatch2 := getWatch2 state''(clauseIndex \<mapsto> clause' ! 1), getWatchList := (getWatchList state'')(clause' ! 1 := clauseIndex # getWatchList state'' (clause' ! 1))\<rparr> in state''' in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state in InvariantConsistent (getM state') \<and> InvariantUniq (getM state') \<and> InvariantWatchListsContainOnlyClausesFromF (getWatchList state') (getF state') \<and> InvariantWatchListsUniq (getWatchList state') \<and> InvariantWatchListsCharacterization (getWatchList state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesEl (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchesDiffer (getF state') (getWatch1 state') (getWatch2 state') \<and> InvariantWatchCharacterization (getF state') (getWatch1 state') (getWatch2 state') (getM state') \<and> InvariantConflictFlagCharacterization (getConflictFlag state') (getF state') (getM state') \<and> InvariantConflictClauseCharacterization (getConflictFlag state') (getConflictClause state') (getF state') (getM state') \<and> InvariantQCharacterization (getConflictFlag state') (getQ state') (getF state') (getM state') \<and> InvariantGetReasonIsReason (getReason state') (getF state') (getM state') (set (getQ state')) \<and> InvariantUniqQ (getQ state') \<and> InvariantVarsQ (getQ state') F0 Vbl \<and> InvariantVarsM (getM state') F0 Vbl \<and> InvariantVarsF (getF state') F0 Vbl \<and> currentLevel (getM state') = 0 \<and> (getConflictFlag state' \<or> getQ state' = [])

goal:
No subgoals!
[PROOF STEP]
qed