[STATEMENT]
lemma InvariantEquivalentZLAfterAddClause:
fixes Phi :: Formula and clause :: Clause and state :: State and Vbl :: "Variable set"
assumes
*:"(getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi) \<or>
   (getSATFlag state = FALSE \<and> \<not> satisfiable Phi)"
  "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)"
  "InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)"
  "InvariantUniqQ (getQ state)"
  "(getConflictFlag state) \<or> (getQ state) = []"
  "currentLevel (getM state) = 0"
  "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
 let Phi' = Phi @ [clause] in
 let Phi'' = (if (clauseTautology clause) then Phi else Phi') in
 (getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'') \<or>
 (getSATFlag state' = FALSE \<and> \<not>satisfiable Phi'')"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
let ?clause' = "remdups (removeFalseLiterals clause (elements (getM state)))"
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
from \<open>currentLevel (getM state) = 0\<close>
[PROOF STATE]
proof (chain)
picking this:
currentLevel (getM state) = 0
[PROOF STEP]
have "getM state = prefixToLevel 0 (getM state)"
[PROOF STATE]
proof (prove)
using this:
currentLevel (getM state) = 0

goal (1 subgoal):
 1. getM state = prefixToLevel 0 (getM state)
[PROOF STEP]
by (rule currentLevelZeroTrailEqualsItsPrefixToLevelZero)
[PROOF STATE]
proof (state)
this:
getM state = prefixToLevel 0 (getM state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
from True
[PROOF STATE]
proof (chain)
picking this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
[PROOF STEP]
have "clauseTrue clause (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. clauseTrue clause (elements (getM state))
[PROOF STEP]
using clauseTrueRemoveDuplicateLiterals
        [of "removeFalseLiterals clause (elements (getM state))" "elements (getM state)"]
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state)) = clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. clauseTrue clause (elements (getM state))
[PROOF STEP]
using clauseTrueRemoveFalseLiterals
        [of "elements (getM state)" "clause"]
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state)) = clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
consistent (elements (getM state)) \<Longrightarrow> clauseTrue clause (elements (getM state)) = clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state))

goal (1 subgoal):
 1. clauseTrue clause (elements (getM state))
[PROOF STEP]
using \<open>InvariantConsistent (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state)) = clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
consistent (elements (getM state)) \<Longrightarrow> clauseTrue clause (elements (getM state)) = clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state))
InvariantConsistent (getM state)

goal (1 subgoal):
 1. clauseTrue clause (elements (getM state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state)) = clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
consistent (elements (getM state)) \<Longrightarrow> clauseTrue clause (elements (getM state)) = clauseTrue (removeFalseLiterals clause (elements (getM state))) (elements (getM state))
consistent (elements (getM state))

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

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof (cases "getSATFlag state = UNDEF")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getSATFlag state = UNDEF

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>clauseTrue clause (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>getM state = prefixToLevel 0 (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))
getM state = prefixToLevel 0 (getM state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiedClauseCanBeRemoved
          [of "getF state" "(elements (prefixToLevel 0 (getM state)))" "Phi" "clause"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))
