< Module unsat_proofs:clauses.
< Prove_Constraint unsat_proofs:lrat:proj_lit_unique.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_lit_is.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_clause_unique.
Subgoal 1:
Variables: CB High PlusOne Low
ProjA : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
ProjB : |{clause}- rangeClause Low High ~~> CB
ProjA1 : Low <= High
ProjA2 : 1 + Low = PlusOne
============================
or (pos Low) (rangeClause PlusOne High) = CB
< ProjB: case ProjB.
Subgoal 1.1:
Variables: High PlusOne Low PlusOne1
ProjA : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
ProjA1 : Low <= High
ProjA2 : 1 + Low = PlusOne
ProjB : Low <= High
ProjB1 : 1 + Low = PlusOne1
============================
or (pos Low) (rangeClause PlusOne High) = or (pos Low) (rangeClause PlusOne1 High)
< apply plus_integer_unique to ProjA2 ProjB1.
Subgoal 1.1:
Variables: High Low PlusOne1
ProjA : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne1 High)
ProjA1 : Low <= High
ProjA2 : 1 + Low = PlusOne1
ProjB : Low <= High
ProjB1 : 1 + Low = PlusOne1
============================
or (pos Low) (rangeClause PlusOne1 High) = or (pos Low) (rangeClause PlusOne1 High)
< search.
Subgoal 1.2:
Variables: High PlusOne Low
ProjA : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
ProjA1 : Low <= High
ProjA2 : 1 + Low = PlusOne
ProjB : Low > High
============================
or (pos Low) (rangeClause PlusOne High) = emptyClause
< apply greater_lesseq_integer_false to ProjB ProjA1.
Subgoal 2:
Variables: CB High Low
ProjA : |{clause}- rangeClause Low High ~~> emptyClause
ProjB : |{clause}- rangeClause Low High ~~> CB
ProjA1 : Low > High
============================
emptyClause = CB
< ProjB: case ProjB.
Subgoal 2.1:
Variables: High Low PlusOne
ProjA : |{clause}- rangeClause Low High ~~> emptyClause
ProjA1 : Low > High
ProjB : Low <= High
ProjB1 : 1 + Low = PlusOne
============================
emptyClause = or (pos Low) (rangeClause PlusOne High)
< apply greater_lesseq_integer_false to ProjA1 ProjB.
Subgoal 2.2:
Variables: High Low
ProjA : |{clause}- rangeClause Low High ~~> emptyClause
ProjA1 : Low > High
ProjB : Low > High
============================
emptyClause = emptyClause
< search.
Subgoal 3:
Variables: CA CB Note
ProjA : |{clause}- noteClause Note CA ~~> CA
ProjB : |{clause}- noteClause Note CA ~~> CB
============================
CA = CB
< case ProjB.
Subgoal 3:
Variables: CB Note
ProjA : |{clause}- noteClause Note CB ~~> CB
============================
CB = CB
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_clause_is.
Subgoal 1:
Variables: High PlusOne Low
Proj : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
IsC : is_clause (rangeClause Low High)
Proj1 : Low <= High
Proj2 : 1 + Low = PlusOne
============================
is_clause (or (pos Low) (rangeClause PlusOne High))
< Is: case IsC.
Subgoal 1:
Variables: High PlusOne Low
Proj : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Proj1 : Low <= High
Proj2 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
============================
is_clause (or (pos Low) (rangeClause PlusOne High))
< apply plus_integer_is_integer to _ _ Proj2.
Subgoal 1:
Variables: High PlusOne Low
Proj : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Proj1 : Low <= High
Proj2 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
H1 : is_integer PlusOne
============================
is_clause (or (pos Low) (rangeClause PlusOne High))
< search.
Subgoal 2:
Variables: High Low
Proj : |{clause}- rangeClause Low High ~~> emptyClause
IsC : is_clause (rangeClause Low High)
Proj1 : Low > High
============================
is_clause emptyClause
< search.
Subgoal 3:
Variables: CT Note
Proj : |{clause}- noteClause Note CT ~~> CT
IsC : is_clause (noteClause Note CT)
============================
is_clause CT
< case IsC.
Subgoal 3:
Variables: CT Note
Proj : |{clause}- noteClause Note CT ~~> CT
H1 : is_string Note
H2 : is_clause CT
============================
is_clause CT
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_formula_unique.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_formula_is.
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:is_clause.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:is_clause.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 3:
Variables: I I1
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
============================
<is_clause {P}> (rangeClause I1 I)
< Helper: assert forall Low High R,
is_integer Low -> is_integer High -> range Low High R -> <is_clause {P}> (rangeClause Low High).
Subgoal 3.1:
Variables: I I1
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
============================
forall Low High R,
is_integer Low -> is_integer High -> range Low High R -> <is_clause {P}> (rangeClause Low High)
< induction on 3.
Subgoal 3.1:
Variables: I I1
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
============================
forall Low High R,
is_integer Low -> is_integer High -> range Low High R @@ -> <is_clause {P}> (rangeClause Low High)
< intros IsLow IsHigh Range.
Subgoal 3.1:
Variables: I I1 Low High R
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : range Low High R @@
============================
<is_clause {P}> (rangeClause Low High)
< Range: case Range.
Subgoal 3.1.1:
Variables: I I1 Low High
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low > High
============================
<is_clause {P}> (rangeClause Low High)
< unfold .
Subgoal 3.1.1:
Variables: I I1 Low High
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low > High
============================
exists X_T,
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> X_T /\ <is_clause {P}> X_T)
< exists emptyClause.
Subgoal 3.1.1:
Variables: I I1 Low High
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low > High
============================
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> emptyClause /\
<is_clause {P}> emptyClause)
< search.
Subgoal 3.1.2:
Variables: I I1 Low High PlusOne Rest
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low <= High
Range1 : 1 + Low = PlusOne
Range2 : range PlusOne High Rest **
============================
<is_clause {P}> (rangeClause Low High)
< unfold .
Subgoal 3.1.2:
Variables: I I1 Low High PlusOne Rest
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low <= High
Range1 : 1 + Low = PlusOne
Range2 : range PlusOne High Rest **
============================
exists X_T,
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> X_T /\ <is_clause {P}> X_T)
< IsPlusOne: apply plus_integer_is_integer to _ _ Range1.
Subgoal 3.1.2:
Variables: I I1 Low High PlusOne Rest
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low <= High
Range1 : 1 + Low = PlusOne
Range2 : range PlusOne High Rest **
IsPlusOne : is_integer PlusOne
============================
exists X_T,
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> X_T /\ <is_clause {P}> X_T)
< IsCT: apply IH1 to _ _ Range2.
Subgoal 3.1.2:
Variables: I I1 Low High PlusOne Rest
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low <= High
Range1 : 1 + Low = PlusOne
Range2 : range PlusOne High Rest **
IsPlusOne : is_integer PlusOne
IsCT : <is_clause {P}> (rangeClause PlusOne High)
============================
exists X_T,
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> X_T /\ <is_clause {P}> X_T)
< Tr: assert |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High).
Subgoal 3.1.2:
Variables: I I1 Low High PlusOne Rest
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
IH1 : forall Low High R,
is_integer Low -> is_integer High -> range Low High R ** -> <is_clause {P}> (rangeClause Low High)
IsLow : is_integer Low
IsHigh : is_integer High
Range : Low <= High
Range1 : 1 + Low = PlusOne
Range2 : range PlusOne High Rest **
IsPlusOne : is_integer PlusOne
IsCT : <is_clause {P}> (rangeClause PlusOne High)
Tr : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
============================
exists X_T,
(is_integer Low /\ is_integer High) /\
(|{clause}- rangeClause Low High ~~> X_T /\ <is_clause {P}> X_T)
< search.
Subgoal 3:
Variables: I I1
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
Helper : forall Low High R,
is_integer Low -> is_integer High -> range Low High R -> <is_clause {P}> (rangeClause Low High)
============================
<is_clause {P}> (rangeClause I1 I)
< Range: apply range_exists to R1 R2.
Subgoal 3:
Variables: I I1 R
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
Helper : forall Low High R,
is_integer Low -> is_integer High -> range Low High R -> <is_clause {P}> (rangeClause Low High)
Range : range I1 I R
============================
<is_clause {P}> (rangeClause I1 I)
< apply Helper to _ _ Range.
Subgoal 3:
Variables: I I1 R
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (rangeClause I1 I) @
R1 : is_integer I1
R2 : is_integer I
Helper : forall Low High R,
is_integer Low -> is_integer High -> range Low High R -> <is_clause {P}> (rangeClause Low High)
Range : range I1 I R
H1 : <is_clause {P}> (rangeClause I1 I)
============================
<is_clause {P}> (rangeClause I1 I)
< search.
Subgoal 4:
Variables: Clause S
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (noteClause S Clause) @
R1 : is_string S
R2 : is_clause Clause *
============================
<is_clause {P}> (noteClause S Clause)
< assert |{clause}- noteClause S Clause ~~> Clause.
Subgoal 4:
Variables: Clause S
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (noteClause S Clause) @
R1 : is_string S
R2 : is_clause Clause *
H1 : |{clause}- noteClause S Clause ~~> Clause
============================
<is_clause {P}> (noteClause S Clause)
< apply IH to R2.
Subgoal 4:
Variables: Clause S
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (noteClause S Clause) @
R1 : is_string S
R2 : is_clause Clause *
H1 : |{clause}- noteClause S Clause ~~> Clause
H2 : <is_clause {P}> Clause
============================
<is_clause {P}> (noteClause S Clause)
< search.
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:is_formula.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:is_formula.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.
< Prove unsat_proofs:lrat:is_lit_pos_or_neg.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_empty_or_not.
Subgoal 3:
Variables: I I1
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
============================
emptyClause = rangeClause I1 I \/ (emptyClause = rangeClause I1 I -> false)
< search.
Subgoal 4:
Variables: Clause S
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
============================
emptyClause = noteClause S Clause \/
(emptyClause = noteClause S Clause -> false)
< search.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_or_or_not.
Subgoal 3:
Variables: I I1
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
============================
(exists L R, or L R = rangeClause I1 I) \/
((exists L R, or L R = rangeClause I1 I) -> false)
< search.
Subgoal 4:
Variables: Clause S
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
============================
(exists L R, or L R = noteClause S Clause) \/
((exists L R, or L R = noteClause S Clause) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_clause_rangeClause_or_not : forall C,
IsC : is_clause C ->
(exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
on IsC.
Subgoal 1:
IH : forall C,
is_clause C * -> (exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
IsC : is_clause emptyClause @
============================
(exists Low High, emptyClause = rangeClause Low High) \/
((exists Low High, emptyClause = rangeClause Low High) -> false)
< search.
Subgoal 2:
Variables: Clause Lit
IH : forall C,
is_clause C * -> (exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
(exists Low High, or Lit Clause = rangeClause Low High) \/
((exists Low High, or Lit Clause = rangeClause Low High) -> false)
< search.
Subgoal 3:
Variables: I I1
IH : forall C,
is_clause C * -> (exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
============================
(exists Low High, rangeClause I1 I = rangeClause Low High) \/
((exists Low High, rangeClause I1 I = rangeClause Low High) -> false)
< search.
Subgoal 4:
Variables: Clause S
IH : forall C,
is_clause C * -> (exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
============================
(exists Low High, noteClause S Clause = rangeClause Low High) \/
((exists Low High, noteClause S Clause = rangeClause Low High) -> false)
< search.
Subgoal 5:
Variables: X_T
IH : forall C,
is_clause C * -> (exists Low High, C = rangeClause Low High) \/
((exists Low High, C = rangeClause Low High) -> false)
IsC : is_clause <unknown K is_clause> @
IsC1 : |{clause}- <unknown K is_clause> ~~> X_T
IsC2 : is_clause X_T *
============================
(exists Low High, <unknown K is_clause> = rangeClause Low High) \/
((exists Low High, <unknown K is_clause> = rangeClause Low High) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_clause_noteClause_or_not : forall C,
IsC : is_clause C ->
(exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
on IsC.
Subgoal 1:
IH : forall C,
is_clause C * -> (exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
IsC : is_clause emptyClause @
============================
(exists Note C', emptyClause = noteClause Note C') \/
((exists Note C', emptyClause = noteClause Note C') -> false)
< search.
Subgoal 2:
Variables: Clause Lit
IH : forall C,
is_clause C * -> (exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
(exists Note C', or Lit Clause = noteClause Note C') \/
((exists Note C', or Lit Clause = noteClause Note C') -> false)
< search.
Subgoal 3:
Variables: I I1
IH : forall C,
is_clause C * -> (exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
============================
(exists Note C', rangeClause I1 I = noteClause Note C') \/
((exists Note C', rangeClause I1 I = noteClause Note C') -> false)
< search.
Subgoal 4:
Variables: Clause S
IH : forall C,
is_clause C * -> (exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
============================
(exists Note C', noteClause S Clause = noteClause Note C') \/
((exists Note C', noteClause S Clause = noteClause Note C') -> false)
< search.
Subgoal 5:
Variables: X_T
IH : forall C,
is_clause C * -> (exists Note C', C = noteClause Note C') \/
((exists Note C', C = noteClause Note C') -> false)
IsC : is_clause <unknown K is_clause> @
IsC1 : |{clause}- <unknown K is_clause> ~~> X_T
IsC2 : is_clause X_T *
============================
(exists Note C', <unknown K is_clause> = noteClause Note C') \/
((exists Note C', <unknown K is_clause> = noteClause Note C') -> false)
< search.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_eq_or_not.
Subgoal 3:
Variables: C2 I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause C2
IsC3 : is_integer I1
IsC4 : is_integer I
============================
rangeClause I1 I = C2 \/ (rangeClause I1 I = C2 -> false)
< Or: apply is_clause_rangeClause_or_not to IsC2.
Subgoal 3:
Variables: C2 I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause C2
IsC3 : is_integer I1
IsC4 : is_integer I
Or : (exists Low High, C2 = rangeClause Low High) \/
((exists Low High, C2 = rangeClause Low High) -> false)
============================
rangeClause I1 I = C2 \/ (rangeClause I1 I = C2 -> false)
< N: case Or.
Subgoal 3.1:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause (rangeClause Low High)
IsC3 : is_integer I1
IsC4 : is_integer I
============================
rangeClause I1 I = rangeClause Low High \/
(rangeClause I1 I = rangeClause Low High -> false)
< Is': case IsC2.
Subgoal 3.1:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC3 : is_integer I1
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
============================
rangeClause I1 I = rangeClause Low High \/
(rangeClause I1 I = rangeClause Low High -> false)
< Or: apply is_integer_eq_or_not to IsC3 Is'.
Subgoal 3.1:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC3 : is_integer I1
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
Or : I1 = Low \/ (I1 = Low -> false)
============================
rangeClause I1 I = rangeClause Low High \/
(rangeClause I1 I = rangeClause Low High -> false)
< N: case Or.
Subgoal 3.1.1:
Variables: I Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low I) @
IsC3 : is_integer Low
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
============================
rangeClause Low I = rangeClause Low High \/
(rangeClause Low I = rangeClause Low High -> false)
< Or: apply is_integer_eq_or_not to IsC4 Is'1.
Subgoal 3.1.1:
Variables: I Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low I) @
IsC3 : is_integer Low
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
Or : I = High \/ (I = High -> false)
============================
rangeClause Low I = rangeClause Low High \/
(rangeClause Low I = rangeClause Low High -> false)
< N: case Or.
Subgoal 3.1.1.1:
Variables: Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low High) @
IsC3 : is_integer Low
IsC4 : is_integer High
Is' : is_integer Low
Is'1 : is_integer High
============================
rangeClause Low High = rangeClause Low High \/
(rangeClause Low High = rangeClause Low High -> false)
< search.
Subgoal 3.1.1.2:
Variables: I Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low I) @
IsC3 : is_integer Low
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I = High -> false
============================
rangeClause Low I = rangeClause Low High \/
(rangeClause Low I = rangeClause Low High -> false)
< right.
Subgoal 3.1.1.2:
Variables: I Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low I) @
IsC3 : is_integer Low
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I = High -> false
============================
rangeClause Low I = rangeClause Low High -> false
< intros E.
Subgoal 3.1.1.2:
Variables: I Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low I) @
IsC3 : is_integer Low
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I = High -> false
E : rangeClause Low I = rangeClause Low High
============================
false
< case E.
Subgoal 3.1.1.2:
Variables: Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low High) @
IsC3 : is_integer Low
IsC4 : is_integer High
Is' : is_integer Low
Is'1 : is_integer High
N : High = High -> false
============================
false
< backchain N.
Subgoal 3.1.2:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC3 : is_integer I1
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I1 = Low -> false
============================
rangeClause I1 I = rangeClause Low High \/
(rangeClause I1 I = rangeClause Low High -> false)
< right.
Subgoal 3.1.2:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC3 : is_integer I1
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I1 = Low -> false
============================
rangeClause I1 I = rangeClause Low High -> false
< intros E.
Subgoal 3.1.2:
Variables: I I1 Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC3 : is_integer I1
IsC4 : is_integer I
Is' : is_integer Low
Is'1 : is_integer High
N : I1 = Low -> false
E : rangeClause I1 I = rangeClause Low High
============================
false
< case E.
Subgoal 3.1.2:
Variables: Low High
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause Low High) @
IsC3 : is_integer Low
IsC4 : is_integer High
Is' : is_integer Low
Is'1 : is_integer High
N : Low = Low -> false
============================
false
< backchain N.
Subgoal 3.2:
Variables: C2 I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause C2
IsC3 : is_integer I1
IsC4 : is_integer I
N : (exists Low High, C2 = rangeClause Low High) -> false
============================
rangeClause I1 I = C2 \/ (rangeClause I1 I = C2 -> false)
< right.
Subgoal 3.2:
Variables: C2 I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause C2
IsC3 : is_integer I1
IsC4 : is_integer I
N : (exists Low High, C2 = rangeClause Low High) -> false
============================
rangeClause I1 I = C2 -> false
< intros E.
Subgoal 3.2:
Variables: C2 I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause C2
IsC3 : is_integer I1
IsC4 : is_integer I
N : (exists Low High, C2 = rangeClause Low High) -> false
E : rangeClause I1 I = C2
============================
false
< case E.
Subgoal 3.2:
Variables: I I1
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (rangeClause I1 I) @
IsC2 : is_clause (rangeClause I1 I)
IsC3 : is_integer I1
IsC4 : is_integer I
N : (exists Low High, rangeClause I1 I = rangeClause Low High) -> false
============================
false
< backchain N.
Subgoal 4:
Variables: C2 Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause C2
IsC3 : is_string S
IsC4 : is_clause Clause *
============================
noteClause S Clause = C2 \/ (noteClause S Clause = C2 -> false)
< Or: apply is_clause_noteClause_or_not to IsC2.
Subgoal 4:
Variables: C2 Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause C2
IsC3 : is_string S
IsC4 : is_clause Clause *
Or : (exists Note C', C2 = noteClause Note C') \/
((exists Note C', C2 = noteClause Note C') -> false)
============================
noteClause S Clause = C2 \/ (noteClause S Clause = C2 -> false)
< N: case Or.
Subgoal 4.1:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause (noteClause Note C')
IsC3 : is_string S
IsC4 : is_clause Clause *
============================
noteClause S Clause = noteClause Note C' \/
(noteClause S Clause = noteClause Note C' -> false)
< Is': case IsC2.
Subgoal 4.1:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC3 : is_string S
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
============================
noteClause S Clause = noteClause Note C' \/
(noteClause S Clause = noteClause Note C' -> false)
< Or: apply is_string_eq_or_not to IsC3 Is'.
Subgoal 4.1:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC3 : is_string S
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
Or : S = Note \/ (S = Note -> false)
============================
noteClause S Clause = noteClause Note C' \/
(noteClause S Clause = noteClause Note C' -> false)
< N: case Or.
Subgoal 4.1.1:
Variables: Clause Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note Clause) @
IsC3 : is_string Note
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
============================
noteClause Note Clause = noteClause Note C' \/
(noteClause Note Clause = noteClause Note C' -> false)
< Or: apply IH to IsC4 Is'1.
Subgoal 4.1.1:
Variables: Clause Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note Clause) @
IsC3 : is_string Note
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
Or : Clause = C' \/ (Clause = C' -> false)
============================
noteClause Note Clause = noteClause Note C' \/
(noteClause Note Clause = noteClause Note C' -> false)
< N: case Or.
Subgoal 4.1.1.1:
Variables: Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note C') @
IsC3 : is_string Note
IsC4 : is_clause C' *
Is' : is_string Note
Is'1 : is_clause C'
============================
noteClause Note C' = noteClause Note C' \/
(noteClause Note C' = noteClause Note C' -> false)
< search.
Subgoal 4.1.1.2:
Variables: Clause Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note Clause) @
IsC3 : is_string Note
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : Clause = C' -> false
============================
noteClause Note Clause = noteClause Note C' \/
(noteClause Note Clause = noteClause Note C' -> false)
< right.
Subgoal 4.1.1.2:
Variables: Clause Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note Clause) @
IsC3 : is_string Note
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : Clause = C' -> false
============================
noteClause Note Clause = noteClause Note C' -> false
< intros E.
Subgoal 4.1.1.2:
Variables: Clause Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note Clause) @
IsC3 : is_string Note
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : Clause = C' -> false
E : noteClause Note Clause = noteClause Note C'
============================
false
< case E.
Subgoal 4.1.1.2:
Variables: Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note C') @
IsC3 : is_string Note
IsC4 : is_clause C' *
Is' : is_string Note
Is'1 : is_clause C'
N : C' = C' -> false
============================
false
< backchain N.
Subgoal 4.1.2:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC3 : is_string S
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : S = Note -> false
============================
noteClause S Clause = noteClause Note C' \/
(noteClause S Clause = noteClause Note C' -> false)
< right.
Subgoal 4.1.2:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC3 : is_string S
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : S = Note -> false
============================
noteClause S Clause = noteClause Note C' -> false
< intros E.
Subgoal 4.1.2:
Variables: Clause S Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC3 : is_string S
IsC4 : is_clause Clause *
Is' : is_string Note
Is'1 : is_clause C'
N : S = Note -> false
E : noteClause S Clause = noteClause Note C'
============================
false
< case E.
Subgoal 4.1.2:
Variables: Note C'
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause Note C') @
IsC3 : is_string Note
IsC4 : is_clause C' *
Is' : is_string Note
Is'1 : is_clause C'
N : Note = Note -> false
============================
false
< backchain N.
Subgoal 4.2:
Variables: C2 Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause C2
IsC3 : is_string S
IsC4 : is_clause Clause *
N : (exists Note C', C2 = noteClause Note C') -> false
============================
noteClause S Clause = C2 \/ (noteClause S Clause = C2 -> false)
< right.
Subgoal 4.2:
Variables: C2 Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause C2
IsC3 : is_string S
IsC4 : is_clause Clause *
N : (exists Note C', C2 = noteClause Note C') -> false
============================
noteClause S Clause = C2 -> false
< intros E.
Subgoal 4.2:
Variables: C2 Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause C2
IsC3 : is_string S
IsC4 : is_clause Clause *
N : (exists Note C', C2 = noteClause Note C') -> false
E : noteClause S Clause = C2
============================
false
< case E.
Subgoal 4.2:
Variables: Clause S
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (noteClause S Clause) @
IsC2 : is_clause (noteClause S Clause)
IsC3 : is_string S
IsC4 : is_clause Clause *
N : (exists Note C', noteClause S Clause = noteClause Note C') -> false
============================
false
< backchain N.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_empty_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_and_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_eq_or_not.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_unique.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_reverse.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_not_same.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_is_lit.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_is_lit_back.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_exists.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_clause_ext_to_proj.
Subgoal 1:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : sat_clause Sat (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< Sat: case Hyp3.
Subgoal 1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< Or: apply lesseq_integer_less_or_eq to Sat.
Subgoal 1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
Or : Low < X \/ Low = X
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< L: case Or.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< Is: case Hyp2.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< P: apply plus_integer_comm to _ _ Hyp5.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< IsPosX: apply mem_is_lit to _ Sat2.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
IsPosX : is_lit (pos X)
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< case IsPosX.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
H1 : is_integer X
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< apply less_lesseq_plus_one to _ _ L P.
Subgoal 1.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
H1 : is_integer X
H2 : PlusOne <= X
============================
sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
< search.
Subgoal 1.2:
Variables: Sat High PlusOne X
Hyp : |{clause}- rangeClause X High ~~> or (pos X) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause X High)
Hyp4 : X <= High
Hyp5 : 1 + X = PlusOne
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
============================
sat_clause Sat (or (pos X) (rangeClause PlusOne High))
< search.
Subgoal 2:
Variables: Sat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : sat_clause Sat (rangeClause Low High)
Hyp4 : Low > High
============================
sat_clause Sat emptyClause
< Sat: case Hyp3.
Subgoal 2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low > High
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
============================
sat_clause Sat emptyClause
< Or: apply lesseq_integer_less_or_eq to Sat.
Subgoal 2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low > High
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
Or : Low < X \/ Low = X
============================
sat_clause Sat emptyClause
< L: case Or.
Subgoal 2.1:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low > High
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
============================
sat_clause Sat emptyClause
< HL: apply greater_integer_flip_less to Hyp4.
Subgoal 2.1:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low > High
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
HL : High < Low
============================
sat_clause Sat emptyClause
< HX: apply less_integer_transitive to HL L.
Subgoal 2.1:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low > High
Sat : Low <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
L : Low < X
HL : High < Low
HX : High < X
============================
sat_clause Sat emptyClause
< apply greater_lesseq_integer_false to _ Sat1.
Subgoal 2.2:
Variables: Sat High X
Hyp : |{clause}- rangeClause X High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause X High)
Hyp4 : X > High
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
============================
sat_clause Sat emptyClause
< apply greater_lesseq_integer_false to Hyp4 Sat1.
Subgoal 3:
Variables: C' Sat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (noteClause Note C')
Hyp3 : sat_clause Sat (noteClause Note C')
============================
sat_clause Sat C'
< case Hyp3.
Subgoal 3:
Variables: C' Sat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (noteClause Note C')
H1 : sat_clause Sat C'
============================
sat_clause Sat C'
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_clause_proj_to_ext.
Subgoal 1:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : sat_clause Sat (or (pos Low) (rangeClause PlusOne High))
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
============================
sat_clause Sat (rangeClause Low High)
< Sat: case Hyp3.
Subgoal 1.1:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : mem (pos Low) Sat
============================
sat_clause Sat (rangeClause Low High)
< Is: case Hyp2.
Subgoal 1.1:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : mem (pos Low) Sat
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause Sat (rangeClause Low High)
< apply is_integer_lesseq to Is.
Subgoal 1.1:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : mem (pos Low) Sat
Is : is_integer Low
Is1 : is_integer High
H1 : Low <= Low
============================
sat_clause Sat (rangeClause Low High)
< search.
Subgoal 1.2:
Variables: Sat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : sat_clause Sat (rangeClause PlusOne High)
============================
sat_clause Sat (rangeClause Low High)
< Sat: case Sat.
Subgoal 1.2:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
============================
sat_clause Sat (rangeClause Low High)
< IsPosX: apply mem_is_lit to _ Sat2.
Subgoal 1.2:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsPosX : is_lit (pos X)
============================
sat_clause Sat (rangeClause Low High)
< IsX: case IsPosX.
Subgoal 1.2:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
============================
sat_clause Sat (rangeClause Low High)
< Or: apply lesseq_integer_less_or_eq to Sat.
Subgoal 1.2:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
Or : PlusOne < X \/ PlusOne = X
============================
sat_clause Sat (rangeClause Low High)
< L: case Or.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
============================
sat_clause Sat (rangeClause Low High)
< Is: case Hyp2.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause Sat (rangeClause Low High)
< P: apply plus_integer_comm to _ _ Hyp5.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
============================
sat_clause Sat (rangeClause Low High)
< L: apply lt_plus_one to Hyp5 _.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
L1 : Low < PlusOne
============================
sat_clause Sat (rangeClause Low High)
< LE: apply less_integer_lesseq to L1.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
L1 : Low < PlusOne
LE : Low <= PlusOne
============================
sat_clause Sat (rangeClause Low High)
< apply lesseq_integer_transitive to LE Sat.
Subgoal 1.2.1:
Variables: Sat High PlusOne Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Sat : PlusOne <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
L : PlusOne < X
Is : is_integer Low
Is1 : is_integer High
P : Low + 1 = PlusOne
L1 : Low < PlusOne
LE : Low <= PlusOne
H1 : Low <= X
============================
sat_clause Sat (rangeClause Low High)
< search.
Subgoal 1.2.2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause X High)
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = X
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
============================
sat_clause Sat (rangeClause Low High)
< Is: case Hyp2.
Subgoal 1.2.2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause X High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = X
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause Sat (rangeClause Low High)
< L: apply lt_plus_one to Hyp5 _.
Subgoal 1.2.2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause X High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = X
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
Is : is_integer Low
Is1 : is_integer High
L : Low < X
============================
sat_clause Sat (rangeClause Low High)
< apply less_integer_lesseq to L.
Subgoal 1.2.2:
Variables: Sat High Low X
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause X High)
Hyp1 : is_list is_lit Sat
Hyp4 : Low <= High
Hyp5 : 1 + Low = X
Sat : X <= X
Sat1 : X <= High
Sat2 : mem (pos X) Sat
IsX : is_integer X
Is : is_integer Low
Is1 : is_integer High
L : Low < X
H1 : Low <= X
============================
sat_clause Sat (rangeClause Low High)
< search.
Subgoal 2:
Variables: Sat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : sat_clause Sat emptyClause
Hyp4 : Low > High
============================
sat_clause Sat (rangeClause Low High)
< case Hyp3.
Subgoal 3:
Variables: C' Sat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Sat
Hyp2 : is_clause (noteClause Note C')
Hyp3 : sat_clause Sat C'
============================
sat_clause Sat (noteClause Note C')
< search.
Proof completed.
< Theorem negs_total :
forall L, is_list is_integer L -> exists N, negs L N.
============================
forall L, is_list is_integer L -> exists N, negs L N
< induction on 1.
IH : forall L, is_list is_integer L * -> exists N, negs L N
============================
forall L, is_list is_integer L @ -> exists N, negs L N
< intros IsL.
Variables: L
IH : forall L, is_list is_integer L * -> exists N, negs L N
IsL : is_list is_integer L @
============================
exists N, negs L N
< IsL: case IsL.
Subgoal 1:
IH : forall L, is_list is_integer L * -> exists N, negs L N
============================
exists N, negs [] N
< search.
Subgoal 2:
Variables: T H
IH : forall L, is_list is_integer L * -> exists N, negs L N
IsL : is_integer H
IsL1 : is_list is_integer T *
============================
exists N, negs (H::T) N
< apply IH to IsL1.
Subgoal 2:
Variables: T H N
IH : forall L, is_list is_integer L * -> exists N, negs L N
IsL : is_integer H
IsL1 : is_list is_integer T *
H1 : negs T N
============================
exists N, negs (H::T) N
< search.
Proof completed.
< Theorem negs_mem :
forall L N X, mem X L -> negs L N -> mem (neg X) N.
============================
forall L N X, mem X L -> negs L N -> mem (neg X) N
< induction on 1.
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
============================
forall L N X, mem X L @ -> negs L N -> mem (neg X) N
< intros Mem Negs.
Variables: L N X
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
Mem : mem X L @
Negs : negs L N
============================
mem (neg X) N
< Mem: case Mem.
Subgoal 1:
Variables: N X Rest
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
Negs : negs (X::Rest) N
============================
mem (neg X) N
< case Negs.
Subgoal 1:
Variables: X Rest LRest
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
H1 : negs Rest LRest
============================
mem (neg X) ((neg X)::LRest)
< search.
Subgoal 2:
Variables: N X Rest I
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
Negs : negs (I::Rest) N
Mem : mem X Rest *
============================
mem (neg X) N
< Negs: case Negs.
Subgoal 2:
Variables: X Rest I LRest
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
Mem : mem X Rest *
Negs : negs Rest LRest
============================
mem (neg X) ((neg I)::LRest)
< apply IH to Mem Negs.
Subgoal 2:
Variables: X Rest I LRest
IH : forall L N X, mem X L * -> negs L N -> mem (neg X) N
Mem : mem X Rest *
Negs : negs Rest LRest
H1 : mem (neg X) LRest
============================
mem (neg X) ((neg I)::LRest)
< search.
Proof completed.
< Theorem negs_subset :
forall LA LB NA NB,
subset LA LB -> negs LA NA -> negs LB NB -> subset NA NB.
============================
forall LA LB NA NB, subset LA LB -> negs LA NA -> negs LB NB -> subset NA NB
< induction on 1.
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
============================
forall LA LB NA NB, subset LA LB @ -> negs LA NA -> negs LB NB -> subset NA NB
< intros S NA NB.
Variables: LA LB NA NB
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
S : subset LA LB @
NA : negs LA NA
NB : negs LB NB
============================
subset NA NB
< S: case S.
Subgoal 1:
Variables: LB NA NB
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NA : negs [] NA
NB : negs LB NB
============================
subset NA NB
< case NA.
Subgoal 1:
Variables: LB NB
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NB : negs LB NB
============================
subset [] NB
< search.
Subgoal 2:
Variables: LB NA NB Rest X
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NA : negs (X::Rest) NA
NB : negs LB NB
S : mem X LB
S1 : subset Rest LB *
============================
subset NA NB
< NA: case NA.
Subgoal 2:
Variables: LB NB Rest X LRest
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NB : negs LB NB
S : mem X LB
S1 : subset Rest LB *
NA : negs Rest LRest
============================
subset ((neg X)::LRest) NB
< apply IH to S1 NA NB.
Subgoal 2:
Variables: LB NB Rest X LRest
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NB : negs LB NB
S : mem X LB
S1 : subset Rest LB *
NA : negs Rest LRest
H1 : subset LRest NB
============================
subset ((neg X)::LRest) NB
< apply negs_mem to S NB.
Subgoal 2:
Variables: LB NB Rest X LRest
IH : forall LA LB NA NB,
subset LA LB * -> negs LA NA -> negs LB NB -> subset NA NB
NB : negs LB NB
S : mem X LB
S1 : subset Rest LB *
NA : negs Rest LRest
H1 : subset LRest NB
H2 : mem (neg X) NB
============================
subset ((neg X)::LRest) NB
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:unsat_clause_ext_to_proj.
Subgoal 1:
Variables: Unsat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< Is: case Hyp2.
Subgoal 1:
Variables: Unsat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp3 : unsat_clause Unsat (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< IsPlusOne: apply plus_integer_is_integer to _ _ Hyp5.
Subgoal 1:
Variables: Unsat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp3 : unsat_clause Unsat (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< Unsat: case Hyp3.
Subgoal 1:
Variables: Unsat High PlusOne Low R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< L: apply lt_plus_one to Hyp5 _.
Subgoal 1:
Variables: Unsat High PlusOne Low R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< R: apply range_smaller_exists to _ _ Unsat L.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< SRR': apply range_subset to _ _ Unsat R _.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< IsPlusOne: apply plus_integer_is_integer to _ _ Hyp5.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< IsR': apply range_is to _ R.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< N: apply negs_total to IsR'.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< S': apply negs_subset to SRR' N Unsat1.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< Mem: assert mem Low R.
Subgoal 1.1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
============================
mem Low R
< case Unsat.
Subgoal 1.1.1:
Variables: Unsat High PlusOne Low N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat1 : negs [] N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' []
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
H1 : Low > High
============================
mem Low []
< apply greater_lesseq_integer_false to _ Hyp4.
Subgoal 1.1.2:
Variables: Unsat High PlusOne Low N R' N1 PlusOne1 Rest
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat1 : negs (Low::Rest) N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' (Low::Rest)
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
H1 : Low <= High
H2 : 1 + Low = PlusOne1
H3 : range PlusOne1 High Rest
============================
mem Low (Low::Rest)
< search.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< MemN: apply negs_mem to Mem Unsat1.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
< unfold .
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
exists NL,
negate_lit (pos Low) NL /\
(mem NL Unsat /\ unsat_clause Unsat (rangeClause PlusOne High))
< exists neg Low.
Subgoal 1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
negate_lit (pos Low) (neg Low) /\
(mem (neg Low) Unsat /\ unsat_clause Unsat (rangeClause PlusOne High))
< split.
Subgoal 1.2:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
negate_lit (pos Low) (neg Low)
< search.
Subgoal 1.3:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
mem (neg Low) Unsat
< apply subset_mem to Unsat2 MemN.
Subgoal 1.3:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
H1 : mem (neg Low) Unsat
============================
mem (neg Low) Unsat
< search.
Subgoal 1.4:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
unsat_clause Unsat (rangeClause PlusOne High)
< unfold .
Subgoal 1.4:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
exists R N, range PlusOne High R /\ (negs R N /\ subset N Unsat)
< exists R',
N1.
Subgoal 1.4:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
range PlusOne High R' /\ (negs R' N1 /\ subset N1 Unsat)
< split.
Subgoal 1.4.1:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
range PlusOne High R'
< search.
Subgoal 1.4.2:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
negs R' N1
< search.
Subgoal 1.4.3:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
============================
subset N1 Unsat
< apply subset_trans to S' Unsat2.
Subgoal 1.4.3:
Variables: Unsat High PlusOne Low R N R' N1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Is : is_integer Low
Is1 : is_integer High
IsPlusOne : is_integer PlusOne
Unsat : range Low High R
Unsat1 : negs R N
Unsat2 : subset N Unsat
L : Low < PlusOne
R : range PlusOne High R'
SRR' : subset R' R
IsPlusOne1 : is_integer PlusOne
IsR' : is_list is_integer R'
N : negs R' N1
S' : subset N1 N
Mem : mem Low R
MemN : mem (neg Low) N
H1 : subset N1 Unsat
============================
subset N1 Unsat
< search.
Subgoal 2:
Variables: Unsat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat (rangeClause Low High)
Hyp4 : Low > High
============================
unsat_clause Unsat emptyClause
< search.
Subgoal 3:
Variables: C' Unsat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (noteClause Note C')
Hyp3 : unsat_clause Unsat (noteClause Note C')
============================
unsat_clause Unsat C'
< case Hyp3.
Subgoal 3:
Variables: C' Unsat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (noteClause Note C')
H1 : unsat_clause Unsat C'
============================
unsat_clause Unsat C'
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:unsat_clause_proj_to_ext.
Subgoal 1:
Variables: Unsat High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat (or (pos Low) (rangeClause PlusOne High))
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
============================
unsat_clause Unsat (rangeClause Low High)
< Unsat: case Hyp3.
Subgoal 1:
Variables: Unsat High PlusOne Low NL
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat : negate_lit (pos Low) NL
Unsat1 : mem NL Unsat
Unsat2 : unsat_clause Unsat (rangeClause PlusOne High)
============================
unsat_clause Unsat (rangeClause Low High)
< Is: case Hyp2.
Subgoal 1:
Variables: Unsat High PlusOne Low NL
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat : negate_lit (pos Low) NL
Unsat1 : mem NL Unsat
Unsat2 : unsat_clause Unsat (rangeClause PlusOne High)
Is : is_integer Low
Is1 : is_integer High
============================
unsat_clause Unsat (rangeClause Low High)
< US: case Unsat2.
Subgoal 1:
Variables: Unsat High PlusOne Low NL R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat : negate_lit (pos Low) NL
Unsat1 : mem NL Unsat
Is : is_integer Low
Is1 : is_integer High
US : range PlusOne High R
US1 : negs R N
US2 : subset N Unsat
============================
unsat_clause Unsat (rangeClause Low High)
< R: assert range Low High (Low::R).
Subgoal 1:
Variables: Unsat High PlusOne Low NL R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat : negate_lit (pos Low) NL
Unsat1 : mem NL Unsat
Is : is_integer Low
Is1 : is_integer High
US : range PlusOne High R
US1 : negs R N
US2 : subset N Unsat
R : range Low High (Low::R)
============================
unsat_clause Unsat (rangeClause Low High)
< N: assert negs (Low::R) ((neg Low)::N).
Subgoal 1:
Variables: Unsat High PlusOne Low NL R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat : negate_lit (pos Low) NL
Unsat1 : mem NL Unsat
Is : is_integer Low
Is1 : is_integer High
US : range PlusOne High R
US1 : negs R N
US2 : subset N Unsat
R : range Low High (Low::R)
N : negs (Low::R) ((neg Low)::N)
============================
unsat_clause Unsat (rangeClause Low High)
< case Unsat.
Subgoal 1:
Variables: Unsat High PlusOne Low R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat1 : mem (neg Low) Unsat
Is : is_integer Low
Is1 : is_integer High
US : range PlusOne High R
US1 : negs R N
US2 : subset N Unsat
R : range Low High (Low::R)
N : negs (Low::R) ((neg Low)::N)
============================
unsat_clause Unsat (rangeClause Low High)
< assert subset ((neg Low)::N) Unsat.
Subgoal 1:
Variables: Unsat High PlusOne Low R N
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_list is_lit Unsat
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
Unsat1 : mem (neg Low) Unsat
Is : is_integer Low
Is1 : is_integer High
US : range PlusOne High R
US1 : negs R N
US2 : subset N Unsat
R : range Low High (Low::R)
N : negs (Low::R) ((neg Low)::N)
H1 : subset ((neg Low)::N) Unsat
============================
unsat_clause Unsat (rangeClause Low High)
< search.
Subgoal 2:
Variables: Unsat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat emptyClause
Hyp4 : Low > High
============================
unsat_clause Unsat (rangeClause Low High)
< R: assert range Low High [].
Subgoal 2:
Variables: Unsat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat emptyClause
Hyp4 : Low > High
R : range Low High []
============================
unsat_clause Unsat (rangeClause Low High)
< assert negs [] [].
Subgoal 2:
Variables: Unsat High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (rangeClause Low High)
Hyp3 : unsat_clause Unsat emptyClause
Hyp4 : Low > High
R : range Low High []
H1 : negs [] []
============================
unsat_clause Unsat (rangeClause Low High)
< search.
Subgoal 3:
Variables: C' Unsat Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_list is_lit Unsat
Hyp2 : is_clause (noteClause Note C')
Hyp3 : unsat_clause Unsat C'
============================
unsat_clause Unsat (noteClause Note C')
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_formula_ext_to_proj.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_formula_proj_to_ext.
Proof completed.
< Theorem negs_form :
forall L N X, negs L N -> mem X N -> exists I, X = neg I.
============================
forall L N X, negs L N -> mem X N -> exists I, X = neg I
< induction on 2.
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
============================
forall L N X, negs L N -> mem X N @ -> exists I, X = neg I
< intros N M.
Variables: L N X
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
N : negs L N
M : mem X N @
============================
exists I, X = neg I
< M: case M.
Subgoal 1:
Variables: L X Rest
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
N : negs L (X::Rest)
============================
exists I, X = neg I
< case N.
Subgoal 1:
Variables: Rest I Rest1
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
H1 : negs Rest1 Rest
============================
exists I1, neg I = neg I1
< search.
Subgoal 2:
Variables: L X Rest I
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
N : negs L (I::Rest)
M : mem X Rest *
============================
exists I, X = neg I
< N: case N.
Subgoal 2:
Variables: X Rest I1 Rest1
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
M : mem X Rest *
N : negs Rest1 Rest
============================
exists I, X = neg I
< apply IH to _ M.
Subgoal 2:
Variables: Rest I1 Rest1 I2
IH : forall L N X, negs L N -> mem X N * -> exists I, X = neg I
M : mem (neg I2) Rest *
N : negs Rest1 Rest
============================
exists I, neg I2 = neg I
< search.
Proof completed.
< Prove unsat_proofs:lrat:unsat_sat_clause.
Subgoal 3:
Variables: A R N High Low
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
SAT : sat_clause A (rangeClause Low High)
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
============================
false
< SAT: case SAT.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
============================
false
< Is: case IsC.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
============================
false
< IsR: apply range_is to _ UNSAT1.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
============================
false
< IsX: apply between_integers_is_integer to _ _ SAT SAT1.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
IsX : is_integer X
============================
false
< M: apply in_range to _ _ UNSAT1 SAT SAT1.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
IsX : is_integer X
M : mem X R
============================
false
< M': apply negs_mem to M UNSAT2.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
IsX : is_integer X
M : mem X R
M' : mem (neg X) N
============================
false
< M3: apply subset_mem to UNSAT3 M'.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
GA : good_assignment A
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
IsX : is_integer X
M : mem X R
M' : mem (neg X) N
M3 : mem (neg X) A
============================
false
< GA: case GA.
Subgoal 3:
Variables: A R N High Low X
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (rangeClause Low High) @
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) A
Is : is_integer Low
Is1 : is_integer High
IsR : is_list is_integer R
IsX : is_integer X
M : mem X R
M' : mem (neg X) N
M3 : mem (neg X) A
GA : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
============================
false
< apply GA to SAT2 _ M3.
Subgoal 4:
Variables: A Clause Note
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
UNSAT : unsat_clause A (noteClause Note Clause) @
SAT : sat_clause A (noteClause Note Clause)
GA : good_assignment A
UNSAT1 : unsat_clause A Clause *
============================
false
< SAT: case SAT.
Subgoal 4:
Variables: A Clause Note
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
UNSAT : unsat_clause A (noteClause Note Clause) @
GA : good_assignment A
UNSAT1 : unsat_clause A Clause *
SAT : sat_clause A Clause
============================
false
< case IsC.
Subgoal 4:
Variables: A Clause Note
IH : forall A C,
is_clause C -> is_list is_lit A -> unsat_clause A C * -> sat_clause A C ->
good_assignment A -> false
IsA : is_list is_lit A
UNSAT : unsat_clause A (noteClause Note Clause) @
GA : good_assignment A
UNSAT1 : unsat_clause A Clause *
SAT : sat_clause A Clause
H1 : is_string Note
H2 : is_clause Clause
============================
false
< apply IH to _ _ UNSAT1 SAT GA.
Proof completed.
< Prove unsat_proofs:lrat:sat_clause_orderless.
Subgoal 3:
Variables: A1 A2 X High Low
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> sat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> sat_clause A2 C
IsC : is_clause (rangeClause Low High)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (rangeClause Low High) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : Low <= X
SAT2 : X <= High
SAT3 : mem (pos X) A1
============================
sat_clause A2 (rangeClause Low High)
< apply MemA1A2 to SAT3.
Subgoal 3:
Variables: A1 A2 X High Low
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> sat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> sat_clause A2 C
IsC : is_clause (rangeClause Low High)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (rangeClause Low High) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : Low <= X
SAT2 : X <= High
SAT3 : mem (pos X) A1
H1 : mem (pos X) A2
============================
sat_clause A2 (rangeClause Low High)
< search.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> sat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> sat_clause A2 C
IsC : is_clause (noteClause Note Clause)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Clause *
============================
sat_clause A2 (noteClause Note Clause)
< case IsC.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> sat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> sat_clause A2 C
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Clause *
H1 : is_string Note
H2 : is_clause Clause
============================
sat_clause A2 (noteClause Note Clause)
< apply IH to _ _ _ SAT1 MemA1A2.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> sat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> sat_clause A2 C
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Clause *
H1 : is_string Note
H2 : is_clause Clause
H3 : sat_clause A2 Clause
============================
sat_clause A2 (noteClause Note Clause)
< search.
Proof completed.
< Prove unsat_proofs:lrat:sat_formula_orderless.
Proof completed.
< Theorem mems_subset :
forall Sub Sup,
is_list is_lit Sub -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup.
============================
forall Sub Sup,
is_list is_lit Sub -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
< induction on 1.
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
============================
forall Sub Sup,
is_list is_lit Sub @ -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
< intros Is Mems.
Variables: Sub Sup
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Is : is_list is_lit Sub @
Mems : forall X, mem X Sub -> mem X Sup
============================
subset Sub Sup
< Is: case Is.
Subgoal 1:
Variables: Sup
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X [] -> mem X Sup
============================
subset [] Sup
< search.
Subgoal 2:
Variables: Sup T H
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
============================
subset (H::T) Sup
< Mems': assert forall X,
mem X T -> mem X Sup.
Subgoal 2.1:
Variables: Sup T H
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
============================
forall X, mem X T -> mem X Sup
< intros M.
Subgoal 2.1:
Variables: Sup T H X
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
M : mem X T
============================
mem X Sup
< apply Mems to _ with
X = X.
Subgoal 2.1:
Variables: Sup T H X
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
M : mem X T
H1 : mem X Sup
============================
mem X Sup
< search.
Subgoal 2:
Variables: Sup T H
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
Mems' : forall X, mem X T -> mem X Sup
============================
subset (H::T) Sup
< M: apply Mems to _ with
X = H.
Subgoal 2:
Variables: Sup T H
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
Mems' : forall X, mem X T -> mem X Sup
M : mem H Sup
============================
subset (H::T) Sup
< apply IH to Is1 Mems'.
Subgoal 2:
Variables: Sup T H
IH : forall Sub Sup,
is_list is_lit Sub * -> (forall X, mem X Sub -> mem X Sup) -> subset Sub Sup
Mems : forall X, mem X (H::T) -> mem X Sup
Is : is_lit H
Is1 : is_list is_lit T *
Mems' : forall X, mem X T -> mem X Sup
M : mem H Sup
H1 : subset T Sup
============================
subset (H::T) Sup
< search.
Proof completed.
< Theorem mems_subset2 [A] :
forall (Sup1 : list A) (Sup2 : list A) (Sub : list A),
subset Sub Sup1 -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2.
============================
forall Sup1 Sup2 Sub,
subset Sub Sup1 -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
< induction on 1.
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
============================
forall Sup1 Sup2 Sub,
subset Sub Sup1 @ -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
< intros S Mems.
Variables: Sup1 Sup2 Sub
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
S : subset Sub Sup1 @
Mems : forall X, mem X Sup1 -> mem X Sup2
============================
subset Sub Sup2
< S: case S.
Subgoal 1:
Variables: Sup1 Sup2
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
Mems : forall X, mem X Sup1 -> mem X Sup2
============================
subset [] Sup2
< search.
Subgoal 2:
Variables: Sup1 Sup2 Rest X
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
Mems : forall X, mem X Sup1 -> mem X Sup2
S : mem X Sup1
S1 : subset Rest Sup1 *
============================
subset (X::Rest) Sup2
< apply Mems to S.
Subgoal 2:
Variables: Sup1 Sup2 Rest X
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
Mems : forall X, mem X Sup1 -> mem X Sup2
S : mem X Sup1
S1 : subset Rest Sup1 *
H1 : mem X Sup2
============================
subset (X::Rest) Sup2
< apply IH to S1 _.
Subgoal 2:
Variables: Sup1 Sup2 Rest X
IH : forall Sup1 Sup2 Sub,
subset Sub Sup1 * -> (forall X, mem X Sup1 -> mem X Sup2) -> subset Sub Sup2
Mems : forall X, mem X Sup1 -> mem X Sup2
S : mem X Sup1
S1 : subset Rest Sup1 *
H1 : mem X Sup2
H2 : subset Rest Sup2
============================
subset (X::Rest) Sup2
< search.
Proof completed.
< Prove unsat_proofs:lrat:unsat_clause_orderless.
Subgoal 3:
Variables: A1 A2 R N High Low
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> unsat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> unsat_clause A2 C
IsC : is_clause (rangeClause Low High)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (rangeClause Low High) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A1
============================
unsat_clause A2 (rangeClause Low High)
< apply mems_subset2 to UNSAT3 MemA1A2.
Subgoal 3:
Variables: A1 A2 R N High Low
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> unsat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> unsat_clause A2 C
IsC : is_clause (rangeClause Low High)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (rangeClause Low High) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : range Low High R
UNSAT2 : negs R N
UNSAT3 : subset N A1
H1 : subset N A2
============================
unsat_clause A2 (rangeClause Low High)
< search.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> unsat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> unsat_clause A2 C
IsC : is_clause (noteClause Note Clause)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : unsat_clause A1 Clause *
============================
unsat_clause A2 (noteClause Note Clause)
< Is: case IsC.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> unsat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> unsat_clause A2 C
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : unsat_clause A1 Clause *
Is : is_string Note
Is1 : is_clause Clause
============================
unsat_clause A2 (noteClause Note Clause)
< apply IH to _ _ _ UNSAT1 MemA1A2.
Subgoal 4:
Variables: A1 A2 Clause Note
IH : forall A1 A2 C,
is_clause C -> is_list is_lit A1 -> is_list is_lit A2 -> unsat_clause A1 C * ->
(forall L, mem L A1 -> mem L A2) -> unsat_clause A2 C
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (noteClause Note Clause) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : unsat_clause A1 Clause *
Is : is_string Note
Is1 : is_clause Clause
H1 : unsat_clause A2 Clause
============================
unsat_clause A2 (noteClause Note Clause)
< search.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_is.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
Unit : unit_clause A (rangeClause Low High) (pos I) @
Unit1 : range Low High Range
Unit2 : select I RangeRest Range
Unit3 : mem (pos I) A -> false
Unit4 : mem (neg I) A -> false
Unit5 : negs RangeRest N
Unit6 : subset N A
============================
is_lit (pos I)
< Is: case IsC.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (rangeClause Low High) (pos I) @
Unit1 : range Low High Range
Unit2 : select I RangeRest Range
Unit3 : mem (pos I) A -> false
Unit4 : mem (neg I) A -> false
Unit5 : negs RangeRest N
Unit6 : subset N A
Is : is_integer Low
Is1 : is_integer High
============================
is_lit (pos I)
< IsRange: apply range_is to _ Unit1.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (rangeClause Low High) (pos I) @
Unit1 : range Low High Range
Unit2 : select I RangeRest Range
Unit3 : mem (pos I) A -> false
Unit4 : mem (neg I) A -> false
Unit5 : negs RangeRest N
Unit6 : subset N A
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
============================
is_lit (pos I)
< Mem: apply select_mem to Unit2.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (rangeClause Low High) (pos I) @
Unit1 : range Low High Range
Unit2 : select I RangeRest Range
Unit3 : mem (pos I) A -> false
Unit4 : mem (neg I) A -> false
Unit5 : negs RangeRest N
Unit6 : subset N A
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
Mem : mem I Range
============================
is_lit (pos I)
< apply is_list_int_mem to _ Mem.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (rangeClause Low High) (pos I) @
Unit1 : range Low High Range
Unit2 : select I RangeRest Range
Unit3 : mem (pos I) A -> false
Unit4 : mem (neg I) A -> false
Unit5 : negs RangeRest N
Unit6 : subset N A
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
Mem : mem I Range
H1 : is_integer I
============================
is_lit (pos I)
< search.
Subgoal 4:
Variables: A L Clause Note
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
Unit : unit_clause A (noteClause Note Clause) L @
Unit1 : unit_clause A Clause L *
============================
is_lit L
< case IsC.
Subgoal 4:
Variables: A L Clause Note
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (noteClause Note Clause) L @
Unit1 : unit_clause A Clause L *
H1 : is_string Note
H2 : is_clause Clause
============================
is_lit L
< apply IH to _ _ Unit1.
Subgoal 4:
Variables: A L Clause Note
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsA : is_list is_lit A
Unit : unit_clause A (noteClause Note Clause) L @
Unit1 : unit_clause A Clause L *
H1 : is_string Note
H2 : is_clause Clause
H3 : is_lit L
============================
is_lit L
< search.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_unique.
Subgoal 3:
Variables: A B LB Range RangeRest N I High Low
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
UnitB : unit_clause B (rangeClause Low High) LB
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
============================
pos I = LB
< UnitB: case UnitB.
Subgoal 3:
Variables: A B Range RangeRest N I High Low Range1 RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range1
UnitB1 : select I1 RangeRest1 Range1
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
============================
pos I = pos I1
< apply range_unique to UnitB UnitA1.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
============================
pos I = pos I1
< Is: case IsC.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
============================
pos I = pos I1
< IsRange: apply range_is to _ UnitB.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
============================
pos I = pos I1
< MA: apply select_mem to UnitA2.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
============================
pos I = pos I1
< MB: apply select_mem to UnitB1.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
============================
pos I = pos I1
< IsI: apply is_list_int_mem to _ MA.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
============================
pos I = pos I1
< IsI1: apply is_list_int_mem to _ MB.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
============================
pos I = pos I1
< Or: apply is_integer_eq_or_not to IsI1 IsI.
Subgoal 3:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
Or : I1 = I \/ (I1 = I -> false)
============================
pos I = pos I1
< E: case Or.
Subgoal 3.1:
Variables: A B Range RangeRest N I High Low RangeRest1 N1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I RangeRest1 Range
UnitB2 : mem (pos I) B -> false
UnitB3 : mem (neg I) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I Range
IsI : is_integer I
IsI1 : is_integer I
============================
pos I = pos I
< search.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
============================
pos I = pos I1
< M: apply mem_before_select_after to UnitB1 _ E.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
M : mem I RangeRest1
============================
pos I = pos I1
< MN: apply negs_mem to M UnitB4.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
M : mem I RangeRest1
MN : mem (neg I) N1
============================
pos I = pos I1
< MB: apply subset_mem to UnitB5 MN.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
M : mem I RangeRest1
MN : mem (neg I) N1
MB1 : mem (neg I) B
============================
pos I = pos I1
< Prm': apply permutation_symmetric to Prm.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
M : mem I RangeRest1
MN : mem (neg I) N1
MB1 : mem (neg I) B
Prm' : permutation B A
============================
pos I = pos I1
< MA: apply permutation_mem to Prm' MB1.
Subgoal 3.2:
Variables: A B Range RangeRest N I High Low RangeRest1 N1 I1
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (rangeClause Low High) (pos I) @
Prm : permutation A B
UnitA1 : range Low High Range
UnitA2 : select I RangeRest Range
UnitA3 : mem (pos I) A -> false
UnitA4 : mem (neg I) A -> false
UnitA5 : negs RangeRest N
UnitA6 : subset N A
UnitB : range Low High Range
UnitB1 : select I1 RangeRest1 Range
UnitB2 : mem (pos I1) B -> false
UnitB3 : mem (neg I1) B -> false
UnitB4 : negs RangeRest1 N1
UnitB5 : subset N1 B
Is : is_integer Low
Is1 : is_integer High
IsRange : is_list is_integer Range
MA : mem I Range
MB : mem I1 Range
IsI : is_integer I
IsI1 : is_integer I1
E : I1 = I -> false
M : mem I RangeRest1
MN : mem (neg I) N1
MB1 : mem (neg I) B
Prm' : permutation B A
MA1 : mem (neg I) A
============================
pos I = pos I1
< apply UnitA4 to _.
Subgoal 4:
Variables: A B LA LB Clause Note
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (noteClause Note Clause) LA @
UnitB : unit_clause B (noteClause Note Clause) LB
Prm : permutation A B
UnitA1 : unit_clause A Clause LA *
============================
LA = LB
< UnitB: case UnitB.
Subgoal 4:
Variables: A B LA LB Clause Note
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (noteClause Note Clause) LA @
Prm : permutation A B
UnitA1 : unit_clause A Clause LA *
UnitB : unit_clause B Clause LB
============================
LA = LB
< Is: case IsC.
Subgoal 4:
Variables: A B LA LB Clause Note
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (noteClause Note Clause) LA @
Prm : permutation A B
UnitA1 : unit_clause A Clause LA *
UnitB : unit_clause B Clause LB
Is : is_string Note
Is1 : is_clause Clause
============================
LA = LB
< apply IH to _ _ _ UnitA1 _ _.
Subgoal 4:
Variables: A B LB Clause Note
IH : forall A B C LA LB,
is_clause C -> is_list is_lit A -> is_list is_lit B -> unit_clause A C LA * ->
unit_clause B C LB -> permutation A B -> LA = LB
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (noteClause Note Clause) LB @
Prm : permutation A B
UnitA1 : unit_clause A Clause LB *
UnitB : unit_clause B Clause LB
Is : is_string Note
Is1 : is_clause Clause
============================
LB = LB
< search.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_not_assigned.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> mem L A -> false
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) A
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
============================
false
< backchain UC3.
Subgoal 4:
Variables: A L Clause Note
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> mem L A -> false
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
UC : unit_clause A (noteClause Note Clause) L @
Mem : mem L A
UC1 : unit_clause A Clause L *
============================
false
< Is: case IsC.
Subgoal 4:
Variables: A L Clause Note
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> mem L A -> false
IsA : is_list is_lit A
UC : unit_clause A (noteClause Note Clause) L @
Mem : mem L A
UC1 : unit_clause A Clause L *
Is : is_string Note
Is1 : is_clause Clause
============================
false
< apply IH to _ _ UC1 _.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_not_assigned_negate.
Subgoal 3:
Variables: A NL Range RangeRest N I High Low
IH : forall A C L NL,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> negate_lit L NL ->
mem NL A -> false
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
UC : unit_clause A (rangeClause Low High) (pos I) @
Neg : negate_lit (pos I) NL
Mem : mem NL A
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
============================
false
< case Neg.
Subgoal 3:
Variables: A Range RangeRest N I High Low
IH : forall A C L NL,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> negate_lit L NL ->
mem NL A -> false
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (neg I) A
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
============================
false
< backchain UC4.
Subgoal 4:
Variables: A L NL Clause Note
IH : forall A C L NL,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> negate_lit L NL ->
mem NL A -> false
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
UC : unit_clause A (noteClause Note Clause) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : unit_clause A Clause L *
============================
false
< case IsC.
Subgoal 4:
Variables: A L NL Clause Note
IH : forall A C L NL,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> negate_lit L NL ->
mem NL A -> false
IsA : is_list is_lit A
UC : unit_clause A (noteClause Note Clause) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : unit_clause A Clause L *
H1 : is_string Note
H2 : is_clause Clause
============================
false
< apply IH to _ _ UC1 _ _.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_expand.
Subgoal 3:
Variables: A E Range RangeRest N I High Low
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
SAT : sat_clause E (rangeClause Low High)
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
============================
mem (pos I) E
< Is: case IsC.
Subgoal 3:
Variables: A E Range RangeRest N I High Low
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
SAT : sat_clause E (rangeClause Low High)
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
============================
mem (pos I) E
< SAT: case SAT.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
============================
mem (pos I) E
< IsPX: apply mem_is_lit to _ SAT2.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsPX : is_lit (pos X)
============================
mem (pos I) E
< IsX: case IsPX.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
============================
mem (pos I) E
< MXR: apply in_range to _ _ UC1 SAT SAT1.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
============================
mem (pos I) E
< M: apply select_mem to UC2.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
============================
mem (pos I) E
< apply range_is to _ UC1.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
============================
mem (pos I) E
< IsI: apply is_list_int_mem to _ M.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
============================
mem (pos I) E
< Or: apply is_integer_eq_or_not to IsI IsX.
Subgoal 3:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
Or : I = X \/ (I = X -> false)
============================
mem (pos I) E
< E: case Or.
Subgoal 3.1:
Variables: A E Range RangeRest N High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos X) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select X RangeRest Range
UC3 : mem (pos X) A -> false
UC4 : mem (neg X) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem X Range
H1 : is_list is_integer Range
IsI : is_integer X
============================
mem (pos X) E
< search.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
============================
mem (pos I) E
< MXRR: apply mem_before_select_after to UC2 MXR _.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
MXRR : mem X RangeRest
============================
mem (pos I) E
< MXN: apply negs_mem to MXRR UC5.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
MXRR : mem X RangeRest
MXN : mem (neg X) N
============================
mem (pos I) E
< MXA: apply subset_mem to UC6 MXN.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
MXRR : mem X RangeRest
MXN : mem (neg X) N
MXA : mem (neg X) A
============================
mem (pos I) E
< MXE: apply Expand to MXA.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
MXRR : mem X RangeRest
MXN : mem (neg X) N
MXA : mem (neg X) A
MXE : mem (neg X) E
============================
mem (pos I) E
< GA_E: case GA_E.
Subgoal 3.2:
Variables: A E Range RangeRest N I High Low X
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (rangeClause Low High) (pos I) @
GA_A : good_assignment A
Expand : forall L, mem L A -> mem L E
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
SAT : Low <= X
SAT1 : X <= High
SAT2 : mem (pos X) E
IsX : is_integer X
MXR : mem X Range
M : mem I Range
H1 : is_list is_integer Range
IsI : is_integer I
E : I = X -> false
MXRR : mem X RangeRest
MXN : mem (neg X) N
MXA : mem (neg X) A
MXE : mem (neg X) E
GA_E : forall L NL, mem L E -> negate_lit L NL -> mem NL E -> false
============================
mem (pos I) E
< apply GA_E to MXE _ SAT2.
Subgoal 4:
Variables: A L E Clause Note
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (noteClause Note Clause) L @
SAT : sat_clause E (noteClause Note Clause)
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : unit_clause A Clause L *
============================
mem L E
< SAT: case SAT.
Subgoal 4:
Variables: A L E Clause Note
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (noteClause Note Clause) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : unit_clause A Clause L *
SAT : sat_clause E Clause
============================
mem L E
< case IsC.
Subgoal 4:
Variables: A L E Clause Note
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (noteClause Note Clause) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : unit_clause A Clause L *
SAT : sat_clause E Clause
H1 : is_string Note
H2 : is_clause Clause
============================
mem L E
< apply IH to _ _ _ UC1 SAT _ _ _.
Subgoal 4:
Variables: A L E Clause Note
IH : forall A C L E,
is_clause C -> is_list is_lit A -> is_list is_lit E -> unit_clause A C L * ->
sat_clause E C -> good_assignment A -> good_assignment E -> (forall L1,
mem L1 A -> mem L1 E) -> mem L E
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (noteClause Note Clause) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : unit_clause A Clause L *
SAT : sat_clause E Clause
H1 : is_string Note
H2 : is_clause Clause
H3 : mem L E
============================
mem L E
< search.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_add.
Subgoal 3:
Variables: A S Range RangeRest N I High Low
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsC : is_clause (rangeClause Low High)
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) S
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
============================
sat_clause S (rangeClause Low High)
< Is: case IsC.
Subgoal 3:
Variables: A S Range RangeRest N I High Low
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) S
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause S (rangeClause Low High)
< M: apply select_mem to UC2.
Subgoal 3:
Variables: A S Range RangeRest N I High Low
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) S
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
M : mem I Range
============================
sat_clause S (rangeClause Low High)
< Low: apply range_low_lesseq to _ UC1 _.
Subgoal 3:
Variables: A S Range RangeRest N I High Low
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) S
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
M : mem I Range
Low : Low <= I
============================
sat_clause S (rangeClause Low High)
< High: apply range_high_lesseq to _ UC1 _.
Subgoal 3:
Variables: A S Range RangeRest N I High Low
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (rangeClause Low High) (pos I) @
Mem : mem (pos I) S
UC1 : range Low High Range
UC2 : select I RangeRest Range
UC3 : mem (pos I) A -> false
UC4 : mem (neg I) A -> false
UC5 : negs RangeRest N
UC6 : subset N A
Is : is_integer Low
Is1 : is_integer High
M : mem I Range
Low : Low <= I
High : I <= High
============================
sat_clause S (rangeClause Low High)
< search.
Subgoal 4:
Variables: A S L Clause Note
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsC : is_clause (noteClause Note Clause)
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (noteClause Note Clause) L @
Mem : mem L S
UC1 : unit_clause A Clause L *
============================
sat_clause S (noteClause Note Clause)
< case IsC.
Subgoal 4:
Variables: A S L Clause Note
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (noteClause Note Clause) L @
Mem : mem L S
UC1 : unit_clause A Clause L *
H1 : is_string Note
H2 : is_clause Clause
============================
sat_clause S (noteClause Note Clause)
< apply IH to _ _ _ UC1 _.
Subgoal 4:
Variables: A S L Clause Note
IH : forall A S C L,
is_clause C -> is_list is_lit A -> is_list is_lit S -> unit_clause A C L * ->
mem L S -> sat_clause S C
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (noteClause Note Clause) L @
Mem : mem L S
UC1 : unit_clause A Clause L *
H1 : is_string Note
H2 : is_clause Clause
H3 : sat_clause S Clause
============================
sat_clause S (noteClause Note Clause)
< search.
Proof completed.
< Theorem posLits_total :
forall L, is_list is_integer L -> exists P, posLits L P.
============================
forall L, is_list is_integer L -> exists P, posLits L P
< induction on 1.
IH : forall L, is_list is_integer L * -> exists P, posLits L P
============================
forall L, is_list is_integer L @ -> exists P, posLits L P
< intros Is.
Variables: L
IH : forall L, is_list is_integer L * -> exists P, posLits L P
Is : is_list is_integer L @
============================
exists P, posLits L P
< Is: case Is.
Subgoal 1:
IH : forall L, is_list is_integer L * -> exists P, posLits L P
============================
exists P, posLits [] P
< search.
Subgoal 2:
Variables: T H
IH : forall L, is_list is_integer L * -> exists P, posLits L P
Is : is_integer H
Is1 : is_list is_integer T *
============================
exists P, posLits (H::T) P
< apply IH to Is1.
Subgoal 2:
Variables: T H P
IH : forall L, is_list is_integer L * -> exists P, posLits L P
Is : is_integer H
Is1 : is_list is_integer T *
H1 : posLits T P
============================
exists P, posLits (H::T) P
< search.
Proof completed.
< Theorem posLits_unique :
forall L P1 P2, posLits L P1 -> posLits L P2 -> P1 = P2.
============================
forall L P1 P2, posLits L P1 -> posLits L P2 -> P1 = P2
< induction on 1.
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
============================
forall L P1 P2, posLits L P1 @ -> posLits L P2 -> P1 = P2
< intros PL1 PL2.
Variables: L P1 P2
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
PL1 : posLits L P1 @
PL2 : posLits L P2
============================
P1 = P2
< PL1: case PL1.
Subgoal 1:
Variables: P2
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
PL2 : posLits [] P2
============================
[] = P2
< case PL2.
Subgoal 1:
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
============================
[] = []
< search.
Subgoal 2:
Variables: P2 LRest I Rest
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
PL2 : posLits (I::Rest) P2
PL1 : posLits Rest LRest *
============================
(pos I)::LRest = P2
< PL2: case PL2.
Subgoal 2:
Variables: LRest I Rest LRest1
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
PL1 : posLits Rest LRest *
PL2 : posLits Rest LRest1
============================
(pos I)::LRest = (pos I)::LRest1
< apply IH to PL1 PL2.
Subgoal 2:
Variables: I Rest LRest1
IH : forall L P1 P2, posLits L P1 * -> posLits L P2 -> P1 = P2
PL1 : posLits Rest LRest1 *
PL2 : posLits Rest LRest1
============================
(pos I)::LRest1 = (pos I)::LRest1
< search.
Proof completed.
< Theorem posLits_is :
forall L P, is_list is_integer L -> posLits L P -> is_list is_lit P.
============================
forall L P, is_list is_integer L -> posLits L P -> is_list is_lit P
< induction on 2.
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
============================
forall L P, is_list is_integer L -> posLits L P @ -> is_list is_lit P
< intros IsL PL.
Variables: L P
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
IsL : is_list is_integer L
PL : posLits L P @
============================
is_list is_lit P
< PL: case PL.
Subgoal 1:
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
IsL : is_list is_integer []
============================
is_list is_lit []
< search.
Subgoal 2:
Variables: LRest I Rest
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
IsL : is_list is_integer (I::Rest)
PL : posLits Rest LRest *
============================
is_list is_lit ((pos I)::LRest)
< Is: case IsL.
Subgoal 2:
Variables: LRest I Rest
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
PL : posLits Rest LRest *
Is : is_integer I
Is1 : is_list is_integer Rest
============================
is_list is_lit ((pos I)::LRest)
< apply IH to _ PL.
Subgoal 2:
Variables: LRest I Rest
IH : forall L P, is_list is_integer L -> posLits L P * -> is_list is_lit P
PL : posLits Rest LRest *
Is : is_integer I
Is1 : is_list is_integer Rest
H1 : is_list is_lit LRest
============================
is_list is_lit ((pos I)::LRest)
< search.
Proof completed.
< Theorem posLits_mem :
forall L P X, mem X L -> posLits L P -> mem (pos X) P.
============================
forall L P X, mem X L -> posLits L P -> mem (pos X) P
< induction on 1.
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
============================
forall L P X, mem X L @ -> posLits L P -> mem (pos X) P
< intros Mem PL.
Variables: L P X
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
Mem : mem X L @
PL : posLits L P
============================
mem (pos X) P
< Mem: case Mem.
Subgoal 1:
Variables: P X Rest
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
PL : posLits (X::Rest) P
============================
mem (pos X) P
< case PL.
Subgoal 1:
Variables: X Rest LRest
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
H1 : posLits Rest LRest
============================
mem (pos X) ((pos X)::LRest)
< search.
Subgoal 2:
Variables: P X Rest I
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
PL : posLits (I::Rest) P
Mem : mem X Rest *
============================
mem (pos X) P
< case PL.
Subgoal 2:
Variables: X Rest I LRest
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
Mem : mem X Rest *
H1 : posLits Rest LRest
============================
mem (pos X) ((pos I)::LRest)
< apply IH to Mem _.
Subgoal 2:
Variables: X Rest I LRest
IH : forall L P X, mem X L * -> posLits L P -> mem (pos X) P
Mem : mem X Rest *
H1 : posLits Rest LRest
H2 : mem (pos X) LRest
============================
mem (pos X) ((pos I)::LRest)
< search.
Proof completed.
< Theorem posLits_form :
forall L P X, posLits L P -> mem X P -> exists I, X = pos I.
============================
forall L P X, posLits L P -> mem X P -> exists I, X = pos I
< induction on 2.
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
============================
forall L P X, posLits L P -> mem X P @ -> exists I, X = pos I
< intros PL Mem.
Variables: L P X
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
PL : posLits L P
Mem : mem X P @
============================
exists I, X = pos I
< Mem: case Mem.
Subgoal 1:
Variables: L X Rest
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
PL : posLits L (X::Rest)
============================
exists I, X = pos I
< case PL.
Subgoal 1:
Variables: Rest I Rest1
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
H1 : posLits Rest1 Rest
============================
exists I1, pos I = pos I1
< search.
Subgoal 2:
Variables: L X Rest I
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
PL : posLits L (I::Rest)
Mem : mem X Rest *
============================
exists I, X = pos I
< case PL.
Subgoal 2:
Variables: X Rest I1 Rest1
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
Mem : mem X Rest *
H1 : posLits Rest1 Rest
============================
exists I, X = pos I
< apply IH to _ Mem.
Subgoal 2:
Variables: Rest I1 Rest1 I2
IH : forall L P X, posLits L P -> mem X P * -> exists I, X = pos I
Mem : mem (pos I2) Rest *
H1 : posLits Rest1 Rest
============================
exists I, pos I2 = pos I
< search.
Proof completed.
< Theorem mem_after_posLits_before :
forall L P I, posLits L P -> mem (pos I) P -> mem I L.
============================
forall L P I, posLits L P -> mem (pos I) P -> mem I L
< induction on 2.
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
============================
forall L P I, posLits L P -> mem (pos I) P @ -> mem I L
< intros PL Mem.
Variables: L P I
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
PL : posLits L P
Mem : mem (pos I) P @
============================
mem I L
< Mem: case Mem.
Subgoal 1:
Variables: L I Rest
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
PL : posLits L ((pos I)::Rest)
============================
mem I L
< case PL.
Subgoal 1:
Variables: I Rest Rest1
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
H1 : posLits Rest1 Rest
============================
mem I (I::Rest1)
< search.
Subgoal 2:
Variables: L I Rest I1
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
PL : posLits L (I1::Rest)
Mem : mem (pos I) Rest *
============================
mem I L
< PL: case PL.
Subgoal 2:
Variables: I Rest I2 Rest1
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
Mem : mem (pos I) Rest *
PL : posLits Rest1 Rest
============================
mem I (I2::Rest1)
< apply IH to _ Mem.
Subgoal 2:
Variables: I Rest I2 Rest1
IH : forall L P I, posLits L P -> mem (pos I) P * -> mem I L
Mem : mem (pos I) Rest *
PL : posLits Rest1 Rest
H1 : mem I Rest1
============================
mem I (I2::Rest1)
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_is.
Subgoal 3:
Variables: L R High Low
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
IsC : is_clause (rangeClause Low High)
GL : gatherLits (rangeClause Low High) L @
GL1 : range Low High R
GL2 : posLits R L
============================
is_list is_lit L
< Is: case IsC.
Subgoal 3:
Variables: L R High Low
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (rangeClause Low High) L @
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
============================
is_list is_lit L
< apply range_is to _ GL1.
Subgoal 3:
Variables: L R High Low
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (rangeClause Low High) L @
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
H1 : is_list is_integer R
============================
is_list is_lit L
< apply posLits_is to _ GL2.
Subgoal 3:
Variables: L R High Low
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (rangeClause Low High) L @
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
H1 : is_list is_integer R
H2 : is_list is_lit L
============================
is_list is_lit L
< search.
Subgoal 4:
Variables: L Clause Note
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
IsC : is_clause (noteClause Note Clause)
GL : gatherLits (noteClause Note Clause) L @
GL1 : gatherLits Clause L *
============================
is_list is_lit L
< case IsC.
Subgoal 4:
Variables: L Clause Note
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (noteClause Note Clause) L @
GL1 : gatherLits Clause L *
H1 : is_string Note
H2 : is_clause Clause
============================
is_list is_lit L
< apply IH to _ GL1.
Subgoal 4:
Variables: L Clause Note
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (noteClause Note Clause) L @
GL1 : gatherLits Clause L *
H1 : is_string Note
H2 : is_clause Clause
H3 : is_list is_lit L
============================
is_list is_lit L
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_exists.
Subgoal 3:
Variables: I I1
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
============================
exists L, gatherLits (rangeClause I1 I) L
< R: apply range_exists to IsC1 IsC2.
Subgoal 3:
Variables: I I1 R
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
R : range I1 I R
============================
exists L, gatherLits (rangeClause I1 I) L
< IsR: apply range_is to _ R.
Subgoal 3:
Variables: I I1 R
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
R : range I1 I R
IsR : is_list is_integer R
============================
exists L, gatherLits (rangeClause I1 I) L
< apply posLits_total to IsR.
Subgoal 3:
Variables: I I1 R P
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (rangeClause I1 I) @
IsC1 : is_integer I1
IsC2 : is_integer I
R : range I1 I R
IsR : is_list is_integer R
H1 : posLits R P
============================
exists L, gatherLits (rangeClause I1 I) L
< search.
Subgoal 4:
Variables: Clause S
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
============================
exists L, gatherLits (noteClause S Clause) L
< apply IH to IsC2.
Subgoal 4:
Variables: Clause S L
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (noteClause S Clause) @
IsC1 : is_string S
IsC2 : is_clause Clause *
H1 : gatherLits Clause L
============================
exists L, gatherLits (noteClause S Clause) L
< search.
Proof completed.
< Theorem permutation_reflexive_lits :
forall L, is_list is_lit L -> permutation L L.
============================
forall L, is_list is_lit L -> permutation L L
< induction on 1.
IH : forall L, is_list is_lit L * -> permutation L L
============================
forall L, is_list is_lit L @ -> permutation L L
< intros Is.
Variables: L
IH : forall L, is_list is_lit L * -> permutation L L
Is : is_list is_lit L @
============================
permutation L L
< Is: case Is.
Subgoal 1:
IH : forall L, is_list is_lit L * -> permutation L L
============================
permutation [] []
< search.
Subgoal 2:
Variables: T H
IH : forall L, is_list is_lit L * -> permutation L L
Is : is_lit H
Is1 : is_list is_lit T *
============================
permutation (H::T) (H::T)
< apply IH to Is1.
Subgoal 2:
Variables: T H
IH : forall L, is_list is_lit L * -> permutation L L
Is : is_lit H
Is1 : is_list is_lit T *
H1 : permutation T T
============================
permutation (H::T) (H::T)
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_permutation.
Subgoal 3:
Variables: L1 L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (rangeClause Low High)
GL1 : gatherLits (rangeClause Low High) L1 @
GL2 : gatherLits (rangeClause Low High) L2
GL3 : range Low High R
GL4 : posLits R L1
============================
permutation L1 L2
< GL': case GL2.
Subgoal 3:
Variables: L1 L2 R High Low R1
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (rangeClause Low High)
GL1 : gatherLits (rangeClause Low High) L1 @
GL3 : range Low High R
GL4 : posLits R L1
GL' : range Low High R1
GL'1 : posLits R1 L2
============================
permutation L1 L2
< apply range_unique to GL' GL3.
Subgoal 3:
Variables: L1 L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (rangeClause Low High)
GL1 : gatherLits (rangeClause Low High) L1 @
GL3 : range Low High R
GL4 : posLits R L1
GL' : range Low High R
GL'1 : posLits R L2
============================
permutation L1 L2
< apply posLits_unique to GL4 GL'1.
Subgoal 3:
Variables: L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (rangeClause Low High)
GL1 : gatherLits (rangeClause Low High) L2 @
GL3 : range Low High R
GL4 : posLits R L2
GL' : range Low High R
GL'1 : posLits R L2
============================
permutation L2 L2
< case IsC.
Subgoal 3:
Variables: L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (rangeClause Low High) L2 @
GL3 : range Low High R
GL4 : posLits R L2
GL' : range Low High R
GL'1 : posLits R L2
H1 : is_integer Low
H2 : is_integer High
============================
permutation L2 L2
< IsR: apply range_is to _ GL3.
Subgoal 3:
Variables: L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (rangeClause Low High) L2 @
GL3 : range Low High R
GL4 : posLits R L2
GL' : range Low High R
GL'1 : posLits R L2
H1 : is_integer Low
H2 : is_integer High
IsR : is_list is_integer R
============================
permutation L2 L2
< apply posLits_is to _ GL4.
Subgoal 3:
Variables: L2 R High Low
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (rangeClause Low High) L2 @
GL3 : range Low High R
GL4 : posLits R L2
GL' : range Low High R
GL'1 : posLits R L2
H1 : is_integer Low
H2 : is_integer High
IsR : is_list is_integer R
H3 : is_list is_lit L2
============================
permutation L2 L2
< backchain permutation_reflexive_lits.
Subgoal 4:
Variables: L1 L2 Clause Note
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (noteClause Note Clause)
GL1 : gatherLits (noteClause Note Clause) L1 @
GL2 : gatherLits (noteClause Note Clause) L2
GL3 : gatherLits Clause L1 *
============================
permutation L1 L2
< GL': case GL2.
Subgoal 4:
Variables: L1 L2 Clause Note
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (noteClause Note Clause)
GL1 : gatherLits (noteClause Note Clause) L1 @
GL3 : gatherLits Clause L1 *
GL' : gatherLits Clause L2
============================
permutation L1 L2
< case IsC.
Subgoal 4:
Variables: L1 L2 Clause Note
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (noteClause Note Clause) L1 @
GL3 : gatherLits Clause L1 *
GL' : gatherLits Clause L2
H1 : is_string Note
H2 : is_clause Clause
============================
permutation L1 L2
< apply IH to _ GL3 GL'.
Subgoal 4:
Variables: L1 L2 Clause Note
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (noteClause Note Clause) L1 @
GL3 : gatherLits Clause L1 *
GL' : gatherLits Clause L2
H1 : is_string Note
H2 : is_clause Clause
H3 : permutation L1 L2
============================
permutation L1 L2
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_gatherLits.
Subgoal 1:
Variables: L High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp2 : gatherLits (rangeClause Low High) L
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< GL: case Hyp2.
Subgoal 1:
Variables: L High PlusOne Low R
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< Is: case Hyp1.
Subgoal 1:
Variables: L High PlusOne Low R
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< L: apply lt_plus_one to Hyp4 _.
Subgoal 1:
Variables: L High PlusOne Low R
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
L : Low < PlusOne
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< IsPlusOne: apply plus_integer_is_integer to _ _ Hyp4.
Subgoal 1:
Variables: L High PlusOne Low R
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
L : Low < PlusOne
IsPlusOne : is_integer PlusOne
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< R: apply range_smaller_exists to _ _ GL L.
Subgoal 1:
Variables: L High PlusOne Low R R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
L : Low < PlusOne
IsPlusOne : is_integer PlusOne
R : range PlusOne High R'
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< IsR': apply range_is to _ R.
Subgoal 1:
Variables: L High PlusOne Low R R'
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
L : Low < PlusOne
IsPlusOne : is_integer PlusOne
R : range PlusOne High R'
IsR' : is_list is_integer R'
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< apply posLits_total to IsR'.
Subgoal 1:
Variables: L High PlusOne Low R R' P
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp3 : Low <= High
Hyp4 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
Is : is_integer Low
Is1 : is_integer High
L : Low < PlusOne
IsPlusOne : is_integer PlusOne
R : range PlusOne High R'
IsR' : is_list is_integer R'
H1 : posLits R' P
============================
exists L', gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
< search.
Subgoal 2:
Variables: L High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp2 : gatherLits (rangeClause Low High) L
Hyp3 : Low > High
============================
exists L', gatherLits emptyClause L'
< search.
Subgoal 3:
Variables: C' L Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_clause (noteClause Note C')
Hyp2 : gatherLits (noteClause Note C') L
============================
exists L', gatherLits C' L'
< case Hyp2.
Subgoal 3:
Variables: C' L Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_clause (noteClause Note C')
H1 : gatherLits C' L
============================
exists L', gatherLits C' L'
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_gatherLits_permutation.
Subgoal 1:
Variables: L L' High PlusOne Low
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp2 : gatherLits (rangeClause Low High) L
Hyp3 : gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
============================
permutation L L'
< GL: case Hyp2.
Subgoal 1:
Variables: L L' High PlusOne Low R
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp3 : gatherLits (or (pos Low) (rangeClause PlusOne High)) L'
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
============================
permutation L L'
< GL': case Hyp3.
Subgoal 1:
Variables: L High PlusOne Low R LRest
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
GL' : gatherLits (rangeClause PlusOne High) LRest
============================
permutation L ((pos Low)::LRest)
< GL': case GL'.
Subgoal 1:
Variables: L High PlusOne Low R LRest R1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL : range Low High R
GL1 : posLits R L
GL' : range PlusOne High R1
GL'1 : posLits R1 LRest
============================
permutation L ((pos Low)::LRest)
< R: case GL.
Subgoal 1.1:
Variables: L High PlusOne Low LRest R1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL1 : posLits [] L
GL' : range PlusOne High R1
GL'1 : posLits R1 LRest
R : Low > High
============================
permutation L ((pos Low)::LRest)
< apply greater_lesseq_integer_false to R Hyp4.
Subgoal 1.2:
Variables: L High PlusOne Low LRest R1 PlusOne1 Rest
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL1 : posLits (Low::Rest) L
GL' : range PlusOne High R1
GL'1 : posLits R1 LRest
R : Low <= High
R1 : 1 + Low = PlusOne1
R2 : range PlusOne1 High Rest
============================
permutation L ((pos Low)::LRest)
< apply plus_integer_unique to R1 Hyp5.
Subgoal 1.2:
Variables: L High PlusOne Low LRest R1 Rest
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL1 : posLits (Low::Rest) L
GL' : range PlusOne High R1
GL'1 : posLits R1 LRest
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
============================
permutation L ((pos Low)::LRest)
< apply range_unique to GL' R2.
Subgoal 1.2:
Variables: L High PlusOne Low LRest Rest
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL1 : posLits (Low::Rest) L
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
============================
permutation L ((pos Low)::LRest)
< PL: case GL1.
Subgoal 1.2:
Variables: High PlusOne Low LRest Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest)
< apply posLits_unique to GL'1 PL.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< Is: case Hyp1.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
Is : is_integer Low
Is1 : is_integer High
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< apply plus_integer_is_integer to _ _ R1.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
Is : is_integer Low
Is1 : is_integer High
H1 : is_integer PlusOne
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< apply range_is to _ GL'.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
Is : is_integer Low
Is1 : is_integer High
H1 : is_integer PlusOne
H2 : is_list is_integer Rest
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< IsLRest1: apply posLits_is to _ PL.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
Is : is_integer Low
Is1 : is_integer High
H1 : is_integer PlusOne
H2 : is_list is_integer Rest
IsLRest1 : is_list is_lit LRest1
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< apply permutation_reflexive_lits to IsLRest1.
Subgoal 1.2:
Variables: High PlusOne Low Rest LRest1
Hyp : |{clause}- rangeClause Low High ~~> or (pos Low) (rangeClause PlusOne High)
Hyp4 : Low <= High
Hyp5 : 1 + Low = PlusOne
GL' : range PlusOne High Rest
GL'1 : posLits Rest LRest1
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
PL : posLits Rest LRest1
Is : is_integer Low
Is1 : is_integer High
H1 : is_integer PlusOne
H2 : is_list is_integer Rest
IsLRest1 : is_list is_lit LRest1
H3 : permutation LRest1 LRest1
============================
permutation ((pos Low)::LRest1) ((pos Low)::LRest1)
< search.
Subgoal 2:
Variables: L L' High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp2 : gatherLits (rangeClause Low High) L
Hyp3 : gatherLits emptyClause L'
Hyp4 : Low > High
============================
permutation L L'
< GL: case Hyp2.
Subgoal 2:
Variables: L L' High Low R
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp3 : gatherLits emptyClause L'
Hyp4 : Low > High
GL : range Low High R
GL1 : posLits R L
============================
permutation L L'
< case Hyp3.
Subgoal 2:
Variables: L High Low R
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low > High
GL : range Low High R
GL1 : posLits R L
============================
permutation L []
< R: case GL.
Subgoal 2.1:
Variables: L High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low > High
GL1 : posLits [] L
R : Low > High
============================
permutation L []
< case GL1.
Subgoal 2.1:
Variables: High Low
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low > High
R : Low > High
============================
permutation [] []
< search.
Subgoal 2.2:
Variables: L High Low PlusOne Rest
Hyp : |{clause}- rangeClause Low High ~~> emptyClause
Hyp1 : is_clause (rangeClause Low High)
Hyp4 : Low > High
GL1 : posLits (Low::Rest) L
R : Low <= High
R1 : 1 + Low = PlusOne
R2 : range PlusOne High Rest
============================
permutation L []
< apply greater_lesseq_integer_false to Hyp4 R.
Subgoal 3:
Variables: C' L L' Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_clause (noteClause Note C')
Hyp2 : gatherLits (noteClause Note C') L
Hyp3 : gatherLits C' L'
============================
permutation L L'
< GL: case Hyp2.
Subgoal 3:
Variables: C' L L' Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp1 : is_clause (noteClause Note C')
Hyp3 : gatherLits C' L'
GL : gatherLits C' L
============================
permutation L L'
< Is: case Hyp1.
Subgoal 3:
Variables: C' L L' Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp3 : gatherLits C' L'
GL : gatherLits C' L
Is : is_string Note
Is1 : is_clause C'
============================
permutation L L'
< apply gatherLits_permutation to _ GL Hyp3.
Subgoal 3:
Variables: C' L L' Note
Hyp : |{clause}- noteClause Note C' ~~> C'
Hyp3 : gatherLits C' L'
GL : gatherLits C' L
Is : is_string Note
Is1 : is_clause C'
H1 : permutation L L'
============================
permutation L L'
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_sat.
Subgoal 3:
Variables: Lits Sat X High Low
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsC : is_clause (rangeClause Low High)
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
============================
exists L, mem L Lits /\ mem L Sat
< GL: case GL.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsC : is_clause (rangeClause Low High)
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
============================
exists L, mem L Lits /\ mem L Sat
< Is: case IsC.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
Is : is_integer Low
Is1 : is_integer High
============================
exists L, mem L Lits /\ mem L Sat
< IsPX: apply mem_is_lit to _ Sat3.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
Is : is_integer Low
Is1 : is_integer High
IsPX : is_lit (pos X)
============================
exists L, mem L Lits /\ mem L Sat
< IsX: case IsPX.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
Is : is_integer Low
Is1 : is_integer High
IsX : is_integer X
============================
exists L, mem L Lits /\ mem L Sat
< Mem: apply in_range to Is _ GL Sat1 Sat2.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
Is : is_integer Low
Is1 : is_integer High
IsX : is_integer X
Mem : mem X R
============================
exists L, mem L Lits /\ mem L Sat
< apply posLits_mem to Mem GL1.
Subgoal 3:
Variables: Lits Sat X High Low R
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (rangeClause Low High) @
Sat1 : Low <= X
Sat2 : X <= High
Sat3 : mem (pos X) Sat
GL : range Low High R
GL1 : posLits R Lits
Is : is_integer Low
Is1 : is_integer High
IsX : is_integer X
Mem : mem X R
H1 : mem (pos X) Lits
============================
exists L, mem L Lits /\ mem L Sat
< search.
Subgoal 4:
Variables: Lits Sat Clause Note
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsC : is_clause (noteClause Note Clause)
IsSat : is_list is_lit Sat
GL : gatherLits (noteClause Note Clause) Lits
Sat : sat_clause Sat (noteClause Note Clause) @
Sat1 : sat_clause Sat Clause *
============================
exists L, mem L Lits /\ mem L Sat
< Is: case IsC.
Subgoal 4:
Variables: Lits Sat Clause Note
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
GL : gatherLits (noteClause Note Clause) Lits
Sat : sat_clause Sat (noteClause Note Clause) @
Sat1 : sat_clause Sat Clause *
Is : is_string Note
Is1 : is_clause Clause
============================
exists L, mem L Lits /\ mem L Sat
< GL: case GL.
Subgoal 4:
Variables: Lits Sat Clause Note
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (noteClause Note Clause) @
Sat1 : sat_clause Sat Clause *
Is : is_string Note
Is1 : is_clause Clause
GL : gatherLits Clause Lits
============================
exists L, mem L Lits /\ mem L Sat
< apply IH to _ _ GL Sat1.
Subgoal 4:
Variables: Lits Sat Clause Note L
IH : forall C Lits Sat,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits -> sat_clause Sat C * ->
exists L, mem L Lits /\ mem L Sat
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (noteClause Note Clause) @
Sat1 : sat_clause Sat Clause *
Is : is_string Note
Is1 : is_clause Clause
GL : gatherLits Clause Lits
H1 : mem L Lits
H2 : mem L Sat
============================
exists L, mem L Lits /\ mem L Sat
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_mem_sat.
Subgoal 3:
Variables: Lits Sat L R High Low
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsC : is_clause (rangeClause Low High)
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem L Lits
MemSat : mem L Sat
GL1 : range Low High R
GL2 : posLits R Lits
============================
sat_clause Sat (rangeClause Low High)
< apply posLits_form to GL2 MemLits.
Subgoal 3:
Variables: Lits Sat R High Low I
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsC : is_clause (rangeClause Low High)
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem (pos I) Lits
MemSat : mem (pos I) Sat
GL1 : range Low High R
GL2 : posLits R Lits
============================
sat_clause Sat (rangeClause Low High)
< MemIR: apply mem_after_posLits_before to GL2 MemLits.
Subgoal 3:
Variables: Lits Sat R High Low I
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsC : is_clause (rangeClause Low High)
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem (pos I) Lits
MemSat : mem (pos I) Sat
GL1 : range Low High R
GL2 : posLits R Lits
MemIR : mem I R
============================
sat_clause Sat (rangeClause Low High)
< Is: case IsC.
Subgoal 3:
Variables: Lits Sat R High Low I
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem (pos I) Lits
MemSat : mem (pos I) Sat
GL1 : range Low High R
GL2 : posLits R Lits
MemIR : mem I R
Is : is_integer Low
Is1 : is_integer High
============================
sat_clause Sat (rangeClause Low High)
< apply range_low_lesseq to _ GL1 MemIR.
Subgoal 3:
Variables: Lits Sat R High Low I
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem (pos I) Lits
MemSat : mem (pos I) Sat
GL1 : range Low High R
GL2 : posLits R Lits
MemIR : mem I R
Is : is_integer Low
Is1 : is_integer High
H1 : Low <= I
============================
sat_clause Sat (rangeClause Low High)
< apply range_high_lesseq to _ GL1 MemIR.
Subgoal 3:
Variables: Lits Sat R High Low I
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsSat : is_list is_lit Sat
GL : gatherLits (rangeClause Low High) Lits @
MemLits : mem (pos I) Lits
MemSat : mem (pos I) Sat
GL1 : range Low High R
GL2 : posLits R Lits
MemIR : mem I R
Is : is_integer Low
Is1 : is_integer High
H1 : Low <= I
H2 : I <= High
============================
sat_clause Sat (rangeClause Low High)
< search.
Subgoal 4:
Variables: Lits Sat L Clause Note
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsC : is_clause (noteClause Note Clause)
IsSat : is_list is_lit Sat
GL : gatherLits (noteClause Note Clause) Lits @
MemLits : mem L Lits
MemSat : mem L Sat
GL1 : gatherLits Clause Lits *
============================
sat_clause Sat (noteClause Note Clause)
< Is: case IsC.
Subgoal 4:
Variables: Lits Sat L Clause Note
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsSat : is_list is_lit Sat
GL : gatherLits (noteClause Note Clause) Lits @
MemLits : mem L Lits
MemSat : mem L Sat
GL1 : gatherLits Clause Lits *
Is : is_string Note
Is1 : is_clause Clause
============================
sat_clause Sat (noteClause Note Clause)
< apply IH to _ _ GL1 MemLits MemSat.
Subgoal 4:
Variables: Lits Sat L Clause Note
IH : forall C Lits Sat L,
is_clause C -> is_list is_lit Sat -> gatherLits C Lits * -> mem L Lits ->
mem L Sat -> sat_clause Sat C
IsSat : is_list is_lit Sat
GL : gatherLits (noteClause Note Clause) Lits @
MemLits : mem L Lits
MemSat : mem L Sat
GL1 : gatherLits Clause Lits *
Is : is_string Note
Is1 : is_clause Clause
H1 : sat_clause Sat Clause
============================
sat_clause Sat (noteClause Note Clause)
< search.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_unsat.
Subgoal 3:
Variables: Lits Unsat L R N High Low
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsC : is_clause (rangeClause Low High)
IsUnsat : is_list is_lit Unsat
GL : gatherLits (rangeClause Low High) Lits
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
============================
false
< Is: case IsC.
Subgoal 3:
Variables: Lits Unsat L R N High Low
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
GL : gatherLits (rangeClause Low High) Lits
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
============================
false
< GL: case GL.
Subgoal 3:
Variables: Lits Unsat L R N High Low R1
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R1
GL1 : posLits R1 Lits
============================
false
< apply range_unique to GL Unsat1.
Subgoal 3:
Variables: Lits Unsat L R N High Low
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
============================
false
< apply posLits_form to GL1 MemLits.
Subgoal 3:
Variables: Lits Unsat R N High Low I
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem (pos I) Lits
MemUnsat : mem (pos I) Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
============================
false
< MR: apply mem_after_posLits_before to GL1 MemLits.
Subgoal 3:
Variables: Lits Unsat R N High Low I
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem (pos I) Lits
MemUnsat : mem (pos I) Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
MR : mem I R
============================
false
< MN: apply negs_mem to MR Unsat2.
Subgoal 3:
Variables: Lits Unsat R N High Low I
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem (pos I) Lits
MemUnsat : mem (pos I) Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
MR : mem I R
MN : mem (neg I) N
============================
false
< MU: apply subset_mem to Unsat3 MN.
Subgoal 3:
Variables: Lits Unsat R N High Low I
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem (pos I) Lits
MemUnsat : mem (pos I) Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
MR : mem I R
MN : mem (neg I) N
MU : mem (neg I) Unsat
============================
false
< GA: case GA.
Subgoal 3:
Variables: Lits Unsat R N High Low I
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (rangeClause Low High) @
MemLits : mem (pos I) Lits
MemUnsat : mem (pos I) Unsat
Unsat1 : range Low High R
Unsat2 : negs R N
Unsat3 : subset N Unsat
Is : is_integer Low
Is1 : is_integer High
GL : range Low High R
GL1 : posLits R Lits
MR : mem I R
MN : mem (neg I) N
MU : mem (neg I) Unsat
GA : forall L NL, mem L Unsat -> negate_lit L NL -> mem NL Unsat -> false
============================
false
< apply GA to MU _ MemUnsat.
Subgoal 4:
Variables: Lits Unsat L Clause Note
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsC : is_clause (noteClause Note Clause)
IsUnsat : is_list is_lit Unsat
GL : gatherLits (noteClause Note Clause) Lits
Unsat : unsat_clause Unsat (noteClause Note Clause) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : unsat_clause Unsat Clause *
============================
false
< case IsC.
Subgoal 4:
Variables: Lits Unsat L Clause Note
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
GL : gatherLits (noteClause Note Clause) Lits
Unsat : unsat_clause Unsat (noteClause Note Clause) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : unsat_clause Unsat Clause *
H1 : is_string Note
H2 : is_clause Clause
============================
false
< case GL.
Subgoal 4:
Variables: Lits Unsat L Clause Note
IH : forall C Lits Unsat L,
good_assignment Unsat -> is_clause C -> is_list is_lit Unsat -> gatherLits C Lits ->
unsat_clause Unsat C * -> mem L Lits -> mem L Unsat -> false
GA : good_assignment Unsat
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (noteClause Note Clause) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : unsat_clause Unsat Clause *
H1 : is_string Note
H2 : is_clause Clause
H3 : gatherLits Clause Lits
============================
false
< apply IH to GA _ _ _ Unsat1 _ _.
Proof completed.
< Theorem posLits_negateLitList_negs :
forall L P N, posLits L P -> negateLitList P N -> negs L N.
============================
forall L P N, posLits L P -> negateLitList P N -> negs L N
< induction on 1.
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
============================
forall L P N, posLits L P @ -> negateLitList P N -> negs L N
< intros PL N.
Variables: L P N
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
PL : posLits L P @
N : negateLitList P N
============================
negs L N
< PL: case PL.
Subgoal 1:
Variables: N
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
N : negateLitList [] N
============================
negs [] N
< case N.
Subgoal 1:
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
============================
negs [] []
< search.
Subgoal 2:
Variables: N LRest I Rest
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
N : negateLitList ((pos I)::LRest) N
PL : posLits Rest LRest *
============================
negs (I::Rest) N
< N: case N.
Subgoal 2:
Variables: LRest I Rest NRest N1
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
PL : posLits Rest LRest *
N : negate_lit (pos I) N1
N1 : negateLitList LRest NRest
============================
negs (I::Rest) (N1::NRest)
< apply IH to PL N1.
Subgoal 2:
Variables: LRest I Rest NRest N1
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
PL : posLits Rest LRest *
N : negate_lit (pos I) N1
N1 : negateLitList LRest NRest
H1 : negs Rest NRest
============================
negs (I::Rest) (N1::NRest)
< case N.
Subgoal 2:
Variables: LRest I Rest NRest
IH : forall L P N, posLits L P * -> negateLitList P N -> negs L N
PL : posLits Rest LRest *
N1 : negateLitList LRest NRest
H1 : negs Rest NRest
============================
negs (I::Rest) ((neg I)::NRest)
< search.
Proof completed.
< Theorem negs_is :
forall L N, is_list is_integer L -> negs L N -> is_list is_lit N.
============================
forall L N, is_list is_integer L -> negs L N -> is_list is_lit N
< induction on 1.
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
============================
forall L N, is_list is_integer L @ -> negs L N -> is_list is_lit N
< intros Is N.
Variables: L N
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
Is : is_list is_integer L @
N : negs L N
============================
is_list is_lit N
< Is: case Is.
Subgoal 1:
Variables: N
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
N : negs [] N
============================
is_list is_lit N
< case N.
Subgoal 1:
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
============================
is_list is_lit []
< search.
Subgoal 2:
Variables: N T H
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
N : negs (H::T) N
Is : is_integer H
Is1 : is_list is_integer T *
============================
is_list is_lit N
< N: case N.
Subgoal 2:
Variables: T H LRest
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
Is : is_integer H
Is1 : is_list is_integer T *
N : negs T LRest
============================
is_list is_lit ((neg H)::LRest)
< apply IH to Is1 N.
Subgoal 2:
Variables: T H LRest
IH : forall L N, is_list is_integer L * -> negs L N -> is_list is_lit N
Is : is_integer H
Is1 : is_list is_integer T *
N : negs T LRest
H1 : is_list is_lit LRest
============================
is_list is_lit ((neg H)::LRest)
< search.
Proof completed.
< Prove unsat_proofs:lrat:negate_lits_unsat.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
IsC : is_clause (rangeClause Low High)
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
============================
unsat_clause NL (rangeClause Low High)
< Is: case IsC.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
============================
unsat_clause NL (rangeClause Low High)
< Negs: apply posLits_negateLitList_negs to GL2 NLL.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
Negs : negs R NL
============================
unsat_clause NL (rangeClause Low High)
< IsR: apply range_is to _ GL1.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
Negs : negs R NL
IsR : is_list is_integer R
============================
unsat_clause NL (rangeClause Low High)
< IsNL: apply negs_is to IsR Negs.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
Negs : negs R NL
IsR : is_list is_integer R
IsNL : is_list is_lit NL
============================
unsat_clause NL (rangeClause Low High)
< apply mems_subset to IsNL _ with
Sup = NL.
Subgoal 3:
Variables: L NL R High Low
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (rangeClause Low High) L @
NLL : negateLitList L NL
GL1 : range Low High R
GL2 : posLits R L
Is : is_integer Low
Is1 : is_integer High
Negs : negs R NL
IsR : is_list is_integer R
IsNL : is_list is_lit NL
H1 : subset NL NL
============================
unsat_clause NL (rangeClause Low High)
< search.
Subgoal 4:
Variables: L NL Clause Note
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
IsC : is_clause (noteClause Note Clause)
GL : gatherLits (noteClause Note Clause) L @
NLL : negateLitList L NL
GL1 : gatherLits Clause L *
============================
unsat_clause NL (noteClause Note Clause)
< case IsC.
Subgoal 4:
Variables: L NL Clause Note
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (noteClause Note Clause) L @
NLL : negateLitList L NL
GL1 : gatherLits Clause L *
H1 : is_string Note
H2 : is_clause Clause
============================
unsat_clause NL (noteClause Note Clause)
< apply IH to _ GL1 _.
Subgoal 4:
Variables: L NL Clause Note
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (noteClause Note Clause) L @
NLL : negateLitList L NL
GL1 : gatherLits Clause L *
H1 : is_string Note
H2 : is_clause Clause
H3 : unsat_clause NL Clause
============================
unsat_clause NL (noteClause Note Clause)
< search.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_proof_is.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_proof_extend.
Proof completed.
< Prove unsat_proofs:lrat:check_proof_correct.
Proof completed.
< Prove unsat_proofs:lrat:checkProof_orderless.
Proof completed.
< Add_Ext_Size unsat_proofs:lrat:checkProof.
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:checkProof.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:checkProof.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_checkProof.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_unique.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_all_greater.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_all_unique.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_sat_formula.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_is.
Proof completed.