getM state = prefixToLevel 0 (getM state)
\<lbrakk>equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi; clauseTrue clause (elements (prefixToLevel 0 (getM state)))\<rbrakk> \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) (Phi @ [clause])

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))
getM state = prefixToLevel 0 (getM state)
\<lbrakk>equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi; clauseTrue clause (elements (prefixToLevel 0 (getM state)))\<rbrakk> \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) (Phi @ [clause])
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))
getM state = prefixToLevel 0 (getM state)
\<lbrakk>equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi; clauseTrue clause (elements (prefixToLevel 0 (getM state)))\<rbrakk> \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) (Phi @ [clause])
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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding InvariantEquivalentZL_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue clause (elements (getM state))
getM state = prefixToLevel 0 (getM state)
\<lbrakk>equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi; clauseTrue clause (elements (prefixToLevel 0 (getM state)))\<rbrakk> \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) (Phi @ [clause])
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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableAppend[of "Phi" "[clause]"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by force
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. \<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof (cases "getSATFlag state = UNDEF")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getSATFlag state = UNDEF

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using falseAndDuplicateLiteralsCanBeRemoved
          [of "getF state" "(elements (prefixToLevel 0 (getM state)))" "[]" "Phi" "clause"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>getM state = prefixToLevel 0 (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using formulaWithEmptyClauseIsUnsatisfiable[of "(getF state @ val2form (elements (getM state)) @ [[]])"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableEquivalent
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])
equivalentFormulae ?formula1.0 ?formula2.0 \<Longrightarrow> satisfiable ?formula1.0 = satisfiable ?formula2.0

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])
equivalentFormulae ?formula1.0 ?formula2.0 \<Longrightarrow> satisfiable ?formula1.0 = satisfiable ?formula2.0
remdups (removeFalseLiterals clause (elements (getM state))) = []

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])
equivalentFormulae ?formula1.0 ?formula2.0 \<Longrightarrow> satisfiable ?formula1.0 = satisfiable ?formula2.0
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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding InvariantEquivalentZL_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])
equivalentFormulae ?formula1.0 ?formula2.0 \<Longrightarrow> satisfiable ?formula1.0 = satisfiable ?formula2.0
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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableAppendTautology
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
[] el getF state @ val2form (elements (getM state)) @ [[]] \<Longrightarrow> \<not> satisfiable (getF state @ val2form (elements (getM state)) @ [[]])
equivalentFormulae ?formula1.0 ?formula2.0 \<Longrightarrow> satisfiable ?formula1.0 = satisfiable ?formula2.0
remdups (removeFalseLiterals clause (elements (getM state))) = []
\<lbrakk>satisfiable ?F; clauseTautology ?c\<rbrakk> \<Longrightarrow> satisfiable (?F @ [?c])

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
remdups (removeFalseLiterals clause (elements (getM state))) = []

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
remdups (removeFalseLiterals clause (elements (getM state))) = []
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableAppend[of "Phi" "[clause]"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
remdups (removeFalseLiterals clause (elements (getM state))) = []
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
remdups (removeFalseLiterals clause (elements (getM state))) = []
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by force
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> [] \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
from \<open>length ?clause' = 1\<close>
[PROOF STATE]
proof (chain)
picking this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
[PROOF STEP]
have "[hd ?clause'] = ?clause'"
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1

goal (1 subgoal):
 1. [hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
using lengthOneCharacterisation[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
(length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1) = (remdups (removeFalseLiterals clause (elements (getM state))) = [hd (remdups (removeFalseLiterals clause (elements (getM state))))])

goal (1 subgoal):
 1. [hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
with \<open>length ?clause' = 1\<close>
[PROOF STATE]
proof (chain)
picking this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
have "val2form (elements (getM state)) @ [?clause'] = val2form ((elements (getM state)) @ ?clause')"
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
using val2formAppend[of "elements (getM state)" "?clause'"]
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state)))) = val2form (elements (getM state)) @ val2form (remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
using val2formOfSingleLiteralValuation[of "?clause'"]
[PROOF STATE]
proof (prove)
using this:
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state)))) = val2form (elements (getM state)) @ val2form (remdups (removeFalseLiterals clause (elements (getM state))))
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1 \<Longrightarrow> val2form (remdups (removeFalseLiterals clause (elements (getM state)))) = [[hd (remdups (removeFalseLiterals clause (elements (getM state))))]]

goal (1 subgoal):
 1. val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state))))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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)]))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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)]))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
\<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)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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')
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
length (decisions (getM state)) = 0
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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "InvariantVarsM (getM ?state') F0 Vbl"
          "InvariantVarsQ (getQ ?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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. 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
[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. vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> 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
[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. vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> 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
[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. vars (elements (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))) \<subseteq> vars F0 \<union> 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
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
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

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
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

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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>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
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>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
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

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
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

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
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

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
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

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
moreover
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
have "\<not> clauseTautology clause"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
assume "\<not> ?thesis"
[PROOF STATE]
proof (state)
this:
\<not> \<not> clauseTautology clause

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<not> \<not> clauseTautology clause
[PROOF STEP]
obtain l'
              where "l' el clause" "opposite l' el clause"
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> clauseTautology clause

goal (1 subgoal):
 1. (\<And>l'. \<lbrakk>l' el clause; opposite l' el clause\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (auto simp add: clauseTautologyCharacterization)
[PROOF STATE]
proof (state)
this:
l' el clause
opposite l' el clause

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. False
[PROOF STEP]
proof (cases "l' el ?clause'")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
have "opposite l' el ?clause'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
assume "\<not> ?thesis"
[PROOF STATE]
proof (state)
this:
\<not> opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

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

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

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

goal (1 subgoal):
 1. literalFalse l' (elements (getM state))
[PROOF STEP]
using clauseTrueIffContainsTrueLiteral[of "?clause'" "elements (getM state)"]
[PROOF STATE]
proof (prove)
using this:
\<not> opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
l' el clause
opposite l' el clause
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))
clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state)) = (\<exists>literal. literal el remdups (removeFalseLiterals clause (elements (getM state))) \<and> literalTrue literal (elements (getM state)))

goal (1 subgoal):
 1. literalFalse l' (elements (getM state))
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
\<not> opposite l' el remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)
l' el clause
opposite l' el clause
\<not> clauseTrue (remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)) (elements (getM state))
clauseTrue (remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)) (elements (getM state)) = (\<exists>literal. literal el remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause) \<and> literalTrue literal (elements (getM state)))

goal (1 subgoal):
 1. literalFalse l' (elements (getM state))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
literalFalse l' (elements (getM state))

goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
hence False
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))

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

goal (1 subgoal):
 1. False
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))
l' el remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)

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

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

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

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

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
have "\<forall> x. x el ?clause' \<longrightarrow> x = l'"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'
[PROOF STEP]
using \<open>l' el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

goal (1 subgoal):
 1. \<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'
[PROOF STEP]
using lengthOneImpliesOnlyElement[of "?clause'" "l'"]
[PROOF STATE]
proof (prove)
using this:
l' el remdups (removeFalseLiterals clause (elements (getM state)))
length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1
\<lbrakk>length (remdups (removeFalseLiterals clause (elements (getM state)))) = 1; l' \<in> set (remdups (removeFalseLiterals clause (elements (getM state))))\<rbrakk> \<Longrightarrow> \<forall>a'. a' \<in> set (remdups (removeFalseLiterals clause (elements (getM state)))) \<longrightarrow> a' = l'

goal (1 subgoal):
 1. \<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
\<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'

goal (1 subgoal):
 1. False
[PROOF STEP]
using \<open>opposite l' el ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
\<forall>x. x el remdups (removeFalseLiterals clause (elements (getM state))) \<longrightarrow> x = l'
opposite 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. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

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

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

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

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

goal (1 subgoal):
 1. \<not> literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
using \<open>InvariantConsistent (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))
InvariantConsistent (getM state)

goal (1 subgoal):
 1. \<not> literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))
consistent (elements (getM state))

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

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

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

goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (opposite l') (elements (getM state))
opposite l' el clause

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

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

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

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

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

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

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<not> \<not> clauseTautology clause \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> clauseTautology clause \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology clause

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology clause

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology clause

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
note clc = calculation
[PROOF STATE]
proof (state)
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof (cases "getSATFlag state = UNDEF")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getSATFlag state = UNDEF

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "InvariantEquivalentZL (getF state) (getM state) Phi"
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF

goal (1 subgoal):
 1. InvariantEquivalentZL (getF state) (getM state) Phi
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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. InvariantEquivalentZL (getF state) (getM state) Phi
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
InvariantEquivalentZL (getF state) (getM state) Phi

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "InvariantEquivalentZL (getF ?state') (getM ?state') (Phi @ [clause])"
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using falseAndDuplicateLiteralsCanBeRemoved
            [of "getF state" "(elements (prefixToLevel 0 (getM state)))" "[]" "Phi" "clause"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>[hd ?clause'] = ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>getM state = prefixToLevel 0 (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>currentLevel (getM state) = 0\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using prefixToLevelAppend[of "0" "getM state" "[(hd ?clause', False)]"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>val2form (elements (getM state)) @ [?clause'] = val2form ((elements (getM state)) @ ?clause')\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state))))

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ remdups (removeFalseLiterals clause (elements (getM state))))
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>length ?clause' = 1\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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)))) = 1

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
using \<open>getSATFlag state = UNDEF\<close>
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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)))) = 1
getSATFlag state = UNDEF

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF state) (getM state) Phi
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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)))) = 1
getSATFlag state = UNDEF

goal (1 subgoal):
 1. InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
[PROOF STEP]
unfolding InvariantEquivalentZL_def
[PROOF STATE]
proof (prove)
using this:
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
[hd (remdups (removeFalseLiterals clause (elements (getM state))))] = remdups (removeFalseLiterals clause (elements (getM state)))
getM state = prefixToLevel 0 (getM state)
currentLevel (getM state) = 0
prefixToLevel 0 (getM state @ [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)]) = (if 0 < currentLevel (getM state) then prefixToLevel 0 (getM state) else getM state @ prefixToLevel_aux [(hd (remdups (removeFalseLiterals clause (elements (getM state)))), False)] 0 (currentLevel (getM state)))
InvariantWatchesEl (getF state) (getWatch1 state) (getWatch2 state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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))
val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] = val2form (elements (getM state) @ 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)))) = 1
getSATFlag state = UNDEF

goal (1 subgoal):
 1. equivalentFormulae (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) @ val2form (elements (prefixToLevel 0 (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state))))) (Phi @ [clause])
[PROOF STEP]
by (simp add: Let_def)
[PROOF STATE]
proof (state)
this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "let state'' = addClause clause state in
            InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and>
            getSATFlag state'' = getSATFlag state"
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])

goal (1 subgoal):
 1. let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
using clc
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
using InvariantEquivalentZLAfterExhaustiveUnitPropagate[of "?state'" "Phi @ [clause]"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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)); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])

goal (1 subgoal):
 1. let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
using exhaustiveUnitPropagatePreservedVariables[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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)); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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)); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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 InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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)); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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 InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
unfolding InvariantUniq_def
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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))); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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 InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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))); InvariantEquivalentZL (getF (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (getM (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) (Phi @ [clause]); 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))\<rbrakk> \<Longrightarrow> let state' = exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) in InvariantEquivalentZL (getF state') (getM state') (Phi @ [clause])
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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 InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
[PROOF STEP]
by (auto simp only: Let_def)
[PROOF STATE]
proof (state)
this:
let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using True
[PROOF STATE]
proof (prove)
using this:
let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
getSATFlag state = UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology clause\<close>
[PROOF STATE]
proof (prove)
using this:
let state'' = addClause clause state in InvariantEquivalentZL (getF state'') (getM state'') (Phi @ [clause]) \<and> getSATFlag state'' = getSATFlag state
getSATFlag state = UNDEF
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by (auto simp only: Let_def split: if_split)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "getSATFlag state = FALSE" "\<not> satisfiable Phi"
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. getSATFlag state = FALSE &&& \<not> satisfiable Phi
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. getSATFlag state = FALSE &&& \<not> satisfiable Phi
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
getSATFlag state = FALSE
\<not> satisfiable Phi

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "getSATFlag ?state' = FALSE"
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = FALSE
\<not> satisfiable Phi

goal (1 subgoal):
 1. getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE
[PROOF STEP]
using assertLiteralEffect[of "state" "hd ?clause'" "False"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = FALSE
\<not> satisfiable Phi
\<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. getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE
[PROOF STEP]
using assms
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = FALSE
\<not> satisfiable Phi
\<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))
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
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)
InvariantQCharacterization (getConflictFlag state) (getQ state) (getF state) (getM state)
InvariantUniqQ (getQ state)
getConflictFlag state \<or> getQ state = []
currentLevel (getM state) = 0
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. getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE
[PROOF STEP]
by simp
[PROOF STATE]
proof (state)
this:
getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "getSATFlag (exhaustiveUnitPropagate ?state') = FALSE"
[PROOF STATE]
proof (prove)
using this:
getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE

goal (1 subgoal):
 1. getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
[PROOF STEP]
using clc
[PROOF STATE]
proof (prove)
using this:
getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause

goal (1 subgoal):
 1. getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
[PROOF STEP]
using exhaustiveUnitPropagatePreservedVariables[of "?state'"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state) = FALSE
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<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 getSATFlag state' = getSATFlag (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)

goal (1 subgoal):
 1. getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
[PROOF STEP]
by (auto simp only: Let_def)
[PROOF STATE]
proof (state)
this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
moreover
[PROOF STATE]
proof (state)
this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
have "\<not> satisfiable (Phi @ [clause])"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> satisfiable (Phi @ [clause])
[PROOF STEP]
using satisfiableAppend[of "Phi" "[clause]"]
[PROOF STATE]
proof (prove)
using this:
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

goal (1 subgoal):
 1. \<not> satisfiable (Phi @ [clause])
[PROOF STEP]
using \<open>\<not> satisfiable Phi\<close>
[PROOF STATE]
proof (prove)
using this:
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<not> satisfiable Phi

goal (1 subgoal):
 1. \<not> satisfiable (Phi @ [clause])
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<not> satisfiable (Phi @ [clause])

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
\<not> satisfiable (Phi @ [clause])
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
\<not> satisfiable (Phi @ [clause])

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using clc
[PROOF STATE]
proof (prove)
using this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
\<not> satisfiable (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology clause\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag (exhaustiveUnitPropagate (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)) = FALSE
\<not> satisfiable (Phi @ [clause])
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))
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
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
exhaustiveUnitPropagate_dom (assertLiteral (hd (remdups (removeFalseLiterals clause (elements (getM state))))) False state)
\<not> clauseTautology clause
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by (simp only: Let_def) simp
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
moreover
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
hence "clauseTautology clause"
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))

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

goal (1 subgoal):
 1. clauseTautology clause
[PROOF STEP]
by (auto simp add: clauseTautologyCharacterization)
[PROOF STATE]
proof (state)
this:
clauseTautology clause

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
ultimately
[PROOF STATE]
proof (chain)
picking this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableAppend[of "Phi" "[clause]"]
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
(* Tautology problem *)
[PROOF STATE]
proof (prove)
using this:
clauseTautology (remdups (removeFalseLiterals clause (elements (getM state))))
clauseTautology clause
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF 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
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
have "\<not> clauseTautology clause"
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
proof-
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
{
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
assume "\<not> ?thesis"
[PROOF STATE]
proof (state)
this:
\<not> \<not> clauseTautology clause

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
then
[PROOF STATE]
proof (chain)
picking this:
\<not> \<not> clauseTautology clause
[PROOF STEP]
obtain l'
                where "l' el clause" "opposite l' el clause"
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> clauseTautology clause

goal (1 subgoal):
 1. (\<And>l'. \<lbrakk>l' el clause; opposite l' el clause\<rbrakk> \<Longrightarrow> thesis) \<Longrightarrow> thesis
[PROOF STEP]
by (auto simp add: clauseTautologyCharacterization)
[PROOF STATE]
proof (state)
this:
l' el clause
opposite l' el clause

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
have False
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. False
[PROOF STEP]
proof (cases "l' el ?clause'")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
l' el remdups (removeFalseLiterals clause (elements (getM state)))

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
hence "\<not> opposite l' el ?clause'"
[PROOF STATE]
proof (prove)
using this:
l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

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

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
hence "literalFalse (opposite l') (elements (getM state))"
[PROOF STATE]
proof (prove)
using this:
\<not> opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

goal (1 subgoal):
 1. literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
\<not> opposite l' el remdups (filter (\<lambda>l. \<not> literalFalse l (elements (getM state))) clause)
opposite l' el clause

goal (1 subgoal):
 1. literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
literalFalse (opposite l') (elements (getM state))

goal (2 subgoals):
 1. l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
 2. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
literalFalse (opposite l') (elements (getM state))

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

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

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

goal (1 subgoal):
 1. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. \<not> l' el remdups (removeFalseLiterals clause (elements (getM state))) \<Longrightarrow> False
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
\<not> l' el remdups (removeFalseLiterals clause (elements (getM state)))

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

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

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

goal (1 subgoal):
 1. literalFalse l' (elements (getM state))
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
literalFalse l' (elements (getM state))

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

goal (1 subgoal):
 1. \<not> literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
using \<open>InvariantConsistent (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))
InvariantConsistent (getM state)

goal (1 subgoal):
 1. \<not> literalFalse (opposite l') (elements (getM state))
[PROOF STEP]
unfolding InvariantConsistent_def
[PROOF STATE]
proof (prove)
using this:
literalFalse l' (elements (getM state))
consistent (elements (getM state))

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

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

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

goal (1 subgoal):
 1. opposite l' el remdups (removeFalseLiterals clause (elements (getM state)))
[PROOF STEP]
unfolding removeFalseLiterals_def
[PROOF STATE]
proof (prove)
using this:
\<not> literalFalse (opposite l') (elements (getM state))
opposite l' el clause

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

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

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

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

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

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

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
}
[PROOF STATE]
proof (state)
this:
\<not> \<not> clauseTautology clause \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
\<not> \<not> clauseTautology clause \<Longrightarrow> False

goal (1 subgoal):
 1. \<not> clauseTautology clause
[PROOF STEP]
by auto
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology clause

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
\<not> clauseTautology clause

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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
proof (cases "getSATFlag state = UNDEF")
[PROOF STATE]
proof (state)
goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case True
[PROOF STATE]
proof (state)
this:
getSATFlag state = UNDEF

goal (2 subgoals):
 1. getSATFlag state = UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
 2. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
show ?thesis
[PROOF STATE]
proof (prove)
goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using falseAndDuplicateLiteralsCanBeRemoved
              [of "getF state" "(elements (prefixToLevel 0 (getM state)))" "[]" "Phi" "clause"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>getM state = prefixToLevel 0 (getM state)\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> ?clause' = []\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (getM state)
remdups (removeFalseLiterals clause (elements (getM state))) \<noteq> []

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology clause\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>getSATFlag state = UNDEF\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding InvariantEquivalentZL_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using clauseOrderIrrelevant[of "getF state" "[?clause']" "val2form (elements (getM state))" "[]"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF
equivalentFormulae (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))] @ val2form (elements (getM state)) @ []) (getF state @ val2form (elements (getM state)) @ [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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using equivalentFormulaeTransitivity[of
                "getF state @ remdups (removeFalseLiterals clause (elements (getM state))) # val2form (elements (getM state))"
                "getF state @ val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))]"
                "Phi @ [clause]"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state = UNDEF \<and> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state)))) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ []) Phi \<Longrightarrow> equivalentFormulae (getF state @ val2form (elements (prefixToLevel 0 (getM state))) @ [remdups (removeFalseLiterals clause (elements (prefixToLevel 0 (getM state))))] @ []) (Phi @ [clause])
getM state = prefixToLevel 0 (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))))
\<not> clauseTautology clause
getSATFlag state = UNDEF
equivalentFormulae (getF state @ [remdups (removeFalseLiterals clause (elements (getM state)))] @ val2form (elements (getM state)) @ []) (getF state @ val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))] @ [])
\<lbrakk>equivalentFormulae (getF state @ remdups (removeFalseLiterals clause (elements (getM state))) # val2form (elements (getM state))) (getF state @ val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))]); equivalentFormulae (getF state @ val2form (elements (getM state)) @ [remdups (removeFalseLiterals clause (elements (getM state)))]) (Phi @ [clause])\<rbrakk> \<Longrightarrow> equivalentFormulae (getF state @ remdups (removeFalseLiterals clause (elements (getM state))) # val2form (elements (getM state))) (Phi @ [clause])

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> equivalentFormulae (getF state' @ val2form (elements (prefixToLevel 0 (getM state')))) Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
next
[PROOF STATE]
proof (state)
goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
case False
[PROOF STATE]
proof (state)
this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. getSATFlag state \<noteq> UNDEF \<Longrightarrow> let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
thus ?thesis
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using *
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using satisfiableAppend[of "Phi" "[clause]"]
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTrue ?clause' (elements (getM state))\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<not> clauseTrue (remdups (removeFalseLiterals clause (elements (getM state)))) (elements (getM state))

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>length ?clause' \<noteq> 1\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology ?clause'\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
using \<open>\<not> clauseTautology clause\<close>
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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))))
\<not> clauseTautology clause

goal (1 subgoal):
 1. let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding addClause_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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))))
\<not> clauseTautology clause

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding setWatch1_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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))))
\<not> clauseTautology clause

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
unfolding setWatch2_def
[PROOF STATE]
proof (prove)
using this:
getSATFlag state \<noteq> UNDEF
getSATFlag state = UNDEF \<and> InvariantEquivalentZL (getF state) (getM state) Phi \<or> getSATFlag state = FALSE \<and> \<not> satisfiable Phi
InvariantConsistent (getM state)
InvariantUniq (getM state)
InvariantWatchListsContainOnlyClausesFromF (getWatchList state) (getF state)
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable Phi
satisfiable (Phi @ [clause]) \<Longrightarrow> satisfiable [clause]
\<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))))
\<not> clauseTautology clause

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'''; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''
[PROOF STEP]
by (auto simp add: Let_def)
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed
[PROOF STATE]
proof (state)
this:
let state' = addClause clause state; Phi' = Phi @ [clause]; Phi'' = if clauseTautology clause then Phi else Phi' in getSATFlag state' = UNDEF \<and> InvariantEquivalentZL (getF state') (getM state') Phi'' \<or> getSATFlag state' = FALSE \<and> \<not> satisfiable Phi''

goal:
No subgoals!
[PROOF STEP]
qed