< Module unsat_proofs:lrat.
< Projection_Constraint proj_lit_unique :
forall L LA LB,
ProjA : |{lit}- L ~~> LA ->
ProjB : |{lit}- L ~~> LB ->
LA = LB.
Proof completed.
< Projection_Constraint proj_lit_is :
forall L LT,
Proj : |{lit}- L ~~> LT ->
IsL : is_lit L ->
is_lit LT.
Proof completed.
< Projection_Constraint proj_clause_unique :
forall C CA CB,
ProjA : |{clause}- C ~~> CA ->
ProjB : |{clause}- C ~~> CB ->
CA = CB.
Proof completed.
< Projection_Constraint proj_clause_is :
forall C CT,
Proj : |{clause}- C ~~> CT ->
IsC : is_clause C ->
is_clause CT.
Proof completed.
< Projection_Constraint proj_formula_unique :
forall F FA FB,
ProjA : |{formula}- F ~~> FA ->
ProjB : |{formula}- F ~~> FB ->
FA = FB.
Proof completed.
< Projection_Constraint proj_formula_is :
forall F FT,
Proj : |{formula}- F ~~> FT ->
IsF : is_formula F ->
is_formula FT.
Proof completed.
< Proj_Rel is_clause C.
Proof completed.
< Ext_Ind forall C, is_clause C.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 1:
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause emptyClause @
============================
<is_clause {P}> emptyClause
< search.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (or Lit Clause) @
R1 : is_lit Lit
R2 : is_clause Clause *
============================
<is_clause {P}> (or Lit Clause)
< apply IH to R2.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> <is_clause {P}> C
R : is_clause (or Lit Clause) @
R1 : is_lit Lit
R2 : is_clause Clause *
H1 : <is_clause {P}> Clause
============================
<is_clause {P}> (or Lit Clause)
< search.
Proof completed.
< Proj_Rel is_formula F.
Proof completed.
< Ext_Ind forall F, is_formula F.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Subgoal 1:
IH : forall F, is_formula F * -> <is_formula {P}> F
R : is_formula emptyFormula @
============================
<is_formula {P}> emptyFormula
< search.
Subgoal 2:
Variables: Formula Clause
IH : forall F, is_formula F * -> <is_formula {P}> F
R : is_formula (and Clause Formula) @
R1 : is_clause Clause
R2 : is_formula Formula *
============================
<is_formula {P}> (and Clause Formula)
< apply IH to R2.
Subgoal 2:
Variables: Formula Clause
IH : forall F, is_formula F * -> <is_formula {P}> F
R : is_formula (and Clause Formula) @
R1 : is_clause Clause
R2 : is_formula Formula *
H1 : <is_formula {P}> Formula
============================
<is_formula {P}> (and Clause Formula)
< search.
Proof completed.
< Extensible_Theorem
is_lit_pos_or_neg : forall L,
IsL : is_lit L ->
exists I,
L = pos I \/ L = neg I
on IsL.
Subgoal 1:
Variables: I
IH : forall L, is_lit L * -> exists I, L = pos I \/ L = neg I
IsL : is_lit (pos I) @
IsL1 : is_integer I
============================
exists I1, pos I = pos I1 \/ pos I = neg I1
< search.
Subgoal 2:
Variables: I
IH : forall L, is_lit L * -> exists I, L = pos I \/ L = neg I
IsL : is_lit (neg I) @
IsL1 : is_integer I
============================
exists I1, neg I = pos I1 \/ neg I = neg I1
< search.
Proof completed.
< Theorem is_lit_eq_or_not :
forall L1 L2, is_lit L1 -> is_lit L2 -> L1 = L2 \/ (L1 = L2 -> false).
============================
forall L1 L2, is_lit L1 -> is_lit L2 -> L1 = L2 \/ (L1 = L2 -> false)
< intros IsL1 IsL2.
Variables: L1 L2
IsL1 : is_lit L1
IsL2 : is_lit L2
============================
L1 = L2 \/ (L1 = L2 -> false)
< Or1: apply is_lit_pos_or_neg to IsL1.
Variables: L1 L2 I
IsL1 : is_lit L1
IsL2 : is_lit L2
Or1 : L1 = pos I \/ L1 = neg I
============================
L1 = L2 \/ (L1 = L2 -> false)
< Or2: apply is_lit_pos_or_neg to IsL2.
Variables: L1 L2 I I1
IsL1 : is_lit L1
IsL2 : is_lit L2
Or1 : L1 = pos I \/ L1 = neg I
Or2 : L2 = pos I1 \/ L2 = neg I1
============================
L1 = L2 \/ (L1 = L2 -> false)
< case Or1.
Subgoal 1:
Variables: L2 I I1
IsL1 : is_lit (pos I)
IsL2 : is_lit L2
Or2 : L2 = pos I1 \/ L2 = neg I1
============================
pos I = L2 \/ (pos I = L2 -> false)
< case Or2.
Subgoal 1.1:
Variables: I I1
IsL1 : is_lit (pos I)
IsL2 : is_lit (pos I1)
============================
pos I = pos I1 \/ (pos I = pos I1 -> false)
< Is1: case IsL1.
Subgoal 1.1:
Variables: I I1
IsL2 : is_lit (pos I1)
Is1 : is_integer I
============================
pos I = pos I1 \/ (pos I = pos I1 -> false)
< Is2: case IsL2.
Subgoal 1.1:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
============================
pos I = pos I1 \/ (pos I = pos I1 -> false)
< Or: apply is_integer_eq_or_not to Is1 Is2.
Subgoal 1.1:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
Or : I = I1 \/ (I = I1 -> false)
============================
pos I = pos I1 \/ (pos I = pos I1 -> false)
< N: case Or.
Subgoal 1.1.1:
Variables: I1
Is1 : is_integer I1
Is2 : is_integer I1
============================
pos I1 = pos I1 \/ (pos I1 = pos I1 -> false)
< search.
Subgoal 1.1.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
============================
pos I = pos I1 \/ (pos I = pos I1 -> false)
< right.
Subgoal 1.1.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
============================
pos I = pos I1 -> false
< intros E.
Subgoal 1.1.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
E : pos I = pos I1
============================
false
< case E.
Subgoal 1.1.2:
Variables: I1
Is1 : is_integer I1
Is2 : is_integer I1
N : I1 = I1 -> false
============================
false
< backchain N.
Subgoal 1.2:
Variables: I I1
IsL1 : is_lit (pos I)
IsL2 : is_lit (neg I1)
============================
pos I = neg I1 \/ (pos I = neg I1 -> false)
< right.
Subgoal 1.2:
Variables: I I1
IsL1 : is_lit (pos I)
IsL2 : is_lit (neg I1)
============================
pos I = neg I1 -> false
< intros E.
Subgoal 1.2:
Variables: I I1
IsL1 : is_lit (pos I)
IsL2 : is_lit (neg I1)
E : pos I = neg I1
============================
false
< case E.
Subgoal 2:
Variables: L2 I I1
IsL1 : is_lit (neg I)
IsL2 : is_lit L2
Or2 : L2 = pos I1 \/ L2 = neg I1
============================
neg I = L2 \/ (neg I = L2 -> false)
< case Or2.
Subgoal 2.1:
Variables: I I1
IsL1 : is_lit (neg I)
IsL2 : is_lit (pos I1)
============================
neg I = pos I1 \/ (neg I = pos I1 -> false)
< right.
Subgoal 2.1:
Variables: I I1
IsL1 : is_lit (neg I)
IsL2 : is_lit (pos I1)
============================
neg I = pos I1 -> false
< intros E.
Subgoal 2.1:
Variables: I I1
IsL1 : is_lit (neg I)
IsL2 : is_lit (pos I1)
E : neg I = pos I1
============================
false
< case E.
Subgoal 2.2:
Variables: I I1
IsL1 : is_lit (neg I)
IsL2 : is_lit (neg I1)
============================
neg I = neg I1 \/ (neg I = neg I1 -> false)
< Is1: case IsL1.
Subgoal 2.2:
Variables: I I1
IsL2 : is_lit (neg I1)
Is1 : is_integer I
============================
neg I = neg I1 \/ (neg I = neg I1 -> false)
< Is2: case IsL2.
Subgoal 2.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
============================
neg I = neg I1 \/ (neg I = neg I1 -> false)
< Or: apply is_integer_eq_or_not to Is1 Is2.
Subgoal 2.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
Or : I = I1 \/ (I = I1 -> false)
============================
neg I = neg I1 \/ (neg I = neg I1 -> false)
< N: case Or.
Subgoal 2.2.1:
Variables: I1
Is1 : is_integer I1
Is2 : is_integer I1
============================
neg I1 = neg I1 \/ (neg I1 = neg I1 -> false)
< search.
Subgoal 2.2.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
============================
neg I = neg I1 \/ (neg I = neg I1 -> false)
< right.
Subgoal 2.2.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
============================
neg I = neg I1 -> false
< intros E.
Subgoal 2.2.2:
Variables: I I1
Is1 : is_integer I
Is2 : is_integer I1
N : I = I1 -> false
E : neg I = neg I1
============================
false
< case E.
Subgoal 2.2.2:
Variables: I1
Is1 : is_integer I1
Is2 : is_integer I1
N : I1 = I1 -> false
============================
false
< backchain N.
Proof completed.
< Extensible_Theorem
is_clause_empty_or_not : forall C,
IsC : is_clause C ->
emptyClause = C \/
(emptyClause = C -> false)
on IsC.
Subgoal 1:
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause emptyClause @
============================
emptyClause = emptyClause \/ (emptyClause = emptyClause -> false)
< search.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
emptyClause = or Lit Clause \/ (emptyClause = or Lit Clause -> false)
< right.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
emptyClause = or Lit Clause -> false
< intros E.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> emptyClause = C \/ (emptyClause = C -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
E : emptyClause = or Lit Clause
============================
false
< case E.
Proof completed.
< Extensible_Theorem
is_clause_or_or_not : forall C,
IsC : is_clause C ->
(exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
on IsC.
Subgoal 1:
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause emptyClause @
============================
(exists L R, or L R = emptyClause) \/
((exists L R, or L R = emptyClause) -> false)
< right.
Subgoal 1:
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause emptyClause @
============================
(exists L R, or L R = emptyClause) -> false
< intros E.
Subgoal 1:
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause emptyClause @
E : exists L R, or L R = emptyClause
============================
false
< case E.
Subgoal 2:
Variables: Clause Lit
IH : forall C,
is_clause C * -> (exists L R, or L R = C) \/
((exists L R, or L R = C) -> false)
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
(exists L R, or L R = or Lit Clause) \/
((exists L R, or L R = or Lit Clause) -> false)
< search.
Proof completed.
< Extensible_Theorem
is_clause_eq_or_not : forall C1 C2,
IsC1 : is_clause C1 ->
IsC2 : is_clause C2 ->
C1 = C2 \/
(C1 = C2 -> false)
on IsC1.
Subgoal 1:
Variables: C2
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause emptyClause @
IsC2 : is_clause C2
============================
emptyClause = C2 \/ (emptyClause = C2 -> false)
< Or: apply is_clause_empty_or_not to IsC2.
Subgoal 1:
Variables: C2
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause emptyClause @
IsC2 : is_clause C2
Or : emptyClause = C2 \/ (emptyClause = C2 -> false)
============================
emptyClause = C2 \/ (emptyClause = C2 -> false)
< Eq: case Or.
Subgoal 1.1:
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause emptyClause @
IsC2 : is_clause emptyClause
============================
emptyClause = emptyClause \/ (emptyClause = emptyClause -> false)
< search.
Subgoal 1.2:
Variables: C2
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause emptyClause @
IsC2 : is_clause C2
Eq : emptyClause = C2 -> false
============================
emptyClause = C2 \/ (emptyClause = C2 -> false)
< search.
Subgoal 2:
Variables: C2 Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause C2
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
============================
or Lit Clause = C2 \/ (or Lit Clause = C2 -> false)
< Or: apply is_clause_or_or_not to IsC2.
Subgoal 2:
Variables: C2 Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause C2
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Or : (exists L R, or L R = C2) \/ ((exists L R, or L R = C2) -> false)
============================
or Lit Clause = C2 \/ (or Lit Clause = C2 -> false)
< Form: case Or.
Subgoal 2.1:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause (or L R)
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
============================
or Lit Clause = or L R \/ (or Lit Clause = or L R -> false)
< Is: case IsC2.
Subgoal 2.1:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit L
Is1 : is_clause R
============================
or Lit Clause = or L R \/ (or Lit Clause = or L R -> false)
< Or: apply is_lit_eq_or_not to Is IsC3.
Subgoal 2.1:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit L
Is1 : is_clause R
Or : L = Lit \/ (L = Lit -> false)
============================
or Lit Clause = or L R \/ (or Lit Clause = or L R -> false)
< NEq: case Or.
Subgoal 2.1.1:
Variables: Clause Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit Lit
Is1 : is_clause R
============================
or Lit Clause = or Lit R \/ (or Lit Clause = or Lit R -> false)
< Or: apply IH to IsC4 Is1.
Subgoal 2.1.1:
Variables: Clause Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit Lit
Is1 : is_clause R
Or : Clause = R \/ (Clause = R -> false)
============================
or Lit Clause = or Lit R \/ (or Lit Clause = or Lit R -> false)
< NEq: case Or.
Subgoal 2.1.1.1:
Variables: Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit R) @
IsC3 : is_lit Lit
IsC4 : is_clause R *
Is : is_lit Lit
Is1 : is_clause R
============================
or Lit R = or Lit R \/ (or Lit R = or Lit R -> false)
< search.
Subgoal 2.1.1.2:
Variables: Clause Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit Lit
Is1 : is_clause R
NEq : Clause = R -> false
============================
or Lit Clause = or Lit R \/ (or Lit Clause = or Lit R -> false)
< right.
Subgoal 2.1.1.2:
Variables: Clause Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit Lit
Is1 : is_clause R
NEq : Clause = R -> false
============================
or Lit Clause = or Lit R -> false
< intros E.
Subgoal 2.1.1.2:
Variables: Clause Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit Lit
Is1 : is_clause R
NEq : Clause = R -> false
E : or Lit Clause = or Lit R
============================
false
< case E.
Subgoal 2.1.1.2:
Variables: Lit R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit R) @
IsC3 : is_lit Lit
IsC4 : is_clause R *
Is : is_lit Lit
Is1 : is_clause R
NEq : R = R -> false
============================
false
< backchain NEq.
Subgoal 2.1.2:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit L
Is1 : is_clause R
NEq : L = Lit -> false
============================
or Lit Clause = or L R \/ (or Lit Clause = or L R -> false)
< right.
Subgoal 2.1.2:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit L
Is1 : is_clause R
NEq : L = Lit -> false
============================
or Lit Clause = or L R -> false
< intros E.
Subgoal 2.1.2:
Variables: Clause Lit L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Is : is_lit L
Is1 : is_clause R
NEq : L = Lit -> false
E : or Lit Clause = or L R
============================
false
< case E.
Subgoal 2.1.2:
Variables: L R
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or L R) @
IsC3 : is_lit L
IsC4 : is_clause R *
Is : is_lit L
Is1 : is_clause R
NEq : L = L -> false
============================
false
< backchain NEq.
Subgoal 2.2:
Variables: C2 Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause C2
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Form : (exists L R, or L R = C2) -> false
============================
or Lit Clause = C2 \/ (or Lit Clause = C2 -> false)
< right.
Subgoal 2.2:
Variables: C2 Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause C2
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Form : (exists L R, or L R = C2) -> false
============================
or Lit Clause = C2 -> false
< intros E.
Subgoal 2.2:
Variables: C2 Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause C2
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Form : (exists L R, or L R = C2) -> false
E : or Lit Clause = C2
============================
false
< case E.
Subgoal 2.2:
Variables: Clause Lit
IH : forall C1 C2,
is_clause C1 * -> is_clause C2 -> C1 = C2 \/ (C1 = C2 -> false)
IsC1 : is_clause (or Lit Clause) @
IsC2 : is_clause (or Lit Clause)
IsC3 : is_lit Lit
IsC4 : is_clause Clause *
Form : (exists L R, or L R = or Lit Clause) -> false
============================
false
< backchain Form.
Proof completed.
< Extensible_Theorem
is_formula_empty_or_not : forall F,
IsF : is_formula F ->
F = emptyFormula \/
(F = emptyFormula -> false)
on IsF.
Subgoal 1:
IH : forall F, is_formula F * -> F = emptyFormula \/ (F = emptyFormula -> false)
IsF : is_formula emptyFormula @
============================
emptyFormula = emptyFormula \/ (emptyFormula = emptyFormula -> false)
< search.
Subgoal 2:
Variables: Formula Clause
IH : forall F, is_formula F * -> F = emptyFormula \/ (F = emptyFormula -> false)
IsF : is_formula (and Clause Formula) @
IsF1 : is_clause Clause
IsF2 : is_formula Formula *
============================
and Clause Formula = emptyFormula \/
(and Clause Formula = emptyFormula -> false)
< search.
Proof completed.
< Extensible_Theorem
is_formula_and_or_not : forall F,
IsF : is_formula F ->
(exists C F', F = unsat_proofs:lrat:and C F') \/
((exists C F', F = unsat_proofs:lrat:and C F') -> false)
on IsF.
Subgoal 1:
IH : forall F,
is_formula F * -> (exists C F', F = and C F') \/
((exists C F', F = and C F') -> false)
IsF : is_formula emptyFormula @
============================
(exists C F', emptyFormula = and C F') \/
((exists C F', emptyFormula = and C F') -> false)
< search.
Subgoal 2:
Variables: Formula Clause
IH : forall F,
is_formula F * -> (exists C F', F = and C F') \/
((exists C F', F = and C F') -> false)
IsF : is_formula (and Clause Formula) @
IsF1 : is_clause Clause
IsF2 : is_formula Formula *
============================
(exists C F', and Clause Formula = and C F') \/
((exists C F', and Clause Formula = and C F') -> false)
< search.
Proof completed.
< Extensible_Theorem
is_formula_eq_or_not : forall F1 F2,
IsF1 : is_formula F1 ->
IsF2 : is_formula F2 ->
F1 = F2 \/
(F1 = F2 -> false)
on IsF1.
Subgoal 1:
Variables: F2
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula F2
============================
emptyFormula = F2 \/ (emptyFormula = F2 -> false)
< Or: apply is_formula_empty_or_not to IsF2.
Subgoal 1:
Variables: F2
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula F2
Or : F2 = emptyFormula \/ (F2 = emptyFormula -> false)
============================
emptyFormula = F2 \/ (emptyFormula = F2 -> false)
< N: case Or.
Subgoal 1.1:
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula emptyFormula
============================
emptyFormula = emptyFormula \/ (emptyFormula = emptyFormula -> false)
< search.
Subgoal 1.2:
Variables: F2
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula F2
N : F2 = emptyFormula -> false
============================
emptyFormula = F2 \/ (emptyFormula = F2 -> false)
< right.
Subgoal 1.2:
Variables: F2
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula F2
N : F2 = emptyFormula -> false
============================
emptyFormula = F2 -> false
< intros E.
Subgoal 1.2:
Variables: F2
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula F2
N : F2 = emptyFormula -> false
E : emptyFormula = F2
============================
false
< case E.
Subgoal 1.2:
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula emptyFormula @
IsF2 : is_formula emptyFormula
N : emptyFormula = emptyFormula -> false
============================
false
< backchain N.
Subgoal 2:
Variables: F2 Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula F2
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
============================
and Clause Formula = F2 \/ (and Clause Formula = F2 -> false)
< Or: apply is_formula_and_or_not to IsF2.
Subgoal 2:
Variables: F2 Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula F2
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Or : (exists C F', F2 = and C F') \/ ((exists C F', F2 = and C F') -> false)
============================
and Clause Formula = F2 \/ (and Clause Formula = F2 -> false)
< N: case Or.
Subgoal 2.1:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula (and C F')
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
============================
and Clause Formula = and C F' \/ (and Clause Formula = and C F' -> false)
< Is': case IsF2.
Subgoal 2.1:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
============================
and Clause Formula = and C F' \/ (and Clause Formula = and C F' -> false)
< Or: apply is_clause_eq_or_not to IsF3 Is'.
Subgoal 2.1:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
Or : Clause = C \/ (Clause = C -> false)
============================
and Clause Formula = and C F' \/ (and Clause Formula = and C F' -> false)
< N: case Or.
Subgoal 2.1.1:
Variables: Formula C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C Formula) @
IsF3 : is_clause C
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
============================
and C Formula = and C F' \/ (and C Formula = and C F' -> false)
< Or: apply IH to IsF4 Is'1.
Subgoal 2.1.1:
Variables: Formula C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C Formula) @
IsF3 : is_clause C
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
Or : Formula = F' \/ (Formula = F' -> false)
============================
and C Formula = and C F' \/ (and C Formula = and C F' -> false)
< N: case Or.
Subgoal 2.1.1.1:
Variables: C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C F') @
IsF3 : is_clause C
IsF4 : is_formula F' *
Is' : is_clause C
Is'1 : is_formula F'
============================
and C F' = and C F' \/ (and C F' = and C F' -> false)
< search.
Subgoal 2.1.1.2:
Variables: Formula C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C Formula) @
IsF3 : is_clause C
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Formula = F' -> false
============================
and C Formula = and C F' \/ (and C Formula = and C F' -> false)
< right.
Subgoal 2.1.1.2:
Variables: Formula C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C Formula) @
IsF3 : is_clause C
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Formula = F' -> false
============================
and C Formula = and C F' -> false
< intros E.
Subgoal 2.1.1.2:
Variables: Formula C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C Formula) @
IsF3 : is_clause C
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Formula = F' -> false
E : and C Formula = and C F'
============================
false
< case E.
Subgoal 2.1.1.2:
Variables: C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C F') @
IsF3 : is_clause C
IsF4 : is_formula F' *
Is' : is_clause C
Is'1 : is_formula F'
N : F' = F' -> false
============================
false
< backchain N.
Subgoal 2.1.2:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Clause = C -> false
============================
and Clause Formula = and C F' \/ (and Clause Formula = and C F' -> false)
< right.
Subgoal 2.1.2:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Clause = C -> false
============================
and Clause Formula = and C F' -> false
< intros E.
Subgoal 2.1.2:
Variables: Formula Clause C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
Is' : is_clause C
Is'1 : is_formula F'
N : Clause = C -> false
E : and Clause Formula = and C F'
============================
false
< case E.
Subgoal 2.1.2:
Variables: C F'
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and C F') @
IsF3 : is_clause C
IsF4 : is_formula F' *
Is' : is_clause C
Is'1 : is_formula F'
N : C = C -> false
============================
false
< backchain N.
Subgoal 2.2:
Variables: F2 Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula F2
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
N : (exists C F', F2 = and C F') -> false
============================
and Clause Formula = F2 \/ (and Clause Formula = F2 -> false)
< right.
Subgoal 2.2:
Variables: F2 Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula F2
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
N : (exists C F', F2 = and C F') -> false
============================
and Clause Formula = F2 -> false
< intros E.
Subgoal 2.2:
Variables: F2 Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula F2
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
N : (exists C F', F2 = and C F') -> false
E : and Clause Formula = F2
============================
false
< case E.
Subgoal 2.2:
Variables: Formula Clause
IH : forall F1 F2,
is_formula F1 * -> is_formula F2 -> F1 = F2 \/ (F1 = F2 -> false)
IsF1 : is_formula (and Clause Formula) @
IsF2 : is_formula (and Clause Formula)
IsF3 : is_clause Clause
IsF4 : is_formula Formula *
N : (exists C F', and Clause Formula = and C F') -> false
============================
false
< backchain N.
Proof completed.
< Theorem is_list_integer_eq_or_not :
forall L1 L2,
is_list is_integer L1 -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false).
============================
forall L1 L2,
is_list is_integer L1 -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
< induction on 1.
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
============================
forall L1 L2,
is_list is_integer L1 @ -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
< intros IsL1 IsL2.
Variables: L1 L2
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
IsL1 : is_list is_integer L1 @
IsL2 : is_list is_integer L2
============================
L1 = L2 \/ (L1 = L2 -> false)
< Is: case IsL1.
Subgoal 1:
Variables: L2
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
IsL2 : is_list is_integer L2
============================
[] = L2 \/ ([] = L2 -> false)
< Is': case IsL2.
Subgoal 1.1:
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
============================
[] = [] \/ ([] = [] -> false)
< search.
Subgoal 1.2:
Variables: T H
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is' : is_integer H
Is'1 : is_list is_integer T
============================
[] = H::T \/ ([] = H::T -> false)
< search.
Subgoal 2:
Variables: L2 T H
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
IsL2 : is_list is_integer L2
Is : is_integer H
Is1 : is_list is_integer T *
============================
H::T = L2 \/ (H::T = L2 -> false)
< Is': case IsL2.
Subgoal 2.1:
Variables: T H
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
============================
H::T = [] \/ (H::T = [] -> false)
< search.
Subgoal 2.2:
Variables: T H T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
============================
H::T = H1::T1 \/ (H::T = H1::T1 -> false)
< Or: apply is_integer_eq_or_not to Is Is'.
Subgoal 2.2:
Variables: T H T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
Or : H = H1 \/ (H = H1 -> false)
============================
H::T = H1::T1 \/ (H::T = H1::T1 -> false)
< N: case Or.
Subgoal 2.2.1:
Variables: T T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
============================
H1::T = H1::T1 \/ (H1::T = H1::T1 -> false)
< Or: apply IH to Is1 Is'1.
Subgoal 2.2.1:
Variables: T T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
Or : T = T1 \/ (T = T1 -> false)
============================
H1::T = H1::T1 \/ (H1::T = H1::T1 -> false)
< N: case Or.
Subgoal 2.2.1.1:
Variables: T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T1 *
Is' : is_integer H1
Is'1 : is_list is_integer T1
============================
H1::T1 = H1::T1 \/ (H1::T1 = H1::T1 -> false)
< search.
Subgoal 2.2.1.2:
Variables: T T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : T = T1 -> false
============================
H1::T = H1::T1 \/ (H1::T = H1::T1 -> false)
< right.
Subgoal 2.2.1.2:
Variables: T T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : T = T1 -> false
============================
H1::T = H1::T1 -> false
< intros E.
Subgoal 2.2.1.2:
Variables: T T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : T = T1 -> false
E : H1::T = H1::T1
============================
false
< case E.
Subgoal 2.2.1.2:
Variables: T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T1 *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : T1 = T1 -> false
============================
false
< backchain N.
Subgoal 2.2.2:
Variables: T H T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : H = H1 -> false
============================
H::T = H1::T1 \/ (H::T = H1::T1 -> false)
< right.
Subgoal 2.2.2:
Variables: T H T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : H = H1 -> false
============================
H::T = H1::T1 -> false
< intros E.
Subgoal 2.2.2:
Variables: T H T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H
Is1 : is_list is_integer T *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : H = H1 -> false
E : H::T = H1::T1
============================
false
< case E.
Subgoal 2.2.2:
Variables: T1 H1
IH : forall L1 L2,
is_list is_integer L1 * -> is_list is_integer L2 -> L1 = L2 \/
(L1 = L2 -> false)
Is : is_integer H1
Is1 : is_list is_integer T1 *
Is' : is_integer H1
Is'1 : is_list is_integer T1
N : H1 = H1 -> false
============================
false
< backchain N.
Proof completed.
< Theorem lookup_after_select :
forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known ->
lookup KRest ID' C' -> lookup Known ID' C'.
============================
forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known ->
lookup KRest ID' C' -> lookup Known ID' C'
< induction on 4.
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
============================
forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known @ ->
lookup KRest ID' C' -> lookup Known ID' C'
< intros IsK IsID' GCL Slct Lkp.
Variables: Known ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsK : is_list (is_pair is_integer is_clause) Known
IsID' : is_integer ID'
GCL : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Slct : select (ID, C) KRest Known @
Lkp : lookup KRest ID' C'
============================
lookup Known ID' C'
< Slct: case Slct.
Subgoal 1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsK : is_list (is_pair is_integer is_clause) ((ID, C)::KRest)
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
============================
lookup ((ID, C)::KRest) ID' C'
< Is: case IsK.
Subgoal 1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is : is_pair is_integer is_clause (ID, C)
Is1 : is_list (is_pair is_integer is_clause) KRest
============================
lookup ((ID, C)::KRest) ID' C'
< Is: case Is.
Subgoal 1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
============================
lookup ((ID, C)::KRest) ID' C'
< Or: apply is_integer_eq_or_not to IsID' Is.
Subgoal 1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
Or : ID' = ID \/ (ID' = ID -> false)
============================
lookup ((ID, C)::KRest) ID' C'
< Eq: case Or.
Subgoal 1.1:
Variables: ID C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
============================
lookup ((ID, C)::KRest) ID C'
< M1: apply lookup_mem to Lkp.
Subgoal 1.1:
Variables: ID C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
M1 : mem (ID, C') KRest
============================
lookup ((ID, C)::KRest) ID C'
< M2: assert mem (ID, C') ((ID, C)::KRest).
Subgoal 1.1:
Variables: ID C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
M1 : mem (ID, C') KRest
M2 : mem (ID, C') ((ID, C)::KRest)
============================
lookup ((ID, C)::KRest) ID C'
< M3: assert mem (ID, C) ((ID, C)::KRest).
Subgoal 1.1:
Variables: ID C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
M1 : mem (ID, C') KRest
M2 : mem (ID, C') ((ID, C)::KRest)
M3 : mem (ID, C) ((ID, C)::KRest)
============================
lookup ((ID, C)::KRest) ID C'
< apply GCL to M2 M3.
Subgoal 1.1:
Variables: ID C KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID C
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
M1 : mem (ID, C) KRest
M2 : mem (ID, C) ((ID, C)::KRest)
M3 : mem (ID, C) ((ID, C)::KRest)
============================
lookup ((ID, C)::KRest) ID C
< search.
Subgoal 1.2:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
Eq : ID' = ID -> false
============================
lookup ((ID, C)::KRest) ID' C'
< unfold .
Subgoal 1.2.1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
Eq : ID' = ID -> false
============================
ID = ID' -> false
< intros E.
Subgoal 1.2.1:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
Eq : ID' = ID -> false
E : ID = ID'
============================
false
< case E.
Subgoal 1.2.1:
Variables: ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID', C)::KRest) -> mem (I, C2) ((ID', C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID'
Is2 : is_clause C
Eq : ID' = ID' -> false
============================
false
< backchain Eq.
Subgoal 1.2.2:
Variables: ID ID' C C' KRest
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I C1 C2,
mem (I, C1) ((ID, C)::KRest) -> mem (I, C2) ((ID, C)::KRest) -> C1 = C2
Lkp : lookup KRest ID' C'
Is1 : is_list (is_pair is_integer is_clause) KRest
Is : is_integer ID
Is2 : is_clause C
Eq : ID' = ID -> false
============================
lookup KRest ID' C'
< search.
Subgoal 2:
Variables: ID ID' C C' L2 I L1
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsK : is_list (is_pair is_integer is_clause) (I::L2)
IsID' : is_integer ID'
GCL : forall I1 C1 C2, mem (I1, C1) (I::L2) -> mem (I1, C2) (I::L2) -> C1 = C2
Lkp : lookup (I::L1) ID' C'
Slct : select (ID, C) L1 L2 *
============================
lookup (I::L2) ID' C'
< Is: case IsK.
Subgoal 2:
Variables: ID ID' C C' L2 I L1
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2, mem (I1, C1) (I::L2) -> mem (I1, C2) (I::L2) -> C1 = C2
Lkp : lookup (I::L1) ID' C'
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) L2
============================
lookup (I::L2) ID' C'
< Lkp: case Lkp.
Subgoal 2.1:
Variables: ID ID' C C' L2 L1
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((ID', C')::L2) -> mem (I1, C2) ((ID', C')::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (ID', C')
Is1 : is_list (is_pair is_integer is_clause) L2
============================
lookup ((ID', C')::L2) ID' C'
< search.
Subgoal 2.2:
Variables: ID ID' C C' L2 L1 V K
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
============================
lookup ((K, V)::L2) ID' C'
< assert forall I C1 C2,
mem (I, C1) L2 -> mem (I, C2) L2 -> C1 = C2.
Subgoal 2.2.1:
Variables: ID ID' C C' L2 L1 V K
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
============================
forall I C1 C2, mem (I, C1) L2 -> mem (I, C2) L2 -> C1 = C2
< intros MA MB.
Subgoal 2.2.1:
Variables: ID ID' C C' L2 L1 V K I1 C1 C2
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
MA : mem (I1, C1) L2
MB : mem (I1, C2) L2
============================
C1 = C2
< MA': assert mem (I1, C1) ((K, V)::L2).
Subgoal 2.2.1:
Variables: ID ID' C C' L2 L1 V K I1 C1 C2
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
MA : mem (I1, C1) L2
MB : mem (I1, C2) L2
MA' : mem (I1, C1) ((K, V)::L2)
============================
C1 = C2
< MB': assert mem (I1, C2) ((K, V)::L2).
Subgoal 2.2.1:
Variables: ID ID' C C' L2 L1 V K I1 C1 C2
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
MA : mem (I1, C1) L2
MB : mem (I1, C2) L2
MA' : mem (I1, C1) ((K, V)::L2)
MB' : mem (I1, C2) ((K, V)::L2)
============================
C1 = C2
< apply GCL to MA' MB'.
Subgoal 2.2.1:
Variables: ID ID' C C' L2 L1 V K I1 C2
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
MA : mem (I1, C2) L2
MB : mem (I1, C2) L2
MA' : mem (I1, C2) ((K, V)::L2)
MB' : mem (I1, C2) ((K, V)::L2)
============================
C2 = C2
< search.
Subgoal 2.2:
Variables: ID ID' C C' L2 L1 V K
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
H1 : forall I C1 C2, mem (I, C1) L2 -> mem (I, C2) L2 -> C1 = C2
============================
lookup ((K, V)::L2) ID' C'
< apply IH to Is1 IsID' _ Slct Lkp1.
Subgoal 2.2:
Variables: ID ID' C C' L2 L1 V K
IH : forall Known ID ID' C C' KRest,
is_list (is_pair is_integer is_clause) Known -> is_integer ID' -> (forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2) -> select (ID, C) KRest Known * ->
lookup KRest ID' C' -> lookup Known ID' C'
IsID' : is_integer ID'
GCL : forall I1 C1 C2,
mem (I1, C1) ((K, V)::L2) -> mem (I1, C2) ((K, V)::L2) -> C1 = C2
Slct : select (ID, C) L1 L2 *
Is : is_pair is_integer is_clause (K, V)
Is1 : is_list (is_pair is_integer is_clause) L2
Lkp : K = ID' -> false
Lkp1 : lookup L1 ID' C'
H1 : forall I C1 C2, mem (I, C1) L2 -> mem (I, C2) L2 -> C1 = C2
H2 : lookup L2 ID' C'
============================
lookup ((K, V)::L2) ID' C'
< search.
Proof completed.
< Theorem mem_is :
forall Known (IDC : pair integer clause),
is_list (is_pair is_integer is_clause) Known -> mem IDC Known -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C.
============================
forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< induction on 2.
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
============================
forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known @ -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< intros Is Mem.
Variables: Known IDC
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Is : is_list (is_pair is_integer is_clause) Known
Mem : mem IDC Known @
============================
exists ID C, (IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< Mem: case Mem.
Subgoal 1:
Variables: IDC Rest
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Is : is_list (is_pair is_integer is_clause) (IDC::Rest)
============================
exists ID C, (IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< Is: case Is.
Subgoal 1:
Variables: IDC Rest
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Is : is_pair is_integer is_clause IDC
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
exists ID C, (IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< case Is.
Subgoal 1:
Variables: Rest B A
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_integer A
H2 : is_clause B
============================
exists ID C, ((A, B) = (ID, C) /\ is_integer ID) /\ is_clause C
< search.
Subgoal 2:
Variables: IDC Rest I
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Is : is_list (is_pair is_integer is_clause) (I::Rest)
Mem : mem IDC Rest *
============================
exists ID C, (IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< Is: case Is.
Subgoal 2:
Variables: IDC Rest I
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Mem : mem IDC Rest *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
exists ID C, (IDC = (ID, C) /\ is_integer ID) /\ is_clause C
< apply IH to _ Mem.
Subgoal 2:
Variables: Rest I ID C
IH : forall Known IDC,
is_list (is_pair is_integer is_clause) Known -> mem IDC Known * -> exists ID C,
(IDC = (ID, C) /\ is_integer ID) /\ is_clause C
Mem : mem (ID, C) Rest *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_integer ID
H2 : is_clause C
============================
exists ID1 C1, ((ID, C) = (ID1, C1) /\ is_integer ID1) /\ is_clause C1
< search.
Proof completed.
< Theorem mem_is_lit :
forall Assignment L,
is_list is_lit Assignment -> mem L Assignment -> is_lit L.
============================
forall Assignment L, is_list is_lit Assignment -> mem L Assignment -> is_lit L
< induction on 2.
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
============================
forall Assignment L,
is_list is_lit Assignment -> mem L Assignment @ -> is_lit L
< intros Is Mem.
Variables: Assignment L
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Is : is_list is_lit Assignment
Mem : mem L Assignment @
============================
is_lit L
< Mem: case Mem.
Subgoal 1:
Variables: L Rest
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Is : is_list is_lit (L::Rest)
============================
is_lit L
< Is: case Is.
Subgoal 1:
Variables: L Rest
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Is : is_lit L
Is1 : is_list is_lit Rest
============================
is_lit L
< search.
Subgoal 2:
Variables: L Rest I
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Is : is_list is_lit (I::Rest)
Mem : mem L Rest *
============================
is_lit L
< Is: case Is.
Subgoal 2:
Variables: L Rest I
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Mem : mem L Rest *
Is : is_lit I
Is1 : is_list is_lit Rest
============================
is_lit L
< apply IH to _ Mem.
Subgoal 2:
Variables: L Rest I
IH : forall Assignment L,
is_list is_lit Assignment -> mem L Assignment * -> is_lit L
Mem : mem L Rest *
Is : is_lit I
Is1 : is_list is_lit Rest
H1 : is_lit L
============================
is_lit L
< search.
Proof completed.
< Theorem select_is :
forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known ->
is_list (is_pair is_integer is_clause) KRest.
============================
forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known -> is_list (is_pair is_integer is_clause) KRest
< induction on 2.
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
============================
forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known @ -> is_list (is_pair is_integer is_clause) KRest
< intros Is Slct.
Variables: Known KRest IDC
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) Known
Slct : select IDC KRest Known @
============================
is_list (is_pair is_integer is_clause) KRest
< Slct: case Slct.
Subgoal 1:
Variables: KRest IDC
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) (IDC::KRest)
============================
is_list (is_pair is_integer is_clause) KRest
< case Is.
Subgoal 1:
Variables: KRest IDC
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
H1 : is_pair is_integer is_clause IDC
H2 : is_list (is_pair is_integer is_clause) KRest
============================
is_list (is_pair is_integer is_clause) KRest
< search.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) (I::L2)
Slct : select IDC L1 L2 *
============================
is_list (is_pair is_integer is_clause) (I::L1)
< Is: case Is.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
Slct : select IDC L1 L2 *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) L2
============================
is_list (is_pair is_integer is_clause) (I::L1)
< apply IH to _ Slct.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_list (is_pair is_integer is_clause) KRest
Slct : select IDC L1 L2 *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) L2
H1 : is_list (is_pair is_integer is_clause) L1
============================
is_list (is_pair is_integer is_clause) (I::L1)
< search.
Proof completed.
< Theorem select_is_picked :
forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known ->
is_pair is_integer is_clause IDC.
============================
forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known -> is_pair is_integer is_clause IDC
< induction on 2.
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
============================
forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known @ -> is_pair is_integer is_clause IDC
< intros Is Slct.
Variables: Known IDC KRest
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
Is : is_list (is_pair is_integer is_clause) Known
Slct : select IDC KRest Known @
============================
is_pair is_integer is_clause IDC
< Slct: case Slct.
Subgoal 1:
Variables: IDC KRest
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
Is : is_list (is_pair is_integer is_clause) (IDC::KRest)
============================
is_pair is_integer is_clause IDC
< case Is.
Subgoal 1:
Variables: IDC KRest
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
H1 : is_pair is_integer is_clause IDC
H2 : is_list (is_pair is_integer is_clause) KRest
============================
is_pair is_integer is_clause IDC
< search.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
Is : is_list (is_pair is_integer is_clause) (I::L2)
Slct : select IDC L1 L2 *
============================
is_pair is_integer is_clause IDC
< case Is.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
Slct : select IDC L1 L2 *
H1 : is_pair is_integer is_clause I
H2 : is_list (is_pair is_integer is_clause) L2
============================
is_pair is_integer is_clause IDC
< apply IH to _ Slct.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known IDC KRest,
is_list (is_pair is_integer is_clause) Known -> select IDC KRest Known * ->
is_pair is_integer is_clause IDC
Slct : select IDC L1 L2 *
H1 : is_pair is_integer is_clause I
H2 : is_list (is_pair is_integer is_clause) L2
H3 : is_pair is_integer is_clause IDC
============================
is_pair is_integer is_clause IDC
< search.
Proof completed.
< Theorem is_list_lit_mem_or_not :
forall A L, is_list is_lit A -> is_lit L -> mem L A \/ (mem L A -> false).
============================
forall A L, is_list is_lit A -> is_lit L -> mem L A \/ (mem L A -> false)
< induction on 1.
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
============================
forall A L, is_list is_lit A @ -> is_lit L -> mem L A \/ (mem L A -> false)
< intros IsA IsL.
Variables: A L
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsA : is_list is_lit A @
IsL : is_lit L
============================
mem L A \/ (mem L A -> false)
< IsA: case IsA.
Subgoal 1:
Variables: L
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
============================
mem L [] \/ (mem L [] -> false)
< right.
Subgoal 1:
Variables: L
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
============================
mem L [] -> false
< intros M.
Subgoal 1:
Variables: L
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
M : mem L []
============================
false
< case M.
Subgoal 2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< Or: apply is_lit_eq_or_not to IsL IsA.
Subgoal 2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
Or : L = H \/ (L = H -> false)
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< EqL: case Or.
Subgoal 2.1:
Variables: T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit H
IsA : is_lit H
IsA1 : is_list is_lit T *
============================
mem H (H::T) \/ (mem H (H::T) -> false)
< search.
Subgoal 2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< Or: apply IH to IsA1 IsL.
Subgoal 2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
Or : mem L T \/ (mem L T -> false)
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< MemRest: case Or.
Subgoal 2.2.1:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
MemRest : mem L T
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< search.
Subgoal 2.2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
MemRest : mem L T -> false
============================
mem L (H::T) \/ (mem L (H::T) -> false)
< right.
Subgoal 2.2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
MemRest : mem L T -> false
============================
mem L (H::T) -> false
< intros Mem.
Subgoal 2.2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
MemRest : mem L T -> false
Mem : mem L (H::T)
============================
false
< Mem: case Mem.
Subgoal 2.2.2.1:
Variables: T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit H
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : H = H -> false
MemRest : mem H T -> false
============================
false
< backchain EqL.
Subgoal 2.2.2.2:
Variables: L T H
IH : forall A L, is_list is_lit A * -> is_lit L -> mem L A \/ (mem L A -> false)
IsL : is_lit L
IsA : is_lit H
IsA1 : is_list is_lit T *
EqL : L = H -> false
MemRest : mem L T -> false
Mem : mem L T
============================
false
< backchain MemRest.
Proof completed.
< Theorem is_list_lit_subset_or_not :
forall A B,
is_list is_lit A -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false)).
============================
forall A B,
is_list is_lit A -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
< induction on 1.
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
============================
forall A B,
is_list is_lit A @ -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
< intros IsA IsB.
Variables: A B
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsA : is_list is_lit A @
IsB : is_list is_lit B
============================
(forall X, mem X A -> mem X B) \/ (exists X, mem X A /\ (mem X B -> false))
< IsA: case IsA.
Subgoal 1:
Variables: B
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
============================
(forall X, mem X [] -> mem X B) \/ (exists X, mem X [] /\ (mem X B -> false))
< left.
Subgoal 1:
Variables: B
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
============================
forall X, mem X [] -> mem X B
< intros M.
Subgoal 1:
Variables: B X
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
M : mem X []
============================
mem X B
< case M.
Subgoal 2:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< Or: apply is_list_lit_mem_or_not to IsB IsA.
Subgoal 2:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
Or : mem H B \/ (mem H B -> false)
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< M: case Or.
Subgoal 2.1:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< Or: apply IH to IsA1 IsB.
Subgoal 2.1:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Or : (forall X, mem X T -> mem X B) \/ (exists X, mem X T /\ (mem X B -> false))
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< Sub: case Or.
Subgoal 2.1.1:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : forall X, mem X T -> mem X B
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< left.
Subgoal 2.1.1:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : forall X, mem X T -> mem X B
============================
forall X, mem X (H::T) -> mem X B
< intros Mem.
Subgoal 2.1.1:
Variables: B T H X
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : forall X, mem X T -> mem X B
Mem : mem X (H::T)
============================
mem X B
< Mem: case Mem.
Subgoal 2.1.1.1:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : forall X, mem X T -> mem X B
============================
mem H B
< search.
Subgoal 2.1.1.2:
Variables: B T H X
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : forall X, mem X T -> mem X B
Mem : mem X T
============================
mem X B
< backchain Sub.
Subgoal 2.1.2:
Variables: B T H X
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : mem X T
Sub1 : mem X B -> false
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< right.
Subgoal 2.1.2:
Variables: B T H X
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B
Sub : mem X T
Sub1 : mem X B -> false
============================
exists X, mem X (H::T) /\ (mem X B -> false)
< search.
Subgoal 2.2:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B -> false
============================
(forall X, mem X (H::T) -> mem X B) \/
(exists X, mem X (H::T) /\ (mem X B -> false))
< right.
Subgoal 2.2:
Variables: B T H
IH : forall A B,
is_list is_lit A * -> is_list is_lit B -> (forall X, mem X A -> mem X B) \/
(exists X, mem X A /\ (mem X B -> false))
IsB : is_list is_lit B
IsA : is_lit H
IsA1 : is_list is_lit T *
M : mem H B -> false
============================
exists X, mem X (H::T) /\ (mem X B -> false)
< search.
Proof completed.
< Theorem is_list_mem_lookup :
forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known -> is_integer ID ->
exists C', lookup Known ID C'.
============================
forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known -> is_integer ID ->
exists C', lookup Known ID C'
< induction on 2.
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
============================
forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known @ -> is_integer ID ->
exists C', lookup Known ID C'
< intros IsK Mem IsID.
Variables: Known ID C
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsK : is_list (is_pair is_integer is_clause) Known
Mem : mem (ID, C) Known @
IsID : is_integer ID
============================
exists C', lookup Known ID C'
< Mem: case Mem.
Subgoal 1:
Variables: ID C Rest
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsK : is_list (is_pair is_integer is_clause) ((ID, C)::Rest)
IsID : is_integer ID
============================
exists C', lookup ((ID, C)::Rest) ID C'
< search.
Subgoal 2:
Variables: ID C Rest I
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsK : is_list (is_pair is_integer is_clause) (I::Rest)
IsID : is_integer ID
Mem : mem (ID, C) Rest *
============================
exists C', lookup (I::Rest) ID C'
< Is: case IsK.
Subgoal 2:
Variables: ID C Rest I
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is : is_pair is_integer is_clause I
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
exists C', lookup (I::Rest) ID C'
< Is: case Is.
Subgoal 2:
Variables: ID C Rest B A
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is1 : is_list (is_pair is_integer is_clause) Rest
Is : is_integer A
Is2 : is_clause B
============================
exists C', lookup ((A, B)::Rest) ID C'
< Or: apply is_integer_eq_or_not to Is IsID.
Subgoal 2:
Variables: ID C Rest B A
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is1 : is_list (is_pair is_integer is_clause) Rest
Is : is_integer A
Is2 : is_clause B
Or : A = ID \/ (A = ID -> false)
============================
exists C', lookup ((A, B)::Rest) ID C'
< Eq: case Or.
Subgoal 2.1:
Variables: ID C Rest B
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is1 : is_list (is_pair is_integer is_clause) Rest
Is : is_integer ID
Is2 : is_clause B
============================
exists C', lookup ((ID, B)::Rest) ID C'
< search.
Subgoal 2.2:
Variables: ID C Rest B A
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is1 : is_list (is_pair is_integer is_clause) Rest
Is : is_integer A
Is2 : is_clause B
Eq : A = ID -> false
============================
exists C', lookup ((A, B)::Rest) ID C'
< apply IH to Is1 Mem IsID.
Subgoal 2.2:
Variables: ID C Rest B A C'
IH : forall Known ID C,
is_list (is_pair is_integer is_clause) Known -> mem (ID, C) Known * -> is_integer ID ->
exists C', lookup Known ID C'
IsID : is_integer ID
Mem : mem (ID, C) Rest *
Is1 : is_list (is_pair is_integer is_clause) Rest
Is : is_integer A
Is2 : is_clause B
Eq : A = ID -> false
H1 : lookup Rest ID C'
============================
exists C', lookup ((A, B)::Rest) ID C'
< search.
Proof completed.
< Theorem lookup_is_value :
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C -> is_clause C.
============================
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C -> is_clause C
< induction on 2.
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
============================
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C @ -> is_clause C
< intros IsK Lkp.
Variables: K ID C
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
IsK : is_list (is_pair is_integer is_clause) K
Lkp : lookup K ID C @
============================
is_clause C
< Lkp: case Lkp.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
IsK : is_list (is_pair is_integer is_clause) ((ID, C)::Rest)
============================
is_clause C
< Is: case IsK.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
Is : is_pair is_integer is_clause (ID, C)
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
is_clause C
< case Is.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_integer ID
H2 : is_clause C
============================
is_clause C
< search.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
IsK : is_list (is_pair is_integer is_clause) ((K1, V)::Rest)
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
============================
is_clause C
< Is: case IsK.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
Is : is_pair is_integer is_clause (K1, V)
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
is_clause C
< apply IH to Is1 Lkp1.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_clause C
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
Is : is_pair is_integer is_clause (K1, V)
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_clause C
============================
is_clause C
< search.
Proof completed.
< Theorem lookup_is_key :
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C -> is_integer ID.
============================
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C -> is_integer ID
< induction on 2.
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
============================
forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C @ -> is_integer ID
< intros IsK Lkp.
Variables: K ID C
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
IsK : is_list (is_pair is_integer is_clause) K
Lkp : lookup K ID C @
============================
is_integer ID
< Lkp: case Lkp.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
IsK : is_list (is_pair is_integer is_clause) ((ID, C)::Rest)
============================
is_integer ID
< Is: case IsK.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
Is : is_pair is_integer is_clause (ID, C)
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
is_integer ID
< case Is.
Subgoal 1:
Variables: ID C Rest
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_integer ID
H2 : is_clause C
============================
is_integer ID
< search.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
IsK : is_list (is_pair is_integer is_clause) ((K1, V)::Rest)
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
============================
is_integer ID
< Is: case IsK.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
Is : is_pair is_integer is_clause (K1, V)
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
is_integer ID
< apply IH to Is1 Lkp1.
Subgoal 2:
Variables: ID C Rest V K1
IH : forall K ID C,
is_list (is_pair is_integer is_clause) K -> lookup K ID C * -> is_integer ID
Lkp : K1 = ID -> false
Lkp1 : lookup Rest ID C *
Is : is_pair is_integer is_clause (K1, V)
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_integer ID
============================
is_integer ID
< search.
Proof completed.
< Theorem is_pair_eq_or_not :
forall (PB : pair integer clause) (PA : pair integer clause),
is_pair is_integer is_clause PA -> is_pair is_integer is_clause PB -> PA = PB \/
(PA = PB -> false).
============================
forall PB PA,
is_pair is_integer is_clause PA -> is_pair is_integer is_clause PB -> PA = PB \/
(PA = PB -> false)
< intros IsPA IsPB.
Variables: PB PA
IsPA : is_pair is_integer is_clause PA
IsPB : is_pair is_integer is_clause PB
============================
PA = PB \/ (PA = PB -> false)
< IsA: case IsPA.
Variables: PB B A
IsPB : is_pair is_integer is_clause PB
IsA : is_integer A
IsA1 : is_clause B
============================
(A, B) = PB \/ ((A, B) = PB -> false)
< IsB: case IsPB.
Variables: B A B1 A1
IsA : is_integer A
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
============================
(A, B) = (A1, B1) \/ ((A, B) = (A1, B1) -> false)
< Or: apply is_integer_eq_or_not to IsA IsB.
Variables: B A B1 A1
IsA : is_integer A
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Or : A = A1 \/ (A = A1 -> false)
============================
(A, B) = (A1, B1) \/ ((A, B) = (A1, B1) -> false)
< Eq: case Or.
Subgoal 1:
Variables: B B1 A1
IsA : is_integer A1
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
============================
(A1, B) = (A1, B1) \/ ((A1, B) = (A1, B1) -> false)
< Or: apply is_clause_eq_or_not to IsA1 IsB1.
Subgoal 1:
Variables: B B1 A1
IsA : is_integer A1
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Or : B = B1 \/ (B = B1 -> false)
============================
(A1, B) = (A1, B1) \/ ((A1, B) = (A1, B1) -> false)
< Eq: case Or.
Subgoal 1.1:
Variables: B1 A1
IsA : is_integer A1
IsA1 : is_clause B1
IsB : is_integer A1
IsB1 : is_clause B1
============================
(A1, B1) = (A1, B1) \/ ((A1, B1) = (A1, B1) -> false)
< search.
Subgoal 1.2:
Variables: B B1 A1
IsA : is_integer A1
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : B = B1 -> false
============================
(A1, B) = (A1, B1) \/ ((A1, B) = (A1, B1) -> false)
< right.
Subgoal 1.2:
Variables: B B1 A1
IsA : is_integer A1
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : B = B1 -> false
============================
(A1, B) = (A1, B1) -> false
< intros E.
Subgoal 1.2:
Variables: B B1 A1
IsA : is_integer A1
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : B = B1 -> false
E : (A1, B) = (A1, B1)
============================
false
< case E.
Subgoal 1.2:
Variables: B1 A1
IsA : is_integer A1
IsA1 : is_clause B1
IsB : is_integer A1
IsB1 : is_clause B1
Eq : B1 = B1 -> false
============================
false
< backchain Eq.
Subgoal 2:
Variables: B A B1 A1
IsA : is_integer A
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : A = A1 -> false
============================
(A, B) = (A1, B1) \/ ((A, B) = (A1, B1) -> false)
< right.
Subgoal 2:
Variables: B A B1 A1
IsA : is_integer A
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : A = A1 -> false
============================
(A, B) = (A1, B1) -> false
< intros E.
Subgoal 2:
Variables: B A B1 A1
IsA : is_integer A
IsA1 : is_clause B
IsB : is_integer A1
IsB1 : is_clause B1
Eq : A = A1 -> false
E : (A, B) = (A1, B1)
============================
false
< case E.
Subgoal 2:
Variables: B1 A1
IsA : is_integer A1
IsA1 : is_clause B1
IsB : is_integer A1
IsB1 : is_clause B1
Eq : A1 = A1 -> false
============================
false
< backchain Eq.
Proof completed.
< Theorem is_count_exists :
forall L IDC,
is_list (is_pair is_integer is_clause) L -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N.
============================
forall L IDC,
is_list (is_pair is_integer is_clause) L -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
< induction on 1.
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
============================
forall L IDC,
is_list (is_pair is_integer is_clause) L @ -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
< intros IsL IsIDC.
Variables: L IDC
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsL : is_list (is_pair is_integer is_clause) L @
IsIDC : is_pair is_integer is_clause IDC
============================
exists N, count IDC L N
< Is: case IsL.
Subgoal 1:
Variables: IDC
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause IDC
============================
exists N, count IDC [] N
< search.
Subgoal 2:
Variables: IDC T H
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause IDC
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
============================
exists N, count IDC (H::T) N
< Or: apply is_pair_eq_or_not to IsIDC Is.
Subgoal 2:
Variables: IDC T H
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause IDC
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
Or : IDC = H \/ (IDC = H -> false)
============================
exists N, count IDC (H::T) N
< C: apply IH to Is1 IsIDC.
Subgoal 2:
Variables: IDC T H N
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause IDC
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
Or : IDC = H \/ (IDC = H -> false)
C : count IDC T N
============================
exists N, count IDC (H::T) N
< Eq: case Or.
Subgoal 2.1:
Variables: T H N
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause H
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
C : count H T N
============================
exists N, count H (H::T) N
< IsN: apply count_is_integer to C.
Subgoal 2.1:
Variables: T H N
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause H
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
C : count H T N
IsN : is_integer N
============================
exists N, count H (H::T) N
< apply plus_integer_total to _ IsN with
N1 = 1.
Subgoal 2.1:
Variables: T H N N3
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause H
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
C : count H T N
IsN : is_integer N
H1 : 1 + N = N3
============================
exists N, count H (H::T) N
< search.
Subgoal 2.2:
Variables: IDC T H N
IH : forall L IDC,
is_list (is_pair is_integer is_clause) L * -> is_pair is_integer is_clause IDC ->
exists N, count IDC L N
IsIDC : is_pair is_integer is_clause IDC
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
C : count IDC T N
Eq : IDC = H -> false
============================
exists N, count IDC (H::T) N
< search.
Proof completed.
< Theorem all_count_0_nil :
forall L,
is_list (is_pair is_integer is_clause) L -> (forall X N,
count X L N -> N = 0) -> L = [].
============================
forall L,
is_list (is_pair is_integer is_clause) L -> (forall X N,
count X L N -> N = 0) -> L = []
< intros IsL Count0.
Variables: L
IsL : is_list (is_pair is_integer is_clause) L
Count0 : forall X N, count X L N -> N = 0
============================
L = []
< Is: case IsL.
Subgoal 1:
Count0 : forall X N, count X [] N -> N = 0
============================
[] = []
< search.
Subgoal 2:
Variables: T H
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
============================
H::T = []
< C: apply is_count_exists to Is1 Is.
Subgoal 2:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
============================
H::T = []
< IsN: apply count_is_integer to C.
Subgoal 2:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
============================
H::T = []
< P: apply plus_integer_total to _ IsN with
N1 = 1.
Subgoal 2:
Variables: T H N N3
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = N3
============================
H::T = []
< C': assert count H (H::T) N3.
Subgoal 2:
Variables: T H N N3
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = N3
C' : count H (H::T) N3
============================
H::T = []
< apply Count0 to C'.
Subgoal 2:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
============================
H::T = []
< GEq: apply count_geq_0 to C.
Subgoal 2:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
GEq : N >= 0
============================
H::T = []
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
GEq : N >= 0
Or : N > 0 \/ N = 0
============================
H::T = []
< L: case Or.
Subgoal 2.1:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
GEq : N >= 0
L : N > 0
============================
H::T = []
< G: apply greater_plus_positive to _ _ P _.
Subgoal 2.1:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
GEq : N >= 0
L : N > 0
G : 0 > 1
============================
H::T = []
< L': assert 0 < 1.
Subgoal 2.1:
Variables: T H N
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T N
IsN : is_integer N
P : 1 + N = 0
C' : count H (H::T) 0
GEq : N >= 0
L : N > 0
G : 0 > 1
L' : 0 < 1
============================
H::T = []
< apply greater_less_impossible to G L'.
Subgoal 2.2:
Variables: T H
Count0 : forall X N, count X (H::T) N -> N = 0
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T
C : count H T 0
IsN : is_integer 0
P : 1 + 0 = 0
C' : count H (H::T) 0
GEq : 0 >= 0
============================
H::T = []
< case P.
Proof completed.
< Theorem counts_permutation :
forall L P,
is_list (is_pair is_integer is_clause) L -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P.
============================
forall L P,
is_list (is_pair is_integer is_clause) L -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
< induction on 1.
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
============================
forall L P,
is_list (is_pair is_integer is_clause) L @ -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
< intros IsL IsP Same.
Variables: L P
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) L @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP
============================
permutation L P
< Is: case IsL (keep).
Subgoal 1:
Variables: P
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X P NP -> NL = NP
============================
permutation [] P
< IsP': case IsP (keep).
Subgoal 1.1:
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) []
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X [] NP -> NL = NP
============================
permutation [] []
< search.
Subgoal 1.2:
Variables: T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
============================
permutation [] (H::T)
< CL: assert count H [] 0.
Subgoal 1.2:
Variables: T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
============================
permutation [] (H::T)
< CP: apply is_count_exists to IsP IsP'.
Subgoal 1.2:
Variables: T H N
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H (H::T) N
============================
permutation [] (H::T)
< apply Same to _ CL CP.
Subgoal 1.2:
Variables: T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H (H::T) 0
============================
permutation [] (H::T)
< CP: case CP.
Subgoal 1.2.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
============================
permutation [] (H::T)
< GEq: apply count_geq_0 to CP.
Subgoal 1.2.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
============================
permutation [] (H::T)
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 1.2.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
Or : N1 > 0 \/ N1 = 0
============================
permutation [] (H::T)
< E: case Or.
Subgoal 1.2.1.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
E : N1 > 0
============================
permutation [] (H::T)
< IsN1: apply count_is_integer to CP.
Subgoal 1.2.1.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
E : N1 > 0
IsN1 : is_integer N1
============================
permutation [] (H::T)
< G: apply greater_plus_positive to _ _ CP1 _.
Subgoal 1.2.1.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
E : N1 > 0
IsN1 : is_integer N1
G : 0 > 1
============================
permutation [] (H::T)
< L: assert 0 < 1.
Subgoal 1.2.1.1:
Variables: T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T N1
CP1 : 1 + N1 = 0
GEq : N1 >= 0
E : N1 > 0
IsN1 : is_integer N1
G : 0 > 1
L : 0 < 1
============================
permutation [] (H::T)
< apply greater_less_impossible to G L.
Subgoal 1.2.1.2:
Variables: T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : count H T 0
CP1 : 1 + 0 = 0
GEq : 0 >= 0
============================
permutation [] (H::T)
< case CP1.
Subgoal 1.2.2:
Variables: T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) [] @
IsP : is_list (is_pair is_integer is_clause) (H::T)
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X [] NL -> count X (H::T) NP ->
NL = NP
IsP' : is_pair is_integer is_clause H
IsP'1 : is_list (is_pair is_integer is_clause) T
CL : count H [] 0
CP : H = H -> false
CP1 : count H T 0
============================
permutation [] (H::T)
< apply CP to _.
Subgoal 2:
Variables: P T H
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
============================
permutation (H::T) P
< CLH: apply is_count_exists to IsL Is.
Subgoal 2:
Variables: P T H N
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N
============================
permutation (H::T) P
< CPH: apply is_count_exists to IsP Is.
Subgoal 2:
Variables: P T H N N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N
CPH : count H P N1
============================
permutation (H::T) P
< G: apply count_greater_0 to CLH.
Subgoal 2:
Variables: P T H N N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N
CPH : count H P N1
G : N > 0
============================
permutation (H::T) P
< apply Same to _ CLH CPH.
Subgoal 2:
Variables: P T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
============================
permutation (H::T) P
< M: apply count_mem to CPH G.
Subgoal 2:
Variables: P T H N1
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
============================
permutation (H::T) P
< S: apply mem_select to M.
Subgoal 2:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
============================
permutation (H::T) P
< IsL': assert is_list (is_pair is_integer is_clause) L'.
Subgoal 2.1:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
============================
is_list (is_pair is_integer is_clause) L'
< case Is.
Subgoal 2.1:
Variables: P T N1 L' B A
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) ((A, B)::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X ((A, B)::T) NL -> count X P NP ->
NL = NP
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count (A, B) ((A, B)::T) N1
CPH : count (A, B) P N1
G : N1 > 0
M : mem (A, B) P
S : select (A, B) L' P
H1 : is_integer A
H2 : is_clause B
============================
is_list (is_pair is_integer is_clause) L'
< apply select_is to _ S.
Subgoal 2.1:
Variables: P T N1 L' B A
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) ((A, B)::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X ((A, B)::T) NL -> count X P NP ->
NL = NP
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count (A, B) ((A, B)::T) N1
CPH : count (A, B) P N1
G : N1 > 0
M : mem (A, B) P
S : select (A, B) L' P
H1 : is_integer A
H2 : is_clause B
H3 : is_list (is_pair is_integer is_clause) L'
============================
is_list (is_pair is_integer is_clause) L'
< search.
Subgoal 2:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
============================
permutation (H::T) P
< assert forall X NL NP,
is_pair is_integer is_clause X -> count X T NL -> count X L' NP -> NL = NP.
Subgoal 2.2:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
============================
forall X NL NP,
is_pair is_integer is_clause X -> count X T NL -> count X L' NP -> NL = NP
< intros IsX CT CL'.
Subgoal 2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
============================
NL = NP
< Or: apply is_pair_eq_or_not to Is IsX.
Subgoal 2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
Or : H = X \/ (H = X -> false)
============================
NL = NP
< E: case Or.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
============================
NL = NP
< IsNP: apply count_is_integer to CL'.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
============================
NL = NP
< PlusNP: apply plus_integer_total to _ IsNP with
N1 = 1.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
============================
NL = NP
< CXP: apply count_select to CL' S PlusNP.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
============================
NL = NP
< IsNL: apply count_is_integer to CT.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
============================
NL = NP
< PlusNL: apply plus_integer_total to _ IsNL with
N1 = 1.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3 N2
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N2
============================
NL = NP
< CXL: assert count X (X::T) N2.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3 N2
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N2
CXL : count X (X::T) N2
============================
NL = NP
< apply Same to _ CXL CXP.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
============================
NL = NP
< P: apply plus_integer_comm to _ _ PlusNP.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
P : NP + 1 = N3
============================
NL = NP
< M: apply plus_minus_same_integer to _ _ P.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
P : NP + 1 = N3
M1 : N3 - 1 = NP
============================
NL = NP
< P': apply plus_integer_comm to _ _ PlusNL.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
P : NP + 1 = N3
M1 : N3 - 1 = NP
P' : NL + 1 = N3
============================
NL = NP
< M': apply plus_minus_same_integer to _ _ P'.
Subgoal 2.2.1:
Variables: P T N1 L' X NL NP N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
IsNP : is_integer NP
PlusNP : 1 + NP = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
P : NP + 1 = N3
M1 : N3 - 1 = NP
P' : NL + 1 = N3
M' : N3 - 1 = NL
============================
NL = NP
< apply minus_integer_unique to M1 M'.
Subgoal 2.2.1:
Variables: P T N1 L' X NL N3
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (X::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X1 NL NP,
is_pair is_integer is_clause X1 -> count X1 (X::T) NL -> count X1 P NP ->
NL = NP
Is : is_pair is_integer is_clause X
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count X (X::T) N1
CPH : count X P N1
G : N1 > 0
M : mem X P
S : select X L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NL
IsNP : is_integer NL
PlusNP : 1 + NL = N3
CXP : count X P N3
IsNL : is_integer NL
PlusNL : 1 + NL = N3
CXL : count X (X::T) N3
P : NL + 1 = N3
M1 : N3 - 1 = NL
P' : NL + 1 = N3
M' : N3 - 1 = NL
============================
NL = NL
< search.
Subgoal 2.2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
============================
NL = NP
< assert X = H -> false.
Subgoal 2.2.2.1:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
============================
X = H -> false
< intros A.
Subgoal 2.2.2.1:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
A : X = H
============================
false
< case A.
Subgoal 2.2.2.1:
Variables: P T H N1 L' NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause H
CT : count H T NL
CL' : count H L' NP
E : H = H -> false
============================
false
< backchain E.
Subgoal 2.2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
H1 : X = H -> false
============================
NL = NP
< CXP: apply count_select_neq to CL' S _.
Subgoal 2.2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
H1 : X = H -> false
CXP : count X P NP
============================
NL = NP
< CXL: assert count X (H::T) NL.
Subgoal 2.2.2:
Variables: P T H N1 L' X NL NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NL
CL' : count X L' NP
E : H = X -> false
H1 : X = H -> false
CXP : count X P NP
CXL : count X (H::T) NL
============================
NL = NP
< apply Same to _ CXL CXP.
Subgoal 2.2.2:
Variables: P T H N1 L' X NP
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
IsX : is_pair is_integer is_clause X
CT : count X T NP
CL' : count X L' NP
E : H = X -> false
H1 : X = H -> false
CXP : count X P NP
CXL : count X (H::T) NP
============================
NP = NP
< search.
Subgoal 2:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X T NL -> count X L' NP -> NL = NP
============================
permutation (H::T) P
< apply IH to Is1 IsL' _.
Subgoal 2:
Variables: P T H N1 L'
IH : forall L P,
is_list (is_pair is_integer is_clause) L * -> is_list (is_pair is_integer is_clause) P ->
(forall X NL NP,
is_pair is_integer is_clause X -> count X L NL -> count X P NP -> NL = NP) ->
permutation L P
IsL : is_list (is_pair is_integer is_clause) (H::T) @
IsP : is_list (is_pair is_integer is_clause) P
Same : forall X NL NP,
is_pair is_integer is_clause X -> count X (H::T) NL -> count X P NP -> NL = NP
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
CLH : count H (H::T) N1
CPH : count H P N1
G : N1 > 0
M : mem H P
S : select H L' P
IsL' : is_list (is_pair is_integer is_clause) L'
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X T NL -> count X L' NP -> NL = NP
H2 : permutation T L'
============================
permutation (H::T) P
< search.
Proof completed.
< Theorem selects_permutation :
forall L P IDC LRest PRest,
is_list (is_pair is_integer is_clause) L -> is_list (is_pair is_integer is_clause) P ->
permutation L P -> select IDC LRest L -> select IDC PRest P -> permutation LRest PRest.
============================
forall L P IDC LRest PRest,
is_list (is_pair is_integer is_clause) L -> is_list (is_pair is_integer is_clause) P ->
permutation L P -> select IDC LRest L -> select IDC PRest P -> permutation LRest PRest
< intros IsL IsP Prm SL SP.
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
============================
permutation LRest PRest
< IsLRest: assert is_list (is_pair is_integer is_clause) LRest.
Subgoal 1:
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
============================
is_list (is_pair is_integer is_clause) LRest
< M: apply select_mem to SL.
Subgoal 1:
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
M : mem IDC L
============================
is_list (is_pair is_integer is_clause) LRest
< apply mem_is to IsL M.
Subgoal 1:
Variables: L P LRest PRest ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
M : mem (ID, C) L
H1 : is_integer ID
H2 : is_clause C
============================
is_list (is_pair is_integer is_clause) LRest
< apply select_is to IsL SL.
Subgoal 1:
Variables: L P LRest PRest ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
M : mem (ID, C) L
H1 : is_integer ID
H2 : is_clause C
H3 : is_list (is_pair is_integer is_clause) LRest
============================
is_list (is_pair is_integer is_clause) LRest
< search.
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
============================
permutation LRest PRest
< IsPRest: assert is_list (is_pair is_integer is_clause) PRest.
Subgoal 2:
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
============================
is_list (is_pair is_integer is_clause) PRest
< M: apply select_mem to SP.
Subgoal 2:
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
M : mem IDC P
============================
is_list (is_pair is_integer is_clause) PRest
< apply mem_is to IsP M.
Subgoal 2:
Variables: L P LRest PRest ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
M : mem (ID, C) P
H1 : is_integer ID
H2 : is_clause C
============================
is_list (is_pair is_integer is_clause) PRest
< apply select_is to IsP SP.
Subgoal 2:
Variables: L P LRest PRest ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
M : mem (ID, C) P
H1 : is_integer ID
H2 : is_clause C
H3 : is_list (is_pair is_integer is_clause) PRest
============================
is_list (is_pair is_integer is_clause) PRest
< search.
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
============================
permutation LRest PRest
< assert forall X NL NP,
is_pair is_integer is_clause X -> count X LRest NL -> count X PRest NP -> NL = NP.
Subgoal 3:
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
============================
forall X NL NP,
is_pair is_integer is_clause X -> count X LRest NL -> count X PRest NP -> NL = NP
< intros IsX CL CP.
Subgoal 3:
Variables: L P IDC LRest PRest X NL NP
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
============================
NL = NP
< M: apply select_mem to SL.
Subgoal 3:
Variables: L P IDC LRest PRest X NL NP
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem IDC L
============================
NL = NP
< Is: apply mem_is to _ M.
Subgoal 3:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
============================
NL = NP
< IsPair: assert is_pair is_integer is_clause (ID, C).
Subgoal 3:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
============================
NL = NP
< Or: apply is_pair_eq_or_not to IsX IsPair.
Subgoal 3:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
Or : X = (ID, C) \/ (X = (ID, C) -> false)
============================
NL = NP
< Eq: case Or.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
============================
NL = NP
< IsNL: apply count_is_integer to CL.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
============================
NL = NP
< PL: apply plus_integer_total to _ IsNL with
N1 = 1.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N3
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N3
============================
NL = NP
< IsNP: apply count_is_integer to CP.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N3
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N3
IsNP : is_integer NP
============================
NL = NP
< PP: apply plus_integer_total to _ IsNP with
N1 = 1.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N3 N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N3
IsNP : is_integer NP
PP : 1 + NP = N1
============================
NL = NP
< CLFull: apply count_select to CL SL PL.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N3 N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N3
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N3
============================
NL = NP
< CPFull: apply count_select to CP SP PP.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N3 N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N3
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N3
CPFull : count (ID, C) P N1
============================
NL = NP
< apply permutation_counts to Prm CLFull CPFull.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
============================
NL = NP
< NP+: apply plus_integer_comm to _ _ PP.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
NP+ : NP + 1 = N1
============================
NL = NP
< MP: apply plus_minus_same_integer to _ _ NP+.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
NP+ : NP + 1 = N1
MP : N1 - 1 = NP
============================
NL = NP
< NL+: apply plus_integer_comm to _ _ PL.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
NP+ : NP + 1 = N1
MP : N1 - 1 = NP
NL+ : NL + 1 = N1
============================
NL = NP
< ML: apply plus_minus_same_integer to _ _ NL+.
Subgoal 3.1:
Variables: L P LRest PRest NL NP ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NP
PP : 1 + NP = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
NP+ : NP + 1 = N1
MP : N1 - 1 = NP
NL+ : NL + 1 = N1
ML : N1 - 1 = NL
============================
NL = NP
< apply minus_integer_unique to MP ML.
Subgoal 3.1:
Variables: L P LRest PRest NL ID C N1
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause (ID, C)
CL : count (ID, C) LRest NL
CP : count (ID, C) PRest NL
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
IsNL : is_integer NL
PL : 1 + NL = N1
IsNP : is_integer NL
PP : 1 + NL = N1
CLFull : count (ID, C) L N1
CPFull : count (ID, C) P N1
NP+ : NL + 1 = N1
MP : N1 - 1 = NL
NL+ : NL + 1 = N1
ML : N1 - 1 = NL
============================
NL = NL
< search.
Subgoal 3.2:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
Eq : X = (ID, C) -> false
============================
NL = NP
< CLFull: apply count_select_neq to CL SL Eq.
Subgoal 3.2:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
Eq : X = (ID, C) -> false
CLFull : count X L NL
============================
NL = NP
< CPFull: apply count_select_neq to CP SP Eq.
Subgoal 3.2:
Variables: L P LRest PRest X NL NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NL
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
Eq : X = (ID, C) -> false
CLFull : count X L NL
CPFull : count X P NP
============================
NL = NP
< apply permutation_counts to Prm CLFull CPFull.
Subgoal 3.2:
Variables: L P LRest PRest X NP ID C
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select (ID, C) LRest L
SP : select (ID, C) PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
IsX : is_pair is_integer is_clause X
CL : count X LRest NP
CP : count X PRest NP
M : mem (ID, C) L
Is : is_integer ID
Is1 : is_clause C
IsPair : is_pair is_integer is_clause (ID, C)
Eq : X = (ID, C) -> false
CLFull : count X L NP
CPFull : count X P NP
============================
NP = NP
< search.
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X LRest NL -> count X PRest NP ->
NL = NP
============================
permutation LRest PRest
< apply counts_permutation to IsLRest IsPRest _.
Variables: L P IDC LRest PRest
IsL : is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
SL : select IDC LRest L
SP : select IDC PRest P
IsLRest : is_list (is_pair is_integer is_clause) LRest
IsPRest : is_list (is_pair is_integer is_clause) PRest
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X LRest NL -> count X PRest NP ->
NL = NP
H2 : permutation LRest PRest
============================
permutation LRest PRest
< search.
Proof completed.
< Theorem permutation_reflexive :
forall L, is_list (is_pair is_integer is_clause) L -> permutation L L.
============================
forall L, is_list (is_pair is_integer is_clause) L -> permutation L L
< induction on 1.
IH : forall L, is_list (is_pair is_integer is_clause) L * -> permutation L L
============================
forall L, is_list (is_pair is_integer is_clause) L @ -> permutation L L
< intros Is.
Variables: L
IH : forall L, is_list (is_pair is_integer is_clause) L * -> permutation L L
Is : is_list (is_pair is_integer is_clause) L @
============================
permutation L L
< Is: case Is.
Subgoal 1:
IH : forall L, is_list (is_pair is_integer is_clause) L * -> permutation L L
============================
permutation [] []
< search.
Subgoal 2:
Variables: T H
IH : forall L, is_list (is_pair is_integer is_clause) L * -> permutation L L
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
============================
permutation (H::T) (H::T)
< apply IH to Is1.
Subgoal 2:
Variables: T H
IH : forall L, is_list (is_pair is_integer is_clause) L * -> permutation L L
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : permutation T T
============================
permutation (H::T) (H::T)
< search.
Proof completed.
< Theorem permutation_is :
forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P -> is_list (is_pair is_integer is_clause) L.
============================
forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P -> is_list (is_pair is_integer is_clause) L
< induction on 2.
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
============================
forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P @ -> is_list (is_pair is_integer is_clause) L
< intros IsP Prm.
Variables: L P
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P @
============================
is_list (is_pair is_integer is_clause) L
< Prm: case Prm.
Subgoal 1:
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) []
============================
is_list (is_pair is_integer is_clause) []
< search.
Subgoal 2:
Variables: P L2 Rest A
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : select A L2 P
Prm1 : permutation Rest L2 *
============================
is_list (is_pair is_integer is_clause) (A::Rest)
< IsRest: apply select_is to IsP Prm.
Subgoal 2:
Variables: P L2 Rest A
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : select A L2 P
Prm1 : permutation Rest L2 *
IsRest : is_list (is_pair is_integer is_clause) L2
============================
is_list (is_pair is_integer is_clause) (A::Rest)
< apply IH to IsRest Prm1.
Subgoal 2:
Variables: P L2 Rest A
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : select A L2 P
Prm1 : permutation Rest L2 *
IsRest : is_list (is_pair is_integer is_clause) L2
H1 : is_list (is_pair is_integer is_clause) Rest
============================
is_list (is_pair is_integer is_clause) (A::Rest)
< IsA: apply select_is_picked to IsP Prm.
Subgoal 2:
Variables: P L2 Rest A
IH : forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P * -> is_list (is_pair is_integer is_clause) L
IsP : is_list (is_pair is_integer is_clause) P
Prm : select A L2 P
Prm1 : permutation Rest L2 *
IsRest : is_list (is_pair is_integer is_clause) L2
H1 : is_list (is_pair is_integer is_clause) Rest
IsA : is_pair is_integer is_clause A
============================
is_list (is_pair is_integer is_clause) (A::Rest)
< search.
Proof completed.
< Define good_assignment : (list lit) -> prop by
good_assignment A :=
forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false.
< Theorem good_assignment_sub :
forall A B,
good_assignment A -> (forall X, mem X B -> mem X A) -> good_assignment B.
============================
forall A B,
good_assignment A -> (forall X, mem X B -> mem X A) -> good_assignment B
< intros GA Sub.
Variables: A B
GA : good_assignment A
Sub : forall X, mem X B -> mem X A
============================
good_assignment B
< unfold .
Variables: A B
GA : good_assignment A
Sub : forall X, mem X B -> mem X A
============================
forall L NL, mem L B -> negate_lit L NL -> mem NL B -> false
< intros MLB Neg MNLB.
Variables: A B L NL
GA : good_assignment A
Sub : forall X, mem X B -> mem X A
MLB : mem L B
Neg : negate_lit L NL
MNLB : mem NL B
============================
false
< GA: case GA.
Variables: A B L NL
Sub : forall X, mem X B -> mem X A
MLB : mem L B
Neg : negate_lit L NL
MNLB : mem NL B
GA : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
============================
false
< MLA: apply Sub to MLB.
Variables: A B L NL
Sub : forall X, mem X B -> mem X A
MLB : mem L B
Neg : negate_lit L NL
MNLB : mem NL B
GA : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
MLA : mem L A
============================
false
< MNLA: apply Sub to MNLB.
Variables: A B L NL
Sub : forall X, mem X B -> mem X A
MLB : mem L B
Neg : negate_lit L NL
MNLB : mem NL B
GA : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
MLA : mem L A
MNLA : mem NL A
============================
false
< apply GA to MLA Neg _.
Proof completed.
< Extensible_Theorem
negate_lit_unique : forall L LA LB,
IsL : is_lit L ->
NegA : negate_lit L LA ->
NegB : negate_lit L LB ->
LA = LB
on NegA.
Subgoal 1:
Variables: LB V
IH : forall L LA LB, is_lit L -> negate_lit L LA * -> negate_lit L LB -> LA = LB
IsL : is_lit (pos V)
NegA : negate_lit (pos V) (neg V) @
NegB : negate_lit (pos V) LB
============================
neg V = LB
< case NegB.
Subgoal 1:
Variables: V
IH : forall L LA LB, is_lit L -> negate_lit L LA * -> negate_lit L LB -> LA = LB
IsL : is_lit (pos V)
NegA : negate_lit (pos V) (neg V) @
============================
neg V = neg V
< search.
Subgoal 2:
Variables: LB V
IH : forall L LA LB, is_lit L -> negate_lit L LA * -> negate_lit L LB -> LA = LB
IsL : is_lit (neg V)
NegA : negate_lit (neg V) (pos V) @
NegB : negate_lit (neg V) LB
============================
pos V = LB
< case NegB.
Subgoal 2:
Variables: V
IH : forall L LA LB, is_lit L -> negate_lit L LA * -> negate_lit L LB -> LA = LB
IsL : is_lit (neg V)
NegA : negate_lit (neg V) (pos V) @
============================
pos V = pos V
< search.
Proof completed.
< Extensible_Theorem
negate_lit_reverse : forall L NL,
IsL : is_lit L ->
Neg : negate_lit L NL ->
negate_lit NL L
on Neg.
Subgoal 1:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> negate_lit NL L
IsL : is_lit (pos V)
Neg : negate_lit (pos V) (neg V) @
============================
negate_lit (neg V) (pos V)
< search.
Subgoal 2:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> negate_lit NL L
IsL : is_lit (neg V)
Neg : negate_lit (neg V) (pos V) @
============================
negate_lit (pos V) (neg V)
< search.
Proof completed.
< Extensible_Theorem
negate_lit_not_same : forall L,
IsL : is_lit L ->
Neg : negate_lit L L ->
false
on Neg.
Proof completed.
< Extensible_Theorem
negate_lit_is_lit : forall L NL,
IsL : is_lit L ->
Neg : negate_lit L NL ->
is_lit NL
on Neg.
Subgoal 1:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> is_lit NL
IsL : is_lit (pos V)
Neg : negate_lit (pos V) (neg V) @
============================
is_lit (neg V)
< case IsL.
Subgoal 1:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> is_lit NL
Neg : negate_lit (pos V) (neg V) @
H1 : is_integer V
============================
is_lit (neg V)
< search.
Subgoal 2:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> is_lit NL
IsL : is_lit (neg V)
Neg : negate_lit (neg V) (pos V) @
============================
is_lit (pos V)
< case IsL.
Subgoal 2:
Variables: V
IH : forall L NL, is_lit L -> negate_lit L NL * -> is_lit NL
Neg : negate_lit (neg V) (pos V) @
H1 : is_integer V
============================
is_lit (pos V)
< search.
Proof completed.
< Extensible_Theorem
negate_lit_is_lit_back : forall L NL,
IsNL : is_lit NL ->
Neg : negate_lit L NL ->
is_lit L
on Neg.
Subgoal 1:
Variables: V
IH : forall L NL, is_lit NL -> negate_lit L NL * -> is_lit L
IsNL : is_lit (neg V)
Neg : negate_lit (pos V) (neg V) @
============================
is_lit (pos V)
< case IsNL.
Subgoal 1:
Variables: V
IH : forall L NL, is_lit NL -> negate_lit L NL * -> is_lit L
Neg : negate_lit (pos V) (neg V) @
H1 : is_integer V
============================
is_lit (pos V)
< search.
Subgoal 2:
Variables: V
IH : forall L NL, is_lit NL -> negate_lit L NL * -> is_lit L
IsNL : is_lit (pos V)
Neg : negate_lit (neg V) (pos V) @
============================
is_lit (neg V)
< case IsNL.
Subgoal 2:
Variables: V
IH : forall L NL, is_lit NL -> negate_lit L NL * -> is_lit L
Neg : negate_lit (neg V) (pos V) @
H1 : is_integer V
============================
is_lit (neg V)
< search.
Proof completed.
< Extensible_Theorem
negate_lit_exists : forall L,
IsL : is_lit L ->
exists NL,
negate_lit L NL
on IsL.
Subgoal 1:
Variables: I
IH : forall L, is_lit L * -> exists NL, negate_lit L NL
IsL : is_lit (pos I) @
IsL1 : is_integer I
============================
exists NL, negate_lit (pos I) NL
< search.
Subgoal 2:
Variables: I
IH : forall L, is_lit L * -> exists NL, negate_lit L NL
IsL : is_lit (neg I) @
IsL1 : is_integer I
============================
exists NL, negate_lit (neg I) NL
< search.
Proof completed.
< Projection_Constraint sat_clause_ext_to_proj :
forall C C' Sat,
|{clause}- C ~~> C' -> is_list is_lit Sat -> is_clause C -> sat_clause Sat C ->
sat_clause Sat C'.
Proof completed.
< Projection_Constraint sat_clause_proj_to_ext :
forall C C' Sat,
|{clause}- C ~~> C' -> is_list is_lit Sat -> is_clause C -> sat_clause Sat C' ->
sat_clause Sat C.
Proof completed.
< Projection_Constraint unsat_clause_ext_to_proj :
forall C C' Unsat,
|{clause}- C ~~> C' -> is_list is_lit Unsat -> is_clause C -> unsat_clause Unsat C ->
unsat_clause Unsat C'.
Proof completed.
< Projection_Constraint unsat_clause_proj_to_ext :
forall C C' Unsat,
|{clause}- C ~~> C' -> is_list is_lit Unsat -> is_clause C -> unsat_clause Unsat C' ->
unsat_clause Unsat C.
Proof completed.
< Projection_Constraint sat_formula_ext_to_proj :
forall F F' Sat,
|{formula}- F ~~> F' -> is_list is_lit Sat -> sat_formula Sat F -> sat_formula Sat F'.
Proof completed.
< Projection_Constraint sat_formula_proj_to_ext :
forall F F' Sat,
|{formula}- F ~~> F' -> is_list is_lit Sat -> sat_formula Sat F' -> sat_formula Sat F.
Proof completed.
< Extensible_Theorem
unsat_sat_clause : forall A C,
IsC : is_clause C ->
IsA : is_list is_lit A ->
UNSAT : unsat_clause A C ->
SAT : sat_clause A C ->
GA : good_assignment A ->
false
on UNSAT.
Subgoal 1:
Variables: A
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 emptyClause
IsA : is_list is_lit A
UNSAT : unsat_clause A emptyClause @
SAT : sat_clause A emptyClause
GA : good_assignment A
============================
false
< SAT: case SAT.
Subgoal 2:
Variables: A NL Rest L
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 (or L Rest)
IsA : is_list is_lit A
UNSAT : unsat_clause A (or L Rest) @
SAT : sat_clause A (or L Rest)
GA : good_assignment A
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A
UNSAT3 : unsat_clause A Rest *
============================
false
< SAT: case SAT.
Subgoal 2.1:
Variables: A NL Rest L
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 (or L Rest)
IsA : is_list is_lit A
UNSAT : unsat_clause A (or L Rest) @
GA : good_assignment A
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A
UNSAT3 : unsat_clause A Rest *
SAT : mem L A
============================
false
< GA: case GA.
Subgoal 2.1:
Variables: A NL Rest L
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 (or L Rest)
IsA : is_list is_lit A
UNSAT : unsat_clause A (or L Rest) @
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A
UNSAT3 : unsat_clause A Rest *
SAT : mem L A
GA : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
============================
false
< apply GA to SAT _ UNSAT2.
Subgoal 2.2:
Variables: A NL Rest L
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 (or L Rest)
IsA : is_list is_lit A
UNSAT : unsat_clause A (or L Rest) @
GA : good_assignment A
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A
UNSAT3 : unsat_clause A Rest *
SAT : sat_clause A Rest
============================
false
< case IsC.
Subgoal 2.2:
Variables: A NL Rest L
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 (or L Rest) @
GA : good_assignment A
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A
UNSAT3 : unsat_clause A Rest *
SAT : sat_clause A Rest
H1 : is_lit L
H2 : is_clause Rest
============================
false
< apply IH to _ _ UNSAT3 SAT GA.
Proof completed.
< Extensible_Theorem
sat_clause_orderless : forall A1 A2 C,
IsC : is_clause C ->
IsA1 : is_list is_lit A1 ->
IsA2 : is_list is_lit A2 ->
SAT : sat_clause A1 C ->
MemA1A2 : (forall L,
mem L A1 -> mem L A2) ->
sat_clause A2 C
on SAT.
Subgoal 1:
Variables: A1 A2 Rest L
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 (or L Rest)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : mem L A1
============================
sat_clause A2 (or L Rest)
< apply MemA1A2 to _.
Subgoal 1:
Variables: A1 A2 Rest L
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 (or L Rest)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : mem L A1
H1 : mem L A2
============================
sat_clause A2 (or L Rest)
< search.
Subgoal 2:
Variables: A1 A2 Rest L
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 (or L Rest)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_clause A1 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Rest *
============================
sat_clause A2 (or L Rest)
< case IsC.
Subgoal 2:
Variables: A1 A2 Rest L
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 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Rest *
H1 : is_lit L
H2 : is_clause Rest
============================
sat_clause A2 (or L Rest)
< apply IH to _ _ _ SAT1 _.
Subgoal 2:
Variables: A1 A2 Rest L
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 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 Rest *
H1 : is_lit L
H2 : is_clause Rest
H3 : sat_clause A2 Rest
============================
sat_clause A2 (or L Rest)
< search.
Proof completed.
< Extensible_Theorem
sat_formula_orderless : forall A1 A2 F,
IsF : is_formula F ->
IsA1 : is_list is_lit A1 ->
IsA2 : is_list is_lit A2 ->
SAT : sat_formula A1 F ->
MemA1A2 : (forall L,
mem L A1 -> mem L A2) ->
sat_formula A2 F
on SAT.
Subgoal 1:
Variables: A1 A2
IH : forall A1 A2 F,
is_formula F -> is_list is_lit A1 -> is_list is_lit A2 -> sat_formula A1 F * ->
(forall L, mem L A1 -> mem L A2) -> sat_formula A2 F
IsF : is_formula emptyFormula
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_formula A1 emptyFormula @
MemA1A2 : forall L, mem L A1 -> mem L A2
============================
sat_formula A2 emptyFormula
< search.
Subgoal 2:
Variables: A1 A2 Rest C
IH : forall A1 A2 F,
is_formula F -> is_list is_lit A1 -> is_list is_lit A2 -> sat_formula A1 F * ->
(forall L, mem L A1 -> mem L A2) -> sat_formula A2 F
IsF : is_formula (and C Rest)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_formula A1 (and C Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 C
SAT2 : sat_formula A1 Rest *
============================
sat_formula A2 (and C Rest)
< case IsF.
Subgoal 2:
Variables: A1 A2 Rest C
IH : forall A1 A2 F,
is_formula F -> is_list is_lit A1 -> is_list is_lit A2 -> sat_formula A1 F * ->
(forall L, mem L A1 -> mem L A2) -> sat_formula A2 F
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_formula A1 (and C Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 C
SAT2 : sat_formula A1 Rest *
H1 : is_clause C
H2 : is_formula Rest
============================
sat_formula A2 (and C Rest)
< apply IH to _ _ _ SAT2 _.
Subgoal 2:
Variables: A1 A2 Rest C
IH : forall A1 A2 F,
is_formula F -> is_list is_lit A1 -> is_list is_lit A2 -> sat_formula A1 F * ->
(forall L, mem L A1 -> mem L A2) -> sat_formula A2 F
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_formula A1 (and C Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 C
SAT2 : sat_formula A1 Rest *
H1 : is_clause C
H2 : is_formula Rest
H3 : sat_formula A2 Rest
============================
sat_formula A2 (and C Rest)
< apply sat_clause_orderless to _ _ _ _ _.
Subgoal 2:
Variables: A1 A2 Rest C
IH : forall A1 A2 F,
is_formula F -> is_list is_lit A1 -> is_list is_lit A2 -> sat_formula A1 F * ->
(forall L, mem L A1 -> mem L A2) -> sat_formula A2 F
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
SAT : sat_formula A1 (and C Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
SAT1 : sat_clause A1 C
SAT2 : sat_formula A1 Rest *
H1 : is_clause C
H2 : is_formula Rest
H3 : sat_formula A2 Rest
H4 : sat_clause A2 C
============================
sat_formula A2 (and C Rest)
< search.
Proof completed.
< Extensible_Theorem
unsat_clause_orderless : forall A1 A2 C,
IsC : is_clause C ->
IsA1 : is_list is_lit A1 ->
IsA2 : is_list is_lit A2 ->
UNSAT : unsat_clause A1 C ->
MemA1A2 : (forall L,
mem L A1 -> mem L A2) ->
unsat_clause A2 C
on UNSAT.
Subgoal 1:
Variables: A1 A2
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 emptyClause
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 emptyClause @
MemA1A2 : forall L, mem L A1 -> mem L A2
============================
unsat_clause A2 emptyClause
< search.
Subgoal 2:
Variables: A1 A2 NL Rest L
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 (or L Rest)
IsA1 : is_list is_lit A1
IsA2 : is_list is_lit A2
UNSAT : unsat_clause A1 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A1
UNSAT3 : unsat_clause A1 Rest *
============================
unsat_clause A2 (or L Rest)
< case IsC.
Subgoal 2:
Variables: A1 A2 NL Rest L
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 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A1
UNSAT3 : unsat_clause A1 Rest *
H1 : is_lit L
H2 : is_clause Rest
============================
unsat_clause A2 (or L Rest)
< apply IH to _ _ _ UNSAT3 _.
Subgoal 2:
Variables: A1 A2 NL Rest L
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 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A1
UNSAT3 : unsat_clause A1 Rest *
H1 : is_lit L
H2 : is_clause Rest
H3 : unsat_clause A2 Rest
============================
unsat_clause A2 (or L Rest)
< apply MemA1A2 to UNSAT2.
Subgoal 2:
Variables: A1 A2 NL Rest L
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 (or L Rest) @
MemA1A2 : forall L, mem L A1 -> mem L A2
UNSAT1 : negate_lit L NL
UNSAT2 : mem NL A1
UNSAT3 : unsat_clause A1 Rest *
H1 : is_lit L
H2 : is_clause Rest
H3 : unsat_clause A2 Rest
H4 : mem NL A2
============================
unsat_clause A2 (or L Rest)
< search.
Proof completed.
< Extensible_Theorem
unit_clause_is : forall A C L,
IsC : is_clause C ->
IsA : is_list is_lit A ->
Unit : unit_clause A C L ->
is_lit L
on Unit.
Subgoal 1:
Variables: A L NL C1
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsC : is_clause (or L C1)
IsA : is_list is_lit A
Unit : unit_clause A (or L C1) L @
Unit1 : mem L A -> false
Unit2 : negate_lit L NL
Unit3 : mem NL A -> false
Unit4 : unsat_clause A C1
============================
is_lit L
< case IsC.
Subgoal 1:
Variables: A L NL C1
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 (or L C1) L @
Unit1 : mem L A -> false
Unit2 : negate_lit L NL
Unit3 : mem NL A -> false
Unit4 : unsat_clause A C1
H1 : is_lit L
H2 : is_clause C1
============================
is_lit L
< search.
Subgoal 2:
Variables: A L NL C1 L1
IH : forall A C L,
is_clause C -> is_list is_lit A -> unit_clause A C L * -> is_lit L
IsC : is_clause (or L1 C1)
IsA : is_list is_lit A
Unit : unit_clause A (or L1 C1) L @
Unit1 : negate_lit L1 NL
Unit2 : mem NL A
Unit3 : unit_clause A C1 L *
============================
is_lit L
< Is: case IsC.
Subgoal 2:
Variables: A L NL C1 L1
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 (or L1 C1) L @
Unit1 : negate_lit L1 NL
Unit2 : mem NL A
Unit3 : unit_clause A C1 L *
Is : is_lit L1
Is1 : is_clause C1
============================
is_lit L
< apply IH to _ _ Unit3.
Subgoal 2:
Variables: A L NL C1 L1
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 (or L1 C1) L @
Unit1 : negate_lit L1 NL
Unit2 : mem NL A
Unit3 : unit_clause A C1 L *
Is : is_lit L1
Is1 : is_clause C1
H1 : is_lit L
============================
is_lit L
< search.
Proof completed.
< Extensible_Theorem
unit_clause_unique : forall A B C LA LB,
IsC : is_clause C ->
IsA : is_list is_lit A ->
IsB : is_list is_lit B ->
UnitA : unit_clause A C LA ->
UnitB : unit_clause B C LB ->
Prm : permutation A B ->
LA = LB
on UnitA.
Subgoal 1:
Variables: A B LA LB NL C1
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 (or LA C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LA C1) LA @
UnitB : unit_clause B (or LA C1) LB
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
============================
LA = LB
< UnitB: case UnitB.
Subgoal 1.1:
Variables: A B LB NL C1 NL1
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 (or LB C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LB C1) LB @
Prm : permutation A B
UnitA1 : mem LB A -> false
UnitA2 : negate_lit LB NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
UnitB : mem LB B -> false
UnitB1 : negate_lit LB NL1
UnitB2 : mem NL1 B -> false
UnitB3 : unsat_clause B C1
============================
LB = LB
< search.
Subgoal 1.2:
Variables: A B LA LB NL C1 NL1
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 (or LA C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
============================
LA = LB
< IsLA: apply unit_clause_is to _ _ UnitA.
Subgoal 1.2:
Variables: A B LA LB NL C1 NL1
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 (or LA C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
============================
LA = LB
< Is: case IsC.
Subgoal 1.2:
Variables: A B LA LB NL C1 NL1
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 (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
Is : is_lit LA
Is1 : is_clause C1
============================
LA = LB
< IsLB: apply unit_clause_is to _ _ UnitB2.
Subgoal 1.2:
Variables: A B LA LB NL C1 NL1
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 (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL
UnitA3 : mem NL A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
Is : is_lit LA
Is1 : is_clause C1
IsLB : is_lit LB
============================
LA = LB
< apply negate_lit_unique to _ UnitA2 UnitB.
Subgoal 1.2:
Variables: A B LA LB C1 NL1
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 (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL1
UnitA3 : mem NL1 A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
Is : is_lit LA
Is1 : is_clause C1
IsLB : is_lit LB
============================
LA = LB
< P: apply permutation_symmetric to Prm.
Subgoal 1.2:
Variables: A B LA LB C1 NL1
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 (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL1
UnitA3 : mem NL1 A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
Is : is_lit LA
Is1 : is_clause C1
IsLB : is_lit LB
P : permutation B A
============================
LA = LB
< MemA: apply permutation_mem to P UnitB1.
Subgoal 1.2:
Variables: A B LA LB C1 NL1
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 (or LA C1) LA @
Prm : permutation A B
UnitA1 : mem LA A -> false
UnitA2 : negate_lit LA NL1
UnitA3 : mem NL1 A -> false
UnitA4 : unsat_clause A C1
UnitB : negate_lit LA NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
IsLA : is_lit LA
Is : is_lit LA
Is1 : is_clause C1
IsLB : is_lit LB
P : permutation B A
MemA : mem NL1 A
============================
LA = LB
< apply UnitA3 to MemA.
Subgoal 2:
Variables: A B LA LB NL C1 L
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 (or L C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or L C1) LA @
UnitB : unit_clause B (or L C1) LB
Prm : permutation A B
UnitA1 : negate_lit L NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
============================
LA = LB
< UnitB: case UnitB.
Subgoal 2.1:
Variables: A B LA LB NL C1 NL1
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 (or LB C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LB C1) LA @
Prm : permutation A B
UnitA1 : negate_lit LB NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
UnitB : mem LB B -> false
UnitB1 : negate_lit LB NL1
UnitB2 : mem NL1 B -> false
UnitB3 : unsat_clause B C1
============================
LA = LB
< MemB: apply permutation_mem to Prm UnitA2.
Subgoal 2.1:
Variables: A B LA LB NL C1 NL1
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 (or LB C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or LB C1) LA @
Prm : permutation A B
UnitA1 : negate_lit LB NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
UnitB : mem LB B -> false
UnitB1 : negate_lit LB NL1
UnitB2 : mem NL1 B -> false
UnitB3 : unsat_clause B C1
MemB : mem NL B
============================
LA = LB
< Is: case IsC.
Subgoal 2.1:
Variables: A B LA LB NL C1 NL1
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 (or LB C1) LA @
Prm : permutation A B
UnitA1 : negate_lit LB NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
UnitB : mem LB B -> false
UnitB1 : negate_lit LB NL1
UnitB2 : mem NL1 B -> false
UnitB3 : unsat_clause B C1
MemB : mem NL B
Is : is_lit LB
Is1 : is_clause C1
============================
LA = LB
< apply negate_lit_unique to _ UnitA1 UnitB1.
Subgoal 2.1:
Variables: A B LA LB C1 NL1
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 (or LB C1) LA @
Prm : permutation A B
UnitA1 : negate_lit LB NL1
UnitA2 : mem NL1 A
UnitA3 : unit_clause A C1 LA *
UnitB : mem LB B -> false
UnitB1 : negate_lit LB NL1
UnitB2 : mem NL1 B -> false
UnitB3 : unsat_clause B C1
MemB : mem NL1 B
Is : is_lit LB
Is1 : is_clause C1
============================
LA = LB
< apply UnitB2 to MemB.
Subgoal 2.2:
Variables: A B LA LB NL C1 L NL1
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 (or L C1)
IsA : is_list is_lit A
IsB : is_list is_lit B
UnitA : unit_clause A (or L C1) LA @
Prm : permutation A B
UnitA1 : negate_lit L NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
UnitB : negate_lit L NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
============================
LA = LB
< case IsC.
Subgoal 2.2:
Variables: A B LA LB NL C1 L NL1
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 (or L C1) LA @
Prm : permutation A B
UnitA1 : negate_lit L NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LA *
UnitB : negate_lit L NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
H1 : is_lit L
H2 : is_clause C1
============================
LA = LB
< apply IH to _ _ _ UnitA3 _ _.
Subgoal 2.2:
Variables: A B LB NL C1 L NL1
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 (or L C1) LB @
Prm : permutation A B
UnitA1 : negate_lit L NL
UnitA2 : mem NL A
UnitA3 : unit_clause A C1 LB *
UnitB : negate_lit L NL1
UnitB1 : mem NL1 B
UnitB2 : unit_clause B C1 LB
H1 : is_lit L
H2 : is_clause C1
============================
LB = LB
< search.
Proof completed.
< Extensible_Theorem
unit_clause_not_assigned : forall A C L,
IsC : is_clause C ->
IsA : is_list is_lit A ->
UC : unit_clause A C L ->
Mem : mem L A ->
false
on UC.
Subgoal 1:
Variables: A L NL C1
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 (or L C1)
IsA : is_list is_lit A
UC : unit_clause A (or L C1) L @
Mem : mem L A
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
============================
false
< backchain UC1.
Subgoal 2:
Variables: A L NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
UC : unit_clause A (or L1 C1) L @
Mem : mem L A
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
============================
false
< case IsC.
Subgoal 2:
Variables: A L NL C1 L1
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 (or L1 C1) L @
Mem : mem L A
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
H1 : is_lit L1
H2 : is_clause C1
============================
false
< apply IH to _ _ UC3 Mem.
Proof completed.
< Extensible_Theorem
unit_clause_not_assigned_negate : forall A C L NL,
IsC : is_clause C ->
IsA : is_list is_lit A ->
UC : unit_clause A C L ->
Neg : negate_lit L NL ->
Mem : mem NL A ->
false
on UC.
Subgoal 1:
Variables: A L NL NL1 C1
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 (or L C1)
IsA : is_list is_lit A
UC : unit_clause A (or L C1) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : mem L A -> false
UC2 : negate_lit L NL1
UC3 : mem NL1 A -> false
UC4 : unsat_clause A C1
============================
false
< backchain UC3.
Subgoal 1:
Variables: A L NL NL1 C1
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 (or L C1)
IsA : is_list is_lit A
UC : unit_clause A (or L C1) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : mem L A -> false
UC2 : negate_lit L NL1
UC3 : mem NL1 A -> false
UC4 : unsat_clause A C1
============================
mem NL1 A
< apply unit_clause_is to _ _ UC.
Subgoal 1:
Variables: A L NL NL1 C1
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 (or L C1)
IsA : is_list is_lit A
UC : unit_clause A (or L C1) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : mem L A -> false
UC2 : negate_lit L NL1
UC3 : mem NL1 A -> false
UC4 : unsat_clause A C1
H1 : is_lit L
============================
mem NL1 A
< apply negate_lit_unique to _ Neg UC2.
Subgoal 1:
Variables: A L NL1 C1
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 (or L C1)
IsA : is_list is_lit A
UC : unit_clause A (or L C1) L @
Neg : negate_lit L NL1
Mem : mem NL1 A
UC1 : mem L A -> false
UC2 : negate_lit L NL1
UC3 : mem NL1 A -> false
UC4 : unsat_clause A C1
H1 : is_lit L
============================
mem NL1 A
< search.
Subgoal 2:
Variables: A L NL NL1 C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
UC : unit_clause A (or L1 C1) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : negate_lit L1 NL1
UC2 : mem NL1 A
UC3 : unit_clause A C1 L *
============================
false
< case IsC.
Subgoal 2:
Variables: A L NL NL1 C1 L1
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 (or L1 C1) L @
Neg : negate_lit L NL
Mem : mem NL A
UC1 : negate_lit L1 NL1
UC2 : mem NL1 A
UC3 : unit_clause A C1 L *
H1 : is_lit L1
H2 : is_clause C1
============================
false
< apply IH to _ _ UC3 _ _.
Proof completed.
< Extensible_Theorem
unit_clause_expand : forall A C L E,
IsC : is_clause C ->
IsA : is_list is_lit A ->
IsE : is_list is_lit E ->
UC : unit_clause A C L ->
SAT : sat_clause E C ->
GA_A : good_assignment A ->
GA_E : good_assignment E ->
Expand : (forall L,
mem L A -> mem L E) ->
mem L E
on UC.
Subgoal 1:
Variables: A L E NL C1
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 (or L C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L C1) L @
SAT : sat_clause E (or L C1)
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
============================
mem L E
< SAT: case SAT.
Subgoal 1.1:
Variables: A L E NL C1
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 (or L C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
SAT : mem L E
============================
mem L E
< search.
Subgoal 1.2:
Variables: A L E NL C1
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 (or L C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
SAT : sat_clause E C1
============================
mem L E
< Is: case IsC.
Subgoal 1.2:
Variables: A L E NL C1
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 (or L C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
SAT : sat_clause E C1
Is : is_lit L
Is1 : is_clause C1
============================
mem L E
< UCE: apply unsat_clause_orderless to _ _ _ UC4 Expand.
Subgoal 1.2:
Variables: A L E NL C1
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 (or L C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
SAT : sat_clause E C1
Is : is_lit L
Is1 : is_clause C1
UCE : unsat_clause E C1
============================
mem L E
< apply unsat_sat_clause to _ _ UCE SAT _.
Subgoal 2:
Variables: A L E NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L1 C1) L @
SAT : sat_clause E (or L1 C1)
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
============================
mem L E
< SAT: case SAT.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L1 C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
============================
mem L E
< GA_A: case GA_A.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L1 C1) L @
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
============================
mem L E
< Is: case IsC.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
============================
mem L E
< Neg: apply negate_lit_reverse to _ UC1.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
Neg : negate_lit NL L1
============================
mem L E
< apply GA_A to UC2 Neg _.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
Neg : negate_lit NL L1
============================
mem L1 A
< GA_E: case GA_E.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
Neg : negate_lit NL L1
GA_E : forall L NL, mem L E -> negate_lit L NL -> mem NL E -> false
============================
mem L1 A
< apply GA_E to SAT UC1 _.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
Neg : negate_lit NL L1
GA_E : forall L NL, mem L E -> negate_lit L NL -> mem NL E -> false
============================
mem NL E
< apply Expand to UC2.
Subgoal 2.1:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : mem L1 E
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
Is : is_lit L1
Is1 : is_clause C1
Neg : negate_lit NL L1
GA_E : forall L NL, mem L E -> negate_lit L NL -> mem NL E -> false
H1 : mem NL E
============================
mem NL E
< search.
Subgoal 2.2:
Variables: A L E NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
IsE : is_list is_lit E
UC : unit_clause A (or L1 C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : sat_clause E C1
============================
mem L E
< case IsC.
Subgoal 2.2:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : sat_clause E C1
H1 : is_lit L1
H2 : is_clause C1
============================
mem L E
< apply IH to _ _ _ UC3 _ _ _ _.
Subgoal 2.2:
Variables: A L E NL C1 L1
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 (or L1 C1) L @
GA_A : good_assignment A
GA_E : good_assignment E
Expand : forall L, mem L A -> mem L E
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
SAT : sat_clause E C1
H1 : is_lit L1
H2 : is_clause C1
H3 : mem L E
============================
mem L E
< search.
Proof completed.
< Extensible_Theorem
unit_clause_add : forall A S C L,
IsC : is_clause C ->
IsA : is_list is_lit A ->
IsS : is_list is_lit S ->
UC : unit_clause A C L ->
Mem : mem L S ->
sat_clause S C
on UC.
Subgoal 1:
Variables: A S L NL C1
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 (or L C1)
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (or L C1) L @
Mem : mem L S
UC1 : mem L A -> false
UC2 : negate_lit L NL
UC3 : mem NL A -> false
UC4 : unsat_clause A C1
============================
sat_clause S (or L C1)
< search.
Subgoal 2:
Variables: A S L NL C1 L1
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 (or L1 C1)
IsA : is_list is_lit A
IsS : is_list is_lit S
UC : unit_clause A (or L1 C1) L @
Mem : mem L S
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
============================
sat_clause S (or L1 C1)
< case IsC.
Subgoal 2:
Variables: A S L NL C1 L1
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 (or L1 C1) L @
Mem : mem L S
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
H1 : is_lit L1
H2 : is_clause C1
============================
sat_clause S (or L1 C1)
< apply IH to _ _ _ UC3 _.
Subgoal 2:
Variables: A S L NL C1 L1
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 (or L1 C1) L @
Mem : mem L S
UC1 : negate_lit L1 NL
UC2 : mem NL A
UC3 : unit_clause A C1 L *
H1 : is_lit L1
H2 : is_clause C1
H3 : sat_clause S C1
============================
sat_clause S (or L1 C1)
< search.
Proof completed.
< Theorem remove_all_no_lookup :
forall Known ID KRest, remove_all Known ID KRest -> no_lookup KRest ID.
============================
forall Known ID KRest, remove_all Known ID KRest -> no_lookup KRest ID
< induction on 1.
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
============================
forall Known ID KRest, remove_all Known ID KRest @ -> no_lookup KRest ID
< intros RA.
Variables: Known ID KRest
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
RA : remove_all Known ID KRest @
============================
no_lookup KRest ID
< RA: case RA.
Subgoal 1:
Variables: ID
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
============================
no_lookup [] ID
< search.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
RA : remove_all IRest ID KRest *
============================
no_lookup KRest ID
< apply IH to RA.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
RA : remove_all IRest ID KRest *
H1 : no_lookup KRest ID
============================
no_lookup KRest ID
< search.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
no_lookup ((A, C)::Rest) ID
< apply IH to RA1.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest, remove_all Known ID KRest * -> no_lookup KRest ID
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
H1 : no_lookup Rest ID
============================
no_lookup ((A, C)::Rest) ID
< search.
Proof completed.
< Theorem remove_all_no_mem :
forall Known ID KRest C,
remove_all Known ID KRest -> mem (ID, C) KRest -> false.
============================
forall Known ID KRest C,
remove_all Known ID KRest -> mem (ID, C) KRest -> false
< induction on 1.
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
============================
forall Known ID KRest C,
remove_all Known ID KRest @ -> mem (ID, C) KRest -> false
< intros RA M.
Variables: Known ID KRest C
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
RA : remove_all Known ID KRest @
M : mem (ID, C) KRest
============================
false
< RA: case RA.
Subgoal 1:
Variables: ID C
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
M : mem (ID, C) []
============================
false
< case M.
Subgoal 2:
Variables: ID KRest C IRest C1
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
M : mem (ID, C) KRest
RA : remove_all IRest ID KRest *
============================
false
< apply IH to RA M.
Subgoal 3:
Variables: ID C Rest C1 A IRest
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
M : mem (ID, C) ((A, C1)::Rest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
false
< M: case M.
Subgoal 3.1:
Variables: Rest C1 A IRest
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
RA : A = A -> false
RA1 : remove_all IRest A Rest *
============================
false
< backchain RA.
Subgoal 3.2:
Variables: ID C Rest C1 A IRest
IH : forall Known ID KRest C,
remove_all Known ID KRest * -> mem (ID, C) KRest -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
M : mem (ID, C) Rest
============================
false
< apply IH to RA1 M.
Proof completed.
< Theorem remove_all_still_mem :
forall Known ID KRest Other C,
remove_all Known ID KRest -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest.
============================
forall Known ID KRest Other C,
remove_all Known ID KRest -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
< induction on 1.
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
============================
forall Known ID KRest Other C,
remove_all Known ID KRest @ -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
< intros RA M NEq.
Variables: Known ID KRest Other C
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
RA : remove_all Known ID KRest @
M : mem (Other, C) Known
NEq : ID = Other -> false
============================
mem (Other, C) KRest
< RA: case RA.
Subgoal 1:
Variables: ID Other C
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
M : mem (Other, C) []
NEq : ID = Other -> false
============================
mem (Other, C) []
< case M.
Subgoal 2:
Variables: ID KRest Other C IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
M : mem (Other, C) ((ID, C1)::IRest)
NEq : ID = Other -> false
RA : remove_all IRest ID KRest *
============================
mem (Other, C) KRest
< M: case M.
Subgoal 2.1:
Variables: ID KRest IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = ID -> false
RA : remove_all IRest ID KRest *
============================
mem (ID, C1) KRest
< apply NEq to _.
Subgoal 2.2:
Variables: ID KRest Other C IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = Other -> false
RA : remove_all IRest ID KRest *
M : mem (Other, C) IRest
============================
mem (Other, C) KRest
< apply IH to RA M NEq.
Subgoal 2.2:
Variables: ID KRest Other C IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = Other -> false
RA : remove_all IRest ID KRest *
M : mem (Other, C) IRest
H1 : mem (Other, C) KRest
============================
mem (Other, C) KRest
< search.
Subgoal 3:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
M : mem (Other, C) ((A, C1)::IRest)
NEq : ID = Other -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
mem (Other, C) ((A, C1)::Rest)
< M: case M.
Subgoal 3.1:
Variables: ID Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = A -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
mem (A, C1) ((A, C1)::Rest)
< search.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = Other -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
M : mem (Other, C) IRest
============================
mem (Other, C) ((A, C1)::Rest)
< apply IH to RA1 M NEq.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) Known -> (ID = Other -> false) ->
mem (Other, C) KRest
NEq : ID = Other -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
M : mem (Other, C) IRest
H1 : mem (Other, C) Rest
============================
mem (Other, C) ((A, C1)::Rest)
< search.
Proof completed.
< Theorem remove_all_mem_after :
forall Known ID KRest Other C,
remove_all Known ID KRest -> mem (Other, C) KRest -> mem (Other, C) Known.
============================
forall Known ID KRest Other C,
remove_all Known ID KRest -> mem (Other, C) KRest -> mem (Other, C) Known
< induction on 1.
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
============================
forall Known ID KRest Other C,
remove_all Known ID KRest @ -> mem (Other, C) KRest -> mem (Other, C) Known
< intros RA M.
Variables: Known ID KRest Other C
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
RA : remove_all Known ID KRest @
M : mem (Other, C) KRest
============================
mem (Other, C) Known
< RA: case RA.
Subgoal 1:
Variables: ID Other C
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
M : mem (Other, C) []
============================
mem (Other, C) []
< search.
Subgoal 2:
Variables: ID KRest Other C IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
M : mem (Other, C) KRest
RA : remove_all IRest ID KRest *
============================
mem (Other, C) ((ID, C1)::IRest)
< apply IH to RA M.
Subgoal 2:
Variables: ID KRest Other C IRest C1
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
M : mem (Other, C) KRest
RA : remove_all IRest ID KRest *
H1 : mem (Other, C) IRest
============================
mem (Other, C) ((ID, C1)::IRest)
< search.
Subgoal 3:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
M : mem (Other, C) ((A, C1)::Rest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
mem (Other, C) ((A, C1)::IRest)
< M: case M.
Subgoal 3.1:
Variables: ID Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
mem (A, C1) ((A, C1)::IRest)
< search.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
M : mem (Other, C) Rest
============================
mem (Other, C) ((A, C1)::IRest)
< apply IH to RA1 M.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known ID KRest Other C,
remove_all Known ID KRest * -> mem (Other, C) KRest -> mem (Other, C) Known
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
M : mem (Other, C) Rest
H1 : mem (Other, C) IRest
============================
mem (Other, C) ((A, C1)::IRest)
< search.
Proof completed.
< Theorem remove_all_lookup_after :
forall Known KRest ID Other C,
remove_all Known ID KRest -> lookup KRest Other C -> lookup Known Other C.
============================
forall Known KRest ID Other C,
remove_all Known ID KRest -> lookup KRest Other C -> lookup Known Other C
< induction on 1.
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
============================
forall Known KRest ID Other C,
remove_all Known ID KRest @ -> lookup KRest Other C -> lookup Known Other C
< intros RA Lkp.
Variables: Known KRest ID Other C
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
RA : remove_all Known ID KRest @
Lkp : lookup KRest Other C
============================
lookup Known Other C
< RA: case RA.
Subgoal 1:
Variables: ID Other C
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup [] Other C
============================
lookup [] Other C
< search.
Subgoal 2:
Variables: KRest ID Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest ID KRest *
============================
lookup ((ID, C1)::IRest) Other C
< assert ID = Other -> false.
Subgoal 2.1:
Variables: KRest ID Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest ID KRest *
============================
ID = Other -> false
< intros E.
Subgoal 2.1:
Variables: KRest ID Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest ID KRest *
E : ID = Other
============================
false
< case E.
Subgoal 2.1:
Variables: KRest Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest Other KRest *
============================
false
< M: apply lookup_mem to Lkp.
Subgoal 2.1:
Variables: KRest Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest Other KRest *
M : mem (Other, C) KRest
============================
false
< backchain remove_all_no_mem.
Subgoal 2:
Variables: KRest ID Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest ID KRest *
H1 : ID = Other -> false
============================
lookup ((ID, C1)::IRest) Other C
< apply IH to RA Lkp.
Subgoal 2:
Variables: KRest ID Other C IRest C1
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup KRest Other C
RA : remove_all IRest ID KRest *
H1 : ID = Other -> false
H2 : lookup IRest Other C
============================
lookup ((ID, C1)::IRest) Other C
< search.
Subgoal 3:
Variables: ID Other C Rest C1 A IRest
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
Lkp : lookup ((A, C1)::Rest) Other C
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
lookup ((A, C1)::IRest) Other C
< Lkp: case Lkp.
Subgoal 3.1:
Variables: ID Other C Rest IRest
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
RA : Other = ID -> false
RA1 : remove_all IRest ID Rest *
============================
lookup ((Other, C)::IRest) Other C
< search.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Lkp : A = Other -> false
Lkp1 : lookup Rest Other C
============================
lookup ((A, C1)::IRest) Other C
< apply IH to RA1 Lkp1.
Subgoal 3.2:
Variables: ID Other C Rest C1 A IRest
IH : forall Known KRest ID Other C,
remove_all Known ID KRest * -> lookup KRest Other C -> lookup Known Other C
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Lkp : A = Other -> false
Lkp1 : lookup Rest Other C
H1 : lookup IRest Other C
============================
lookup ((A, C1)::IRest) Other C
< search.
Proof completed.
< Theorem remove_all_is :
forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest ->
is_list (is_pair is_integer is_clause) KRest.
============================
forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest -> is_list (is_pair is_integer is_clause) KRest
< induction on 2.
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
============================
forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest @ ->
is_list (is_pair is_integer is_clause) KRest
< intros Is RA.
Variables: Known ID KRest
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) Known
RA : remove_all Known ID KRest @
============================
is_list (is_pair is_integer is_clause) KRest
< RA: case RA.
Subgoal 1:
Variables: ID
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) []
============================
is_list (is_pair is_integer is_clause) []
< search.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) ((ID, C)::IRest)
RA : remove_all IRest ID KRest *
============================
is_list (is_pair is_integer is_clause) KRest
< Is: case Is.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
RA : remove_all IRest ID KRest *
Is : is_pair is_integer is_clause (ID, C)
Is1 : is_list (is_pair is_integer is_clause) IRest
============================
is_list (is_pair is_integer is_clause) KRest
< apply IH to Is1 RA.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
RA : remove_all IRest ID KRest *
Is : is_pair is_integer is_clause (ID, C)
Is1 : is_list (is_pair is_integer is_clause) IRest
H1 : is_list (is_pair is_integer is_clause) KRest
============================
is_list (is_pair is_integer is_clause) KRest
< search.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
Is : is_list (is_pair is_integer is_clause) ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
is_list (is_pair is_integer is_clause) ((A, C)::Rest)
< Is: case Is.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Is : is_pair is_integer is_clause (A, C)
Is1 : is_list (is_pair is_integer is_clause) IRest
============================
is_list (is_pair is_integer is_clause) ((A, C)::Rest)
< apply IH to Is1 RA1.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
is_list (is_pair is_integer is_clause) Known -> remove_all Known ID KRest * ->
is_list (is_pair is_integer is_clause) KRest
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Is : is_pair is_integer is_clause (A, C)
Is1 : is_list (is_pair is_integer is_clause) IRest
H1 : is_list (is_pair is_integer is_clause) Rest
============================
is_list (is_pair is_integer is_clause) ((A, C)::Rest)
< search.
Proof completed.
< Theorem is_remove_all_exists :
forall Known ID,
is_list (is_pair is_integer is_clause) Known -> is_integer ID -> exists KRest,
remove_all Known ID KRest.
============================
forall Known ID,
is_list (is_pair is_integer is_clause) Known -> is_integer ID -> exists KRest,
remove_all Known ID KRest
< induction on 1.
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
============================
forall Known ID,
is_list (is_pair is_integer is_clause) Known @ -> is_integer ID -> exists KRest,
remove_all Known ID KRest
< intros IsKnown IsID.
Variables: Known ID
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsKnown : is_list (is_pair is_integer is_clause) Known @
IsID : is_integer ID
============================
exists KRest, remove_all Known ID KRest
< Is: case IsKnown.
Subgoal 1:
Variables: ID
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
============================
exists KRest, remove_all [] ID KRest
< search.
Subgoal 2:
Variables: ID T H
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
============================
exists KRest, remove_all (H::T) ID KRest
< apply IH to Is1 IsID.
Subgoal 2:
Variables: ID T H KRest
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : remove_all T ID KRest
============================
exists KRest, remove_all (H::T) ID KRest
< Is: case Is.
Subgoal 2:
Variables: ID T KRest B A
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : remove_all T ID KRest
Is : is_integer A
Is2 : is_clause B
============================
exists KRest, remove_all ((A, B)::T) ID KRest
< Or: apply is_integer_eq_or_not to Is IsID.
Subgoal 2:
Variables: ID T KRest B A
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : remove_all T ID KRest
Is : is_integer A
Is2 : is_clause B
Or : A = ID \/ (A = ID -> false)
============================
exists KRest, remove_all ((A, B)::T) ID KRest
< E: case Or.
Subgoal 2.1:
Variables: ID T KRest B
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : remove_all T ID KRest
Is : is_integer ID
Is2 : is_clause B
============================
exists KRest, remove_all ((ID, B)::T) ID KRest
< search.
Subgoal 2.2:
Variables: ID T KRest B A
IH : forall Known ID,
is_list (is_pair is_integer is_clause) Known * -> is_integer ID -> exists KRest,
remove_all Known ID KRest
IsID : is_integer ID
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : remove_all T ID KRest
Is : is_integer A
Is2 : is_clause B
E : A = ID -> false
============================
exists KRest, remove_all ((A, B)::T) ID KRest
< search.
Proof completed.
< Theorem remove_all_counts :
forall Known ID KRest IDC N,
remove_all Known ID KRest -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N.
============================
forall Known ID KRest IDC N,
remove_all Known ID KRest -> count IDC Known N -> ((exists C, IDC = (ID, C)) ->
false) -> count IDC KRest N
< induction on 1.
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
============================
forall Known ID KRest IDC N,
remove_all Known ID KRest @ -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
< intros RA C NEq.
Variables: Known ID KRest IDC N
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
RA : remove_all Known ID KRest @
C : count IDC Known N
NEq : (exists C, IDC = (ID, C)) -> false
============================
count IDC KRest N
< RA: case RA.
Subgoal 1:
Variables: ID IDC N
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
C : count IDC [] N
NEq : (exists C, IDC = (ID, C)) -> false
============================
count IDC [] N
< case C.
Subgoal 1:
Variables: ID IDC
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C, IDC = (ID, C)) -> false
============================
count IDC [] 0
< search.
Subgoal 2:
Variables: ID KRest IDC N IRest C
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
C : count IDC ((ID, C)::IRest) N
NEq : (exists C, IDC = (ID, C)) -> false
RA : remove_all IRest ID KRest *
============================
count IDC KRest N
< C: case C.
Subgoal 2.1:
Variables: ID KRest N IRest C N1
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C1, (ID, C) = (ID, C1)) -> false
RA : remove_all IRest ID KRest *
C : count (ID, C) IRest N1
C1 : 1 + N1 = N
============================
count (ID, C) KRest N
< apply NEq to _.
Subgoal 2.2:
Variables: ID KRest IDC N IRest C
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C, IDC = (ID, C)) -> false
RA : remove_all IRest ID KRest *
C : IDC = (ID, C) -> false
C1 : count IDC IRest N
============================
count IDC KRest N
< apply IH to RA C1 NEq.
Subgoal 2.2:
Variables: ID KRest IDC N IRest C
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C, IDC = (ID, C)) -> false
RA : remove_all IRest ID KRest *
C : IDC = (ID, C) -> false
C1 : count IDC IRest N
H1 : count IDC KRest N
============================
count IDC KRest N
< search.
Subgoal 3:
Variables: ID IDC N Rest C A IRest
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
C : count IDC ((A, C)::IRest) N
NEq : (exists C, IDC = (ID, C)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
count IDC ((A, C)::Rest) N
< C: case C.
Subgoal 3.1:
Variables: ID N Rest C A IRest N1
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C1, (A, C) = (ID, C1)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
C : count (A, C) IRest N1
C1 : 1 + N1 = N
============================
count (A, C) ((A, C)::Rest) N
< apply IH to RA1 C _.
Subgoal 3.1:
Variables: ID N Rest C A IRest N1
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C1, (A, C) = (ID, C1)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
C : count (A, C) IRest N1
C1 : 1 + N1 = N
H1 : count (A, C) Rest N1
============================
count (A, C) ((A, C)::Rest) N
< search.
Subgoal 3.2:
Variables: ID IDC N Rest C A IRest
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C, IDC = (ID, C)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
C : IDC = (A, C) -> false
C1 : count IDC IRest N
============================
count IDC ((A, C)::Rest) N
< apply IH to RA1 C1 _.
Subgoal 3.2:
Variables: ID IDC N Rest C A IRest
IH : forall Known ID KRest IDC N,
remove_all Known ID KRest * -> count IDC Known N -> ((exists C,
IDC = (ID, C)) -> false) -> count IDC KRest N
NEq : (exists C, IDC = (ID, C)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
C : IDC = (A, C) -> false
C1 : count IDC IRest N
H1 : count IDC Rest N
============================
count IDC ((A, C)::Rest) N
< search.
Proof completed.
< Theorem remove_all_permutation :
forall Known ID KRest P,
is_list (is_pair is_integer is_clause) Known -> is_integer ID -> remove_all Known ID KRest ->
permutation Known P -> exists P',
remove_all P ID P' /\ permutation KRest P'.
============================
forall Known ID KRest P,
is_list (is_pair is_integer is_clause) Known -> is_integer ID -> remove_all Known ID KRest ->
permutation Known P -> exists P', remove_all P ID P' /\ permutation KRest P'
< intros IsKnown IsID RA Prm.
Variables: Known ID KRest P
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< Prm': apply permutation_symmetric to Prm.
Variables: Known ID KRest P
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< IsP: apply permutation_is to IsKnown Prm'.
Variables: Known ID KRest P
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< RAP: apply is_remove_all_exists to IsP IsID.
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< IsKRest: apply remove_all_is to IsKnown RA.
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< IsKRest1: apply remove_all_is to IsP RAP.
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< assert forall X NL NP,
is_pair is_integer is_clause X -> count X KRest NL -> count X KRest1 NP -> NL = NP.
Subgoal 1:
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
============================
forall X NL NP,
is_pair is_integer is_clause X -> count X KRest NL -> count X KRest1 NP -> NL = NP
< intros IsX CKRest CKRest1.
Subgoal 1:
Variables: Known ID KRest P KRest1 X NL NP
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause X
CKRest : count X KRest NL
CKRest1 : count X KRest1 NP
============================
NL = NP
< Is: case IsX (keep).
Subgoal 1:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
============================
NL = NP
< Or: apply is_integer_eq_or_not to Is IsID.
Subgoal 1:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
Or : A = ID \/ (A = ID -> false)
============================
NL = NP
< E: case Or.
Subgoal 1.1:
Variables: Known ID KRest P KRest1 NL NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest NL
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
============================
NL = NP
< GEq: apply count_geq_0 to CKRest.
Subgoal 1.1:
Variables: Known ID KRest P KRest1 NL NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest NL
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NL >= 0
============================
NL = NP
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 1.1:
Variables: Known ID KRest P KRest1 NL NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest NL
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NL >= 0
Or : NL > 0 \/ NL = 0
============================
NL = NP
< L: case Or.
Subgoal 1.1.1:
Variables: Known ID KRest P KRest1 NL NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest NL
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NL >= 0
L : NL > 0
============================
NL = NP
< M: apply count_mem to CKRest L.
Subgoal 1.1.1:
Variables: Known ID KRest P KRest1 NL NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest NL
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NL >= 0
L : NL > 0
M : mem (ID, B) KRest
============================
NL = NP
< apply remove_all_no_mem to RA M.
Subgoal 1.1.2:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : 0 >= 0
============================
0 = NP
< clear GEq.
Subgoal 1.1.2:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
============================
0 = NP
< GEq: apply count_geq_0 to CKRest1.
Subgoal 1.1.2:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NP >= 0
============================
0 = NP
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 1.1.2:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NP >= 0
Or : NP > 0 \/ NP = 0
============================
0 = NP
< L: case Or.
Subgoal 1.1.2.1:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NP >= 0
L : NP > 0
============================
0 = NP
< M: apply count_mem to CKRest1 L.
Subgoal 1.1.2.1:
Variables: Known ID KRest P KRest1 NP B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 NP
Is : is_integer ID
Is1 : is_clause B
GEq : NP >= 0
L : NP > 0
M : mem (ID, B) KRest1
============================
0 = NP
< apply remove_all_no_mem to RAP M.
Subgoal 1.1.2.2:
Variables: Known ID KRest P KRest1 B
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, B)
CKRest : count (ID, B) KRest 0
CKRest1 : count (ID, B) KRest1 0
Is : is_integer ID
Is1 : is_clause B
GEq : 0 >= 0
============================
0 = 0
< search.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
============================
NL = NP
< assert (exists C, (A, B) = (ID, C)) -> false.
Subgoal 1.2.1:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
============================
(exists C, (A, B) = (ID, C)) -> false
< intros Ex.
Subgoal 1.2.1:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
Ex : exists C, (A, B) = (ID, C)
============================
false
< case Ex.
Subgoal 1.2.1:
Variables: Known ID KRest P KRest1 NL NP C
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (ID, C)
CKRest : count (ID, C) KRest NL
CKRest1 : count (ID, C) KRest1 NP
Is : is_integer ID
Is1 : is_clause C
E : ID = ID -> false
============================
false
< backchain E.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
============================
NL = NP
< CKnown: apply is_count_exists to IsKnown IsX.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A N
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
============================
NL = NP
< CKRest': apply remove_all_counts to RA CKnown _.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A N
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
CKRest' : count (A, B) KRest N
============================
NL = NP
< CP: apply is_count_exists to IsP IsX.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A N N1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
CKRest' : count (A, B) KRest N
CP : count (A, B) P N1
============================
NL = NP
< CKRest1': apply remove_all_counts to RAP CP _.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NL NP B A N N1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest NL
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
CKRest' : count (A, B) KRest N
CP : count (A, B) P N1
CKRest1' : count (A, B) KRest1 N1
============================
NL = NP
< apply count_unique to CKRest CKRest'.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 NP B A N N1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest N
CKRest1 : count (A, B) KRest1 NP
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
CKRest' : count (A, B) KRest N
CP : count (A, B) P N1
CKRest1' : count (A, B) KRest1 N1
============================
N = NP
< apply count_unique to CKRest1 CKRest1'.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 B A N N1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest N
CKRest1 : count (A, B) KRest1 N1
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N
CKRest' : count (A, B) KRest N
CP : count (A, B) P N1
CKRest1' : count (A, B) KRest1 N1
============================
N = N1
< apply permutation_counts to _ CKnown CP.
Subgoal 1.2:
Variables: Known ID KRest P KRest1 B A N1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
IsX : is_pair is_integer is_clause (A, B)
CKRest : count (A, B) KRest N1
CKRest1 : count (A, B) KRest1 N1
Is : is_integer A
Is1 : is_clause B
E : A = ID -> false
H1 : (exists C, (A, B) = (ID, C)) -> false
CKnown : count (A, B) Known N1
CKRest' : count (A, B) KRest N1
CP : count (A, B) P N1
CKRest1' : count (A, B) KRest1 N1
============================
N1 = N1
< search.
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X KRest NL -> count X KRest1 NP ->
NL = NP
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< apply counts_permutation to IsKRest IsKRest1 _.
Variables: Known ID KRest P KRest1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsID : is_integer ID
RA : remove_all Known ID KRest
Prm : permutation Known P
Prm' : permutation P Known
IsP : is_list (is_pair is_integer is_clause) P
RAP : remove_all P ID KRest1
IsKRest : is_list (is_pair is_integer is_clause) KRest
IsKRest1 : is_list (is_pair is_integer is_clause) KRest1
H1 : forall X NL NP,
is_pair is_integer is_clause X -> count X KRest NL -> count X KRest1 NP ->
NL = NP
H2 : permutation KRest KRest1
============================
exists P', remove_all P ID P' /\ permutation KRest P'
< search.
Proof completed.
< Define good_clause_list : (list (pair integer clause)) -> prop by
good_clause_list Known :=
forall ID C1 KRest C2,
select (ID, C1) KRest Known -> mem (ID, C2) KRest -> false.
< Theorem good_clause_list_drop :
forall L IDC, good_clause_list (IDC::L) -> good_clause_list L.
============================
forall L IDC, good_clause_list (IDC::L) -> good_clause_list L
< intros GCL.
Variables: L IDC
GCL : good_clause_list (IDC::L)
============================
good_clause_list L
< GCL: case GCL.
Variables: L IDC
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest (IDC::L) -> mem (ID, C2) KRest -> false
============================
good_clause_list L
< unfold .
Variables: L IDC
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest (IDC::L) -> mem (ID, C2) KRest -> false
============================
forall ID C1 KRest C2, select (ID, C1) KRest L -> mem (ID, C2) KRest -> false
< intros S M.
Variables: L IDC ID C1 KRest C2
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest (IDC::L) -> mem (ID, C2) KRest -> false
S : select (ID, C1) KRest L
M : mem (ID, C2) KRest
============================
false
< backchain GCL to
ID = ID
C1 = C1.
Proof completed.
< Theorem good_clause_list_select :
forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L -> good_clause_list Rest.
============================
forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L -> good_clause_list Rest
< induction on 2.
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
============================
forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L @ -> good_clause_list Rest
< intros GCL S.
Variables: L Rest ID C
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list L
S : select (ID, C) Rest L @
============================
good_clause_list Rest
< S: case S.
Subgoal 1:
Variables: Rest ID C
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID, C)::Rest)
============================
good_clause_list Rest
< apply good_clause_list_drop to GCL.
Subgoal 1:
Variables: Rest ID C
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID, C)::Rest)
H1 : good_clause_list Rest
============================
good_clause_list Rest
< search.
Subgoal 2:
Variables: ID C L2 I L1
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
============================
good_clause_list (I::L1)
< GCL': apply good_clause_list_drop to GCL.
Subgoal 2:
Variables: ID C L2 I L1
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
============================
good_clause_list (I::L1)
< GCL1: apply IH to GCL' S.
Subgoal 2:
Variables: ID C L2 I L1
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
============================
good_clause_list (I::L1)
< unfold .
Subgoal 2:
Variables: ID C L2 I L1
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
============================
forall ID C1 KRest C2,
select (ID, C1) KRest (I::L1) -> mem (ID, C2) KRest -> false
< intros Slct M.
Subgoal 2:
Variables: ID C L2 I L1 ID1 C1 KRest C2
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) KRest (I::L1)
M : mem (ID1, C2) KRest
============================
false
< Slct: case Slct.
Subgoal 2.1:
Variables: ID C L2 L1 ID1 C1 C2
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID1, C1)::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
M : mem (ID1, C2) L1
============================
false
< M': apply mem_after_select_before to S M.
Subgoal 2.1:
Variables: ID C L2 L1 ID1 C1 C2
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID1, C1)::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
M : mem (ID1, C2) L1
M' : mem (ID1, C2) L2
============================
false
< GCL: case GCL.
Subgoal 2.1:
Variables: ID C L2 L1 ID1 C1 C2
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
M : mem (ID1, C2) L1
M' : mem (ID1, C2) L2
GCL : forall ID C2 KRest C3,
select (ID, C2) KRest ((ID1, C1)::L2) -> mem (ID, C3) KRest -> false
============================
false
< apply GCL to _ M'.
Subgoal 2.2:
Variables: ID C L2 I L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
M : mem (ID1, C2) (I::L3)
Slct : select (ID1, C1) L3 L1
============================
false
< M: case M.
Subgoal 2.2.1:
Variables: ID C L2 L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID1, C2)::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) L3 L1
============================
false
< MS: apply select_mem to Slct.
Subgoal 2.2.1:
Variables: ID C L2 L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID1, C2)::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) L3 L1
MS : mem (ID1, C1) L1
============================
false
< M': apply mem_after_select_before to S MS.
Subgoal 2.2.1:
Variables: ID C L2 L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list ((ID1, C2)::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) L3 L1
MS : mem (ID1, C1) L1
M' : mem (ID1, C1) L2
============================
false
< GCL: case GCL.
Subgoal 2.2.1:
Variables: ID C L2 L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) L3 L1
MS : mem (ID1, C1) L1
M' : mem (ID1, C1) L2
GCL : forall ID C1 KRest C3,
select (ID, C1) KRest ((ID1, C2)::L2) -> mem (ID, C3) KRest -> false
============================
false
< backchain GCL.
Subgoal 2.2.2:
Variables: ID C L2 I L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
GCL1 : good_clause_list L1
Slct : select (ID1, C1) L3 L1
M : mem (ID1, C2) L3
============================
false
< GCL1: case GCL1.
Subgoal 2.2.2:
Variables: ID C L2 I L1 ID1 C1 C2 L3
IH : forall L Rest ID C,
good_clause_list L -> select (ID, C) Rest L * -> good_clause_list Rest
GCL : good_clause_list (I::L2)
S : select (ID, C) L1 L2 *
GCL' : good_clause_list L2
Slct : select (ID1, C1) L3 L1
M : mem (ID1, C2) L3
GCL1 : forall ID C1 KRest C2,
select (ID, C1) KRest L1 -> mem (ID, C2) KRest -> false
============================
false
< apply GCL1 to Slct M.
Proof completed.
< Theorem good_clause_list_remove_all :
forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest -> good_clause_list KRest.
============================
forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest -> good_clause_list KRest
< induction on 2.
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
============================
forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest @ -> good_clause_list KRest
< intros GCL RA.
Variables: Known ID KRest
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list Known
RA : remove_all Known ID KRest @
============================
good_clause_list KRest
< RA: case RA.
Subgoal 1:
Variables: ID
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list []
============================
good_clause_list []
< search.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((ID, C)::IRest)
RA : remove_all IRest ID KRest *
============================
good_clause_list KRest
< GCL': apply good_clause_list_drop to GCL.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((ID, C)::IRest)
RA : remove_all IRest ID KRest *
GCL' : good_clause_list IRest
============================
good_clause_list KRest
< apply IH to GCL' RA.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((ID, C)::IRest)
RA : remove_all IRest ID KRest *
GCL' : good_clause_list IRest
H1 : good_clause_list KRest
============================
good_clause_list KRest
< search.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
good_clause_list ((A, C)::Rest)
< GCL': apply good_clause_list_drop to GCL.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
============================
good_clause_list ((A, C)::Rest)
< GCLR: apply IH to GCL' RA1.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
============================
good_clause_list ((A, C)::Rest)
< unfold .
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
============================
forall ID C1 KRest C2,
select (ID, C1) KRest ((A, C)::Rest) -> mem (ID, C2) KRest -> false
< intros S M.
Subgoal 3:
Variables: ID Rest C A IRest ID1 C1 KRest1 C2
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
S : select (ID1, C1) KRest1 ((A, C)::Rest)
M : mem (ID1, C2) KRest1
============================
false
< S: case S.
Subgoal 3.1:
Variables: ID Rest C A IRest C2
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (A, C2) Rest
============================
false
< M': apply remove_all_mem_after to RA1 M.
Subgoal 3.1:
Variables: ID Rest C A IRest C2
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (A, C2) Rest
M' : mem (A, C2) IRest
============================
false
< GCL: case GCL.
Subgoal 3.1:
Variables: ID Rest C A IRest C2
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (A, C2) Rest
M' : mem (A, C2) IRest
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest ((A, C)::IRest) -> mem (ID, C2) KRest -> false
============================
false
< backchain GCL.
Subgoal 3.2:
Variables: ID Rest C A IRest ID1 C1 C2 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (ID1, C2) ((A, C)::L1)
S : select (ID1, C1) L1 Rest
============================
false
< M': apply select_mem to S.
Subgoal 3.2:
Variables: ID Rest C A IRest ID1 C1 C2 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (ID1, C2) ((A, C)::L1)
S : select (ID1, C1) L1 Rest
M' : mem (ID1, C1) Rest
============================
false
< MS: apply remove_all_mem_after to RA1 M'.
Subgoal 3.2:
Variables: ID Rest C A IRest ID1 C1 C2 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
M : mem (ID1, C2) ((A, C)::L1)
S : select (ID1, C1) L1 Rest
M' : mem (ID1, C1) Rest
MS : mem (ID1, C1) IRest
============================
false
< M: case M.
Subgoal 3.2.1:
Variables: ID Rest C A IRest C1 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
S : select (A, C1) L1 Rest
M' : mem (A, C1) Rest
MS : mem (A, C1) IRest
============================
false
< GCL: case GCL.
Subgoal 3.2.1:
Variables: ID Rest C A IRest C1 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
S : select (A, C1) L1 Rest
M' : mem (A, C1) Rest
MS : mem (A, C1) IRest
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest ((A, C)::IRest) -> mem (ID, C2) KRest -> false
============================
false
< backchain GCL.
Subgoal 3.2.2:
Variables: ID Rest C A IRest ID1 C1 C2 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
GCLR : good_clause_list Rest
S : select (ID1, C1) L1 Rest
M' : mem (ID1, C1) Rest
MS : mem (ID1, C1) IRest
M : mem (ID1, C2) L1
============================
false
< GCLR: case GCLR.
Subgoal 3.2.2:
Variables: ID Rest C A IRest ID1 C1 C2 L1
IH : forall Known ID KRest,
good_clause_list Known -> remove_all Known ID KRest * -> good_clause_list KRest
GCL : good_clause_list ((A, C)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
GCL' : good_clause_list IRest
S : select (ID1, C1) L1 Rest
M' : mem (ID1, C1) Rest
MS : mem (ID1, C1) IRest
M : mem (ID1, C2) L1
GCLR : forall ID C1 KRest C2,
select (ID, C1) KRest Rest -> mem (ID, C2) KRest -> false
============================
false
< backchain GCLR.
Proof completed.
< Theorem good_clause_list_add :
forall Known ID C,
good_clause_list Known -> ((exists C', mem (ID, C') Known) -> false) -> good_clause_list ((ID, C)::Known).
============================
forall Known ID C,
good_clause_list Known -> ((exists C', mem (ID, C') Known) -> false) -> good_clause_list ((ID, C)::Known)
< intros GCL NMem.
Variables: Known ID C
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
============================
good_clause_list ((ID, C)::Known)
< unfold .
Variables: Known ID C
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
============================
forall ID1 C1 KRest C2,
select (ID1, C1) KRest ((ID, C)::Known) -> mem (ID1, C2) KRest -> false
< intros S M.
Variables: Known ID C ID1 C1 KRest C2
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
S : select (ID1, C1) KRest ((ID, C)::Known)
M : mem (ID1, C2) KRest
============================
false
< S: case S.
Subgoal 1:
Variables: Known ID C C2
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
M : mem (ID, C2) Known
============================
false
< backchain NMem.
Subgoal 2:
Variables: Known ID C ID1 C1 C2 L1
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
M : mem (ID1, C2) ((ID, C)::L1)
S : select (ID1, C1) L1 Known
============================
false
< M: case M.
Subgoal 2.1:
Variables: Known ID C C1 L1
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
S : select (ID, C1) L1 Known
============================
false
< M: apply select_mem to S.
Subgoal 2.1:
Variables: Known ID C C1 L1
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
S : select (ID, C1) L1 Known
M : mem (ID, C1) Known
============================
false
< backchain NMem.
Subgoal 2.2:
Variables: Known ID C ID1 C1 C2 L1
GCL : good_clause_list Known
NMem : (exists C', mem (ID, C') Known) -> false
S : select (ID1, C1) L1 Known
M : mem (ID1, C2) L1
============================
false
< GCL: case GCL.
Subgoal 2.2:
Variables: Known ID C ID1 C1 C2 L1
NMem : (exists C', mem (ID, C') Known) -> false
S : select (ID1, C1) L1 Known
M : mem (ID1, C2) L1
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest Known -> mem (ID, C2) KRest -> false
============================
false
< backchain GCL.
Proof completed.
< Theorem good_clause_list_remove_all_add :
forall Known ID KRest C,
good_clause_list Known -> remove_all Known ID KRest -> good_clause_list ((ID, C)::KRest).
============================
forall Known ID KRest C,
good_clause_list Known -> remove_all Known ID KRest -> good_clause_list ((ID, C)::KRest)
< intros GCL RA.
Variables: Known ID KRest C
GCL : good_clause_list Known
RA : remove_all Known ID KRest
============================
good_clause_list ((ID, C)::KRest)
< apply good_clause_list_remove_all to GCL RA.
Variables: Known ID KRest C
GCL : good_clause_list Known
RA : remove_all Known ID KRest
H1 : good_clause_list KRest
============================
good_clause_list ((ID, C)::KRest)
< backchain good_clause_list_add.
Variables: Known ID KRest C
GCL : good_clause_list Known
RA : remove_all Known ID KRest
H1 : good_clause_list KRest
============================
(exists C', mem (ID, C') KRest) -> false
< intros M.
Variables: Known ID KRest C
GCL : good_clause_list Known
RA : remove_all Known ID KRest
H1 : good_clause_list KRest
M : exists C', mem (ID, C') KRest
============================
false
< M: case M.
Variables: Known ID KRest C C'
GCL : good_clause_list Known
RA : remove_all Known ID KRest
H1 : good_clause_list KRest
M : mem (ID, C') KRest
============================
false
< apply remove_all_no_mem to RA M.
Proof completed.
< Theorem permutation_good_clause_list :
forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P -> good_clause_list L ->
good_clause_list P.
============================
forall L P,
is_list (is_pair is_integer is_clause) P -> permutation L P -> good_clause_list L ->
good_clause_list P
< intros IsP Prm GCL.
Variables: L P
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
============================
good_clause_list P
< unfold .
Variables: L P
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
============================
forall ID C1 KRest C2, select (ID, C1) KRest P -> mem (ID, C2) KRest -> false
< intros S MK.
Variables: L P ID C1 KRest C2
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
============================
false
< MS: apply select_mem to S.
Variables: L P ID C1 KRest C2
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
============================
false
< Prm': apply permutation_symmetric to Prm.
Variables: L P ID C1 KRest C2
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
============================
false
< ML1: apply permutation_mem to Prm' MS.
Variables: L P ID C1 KRest C2
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
============================
false
< SL: apply mem_select to ML1.
Variables: L P ID C1 KRest C2 L'
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
SL : select (ID, C1) L' L
============================
false
< IsL: apply permutation_is to IsP Prm.
Variables: L P ID C1 KRest C2 L'
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
SL : select (ID, C1) L' L
IsL : is_list (is_pair is_integer is_clause) L
============================
false
< P': apply selects_permutation to _ _ Prm' S SL.
Variables: L P ID C1 KRest C2 L'
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
SL : select (ID, C1) L' L
IsL : is_list (is_pair is_integer is_clause) L
P' : permutation KRest L'
============================
false
< ML': apply permutation_mem to P' MK.
Variables: L P ID C1 KRest C2 L'
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
GCL : good_clause_list L
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
SL : select (ID, C1) L' L
IsL : is_list (is_pair is_integer is_clause) L
P' : permutation KRest L'
ML' : mem (ID, C2) L'
============================
false
< GCL: case GCL.
Variables: L P ID C1 KRest C2 L'
IsP : is_list (is_pair is_integer is_clause) P
Prm : permutation L P
S : select (ID, C1) KRest P
MK : mem (ID, C2) KRest
MS : mem (ID, C1) P
Prm' : permutation P L
ML1 : mem (ID, C1) L
SL : select (ID, C1) L' L
IsL : is_list (is_pair is_integer is_clause) L
P' : permutation KRest L'
ML' : mem (ID, C2) L'
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest L -> mem (ID, C2) KRest -> false
============================
false
< backchain GCL.
Proof completed.
< Theorem good_clause_list_mems :
forall L X CA CB,
good_clause_list L -> mem (X, CA) L -> mem (X, CB) L -> CA = CB.
============================
forall L X CA CB,
good_clause_list L -> mem (X, CA) L -> mem (X, CB) L -> CA = CB
< induction on 2.
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
============================
forall L X CA CB,
good_clause_list L -> mem (X, CA) L @ -> mem (X, CB) L -> CA = CB
< intros GCL MA MB.
Variables: L X CA CB
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list L
MA : mem (X, CA) L @
MB : mem (X, CB) L
============================
CA = CB
< MA: case MA.
Subgoal 1:
Variables: X CA CB Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list ((X, CA)::Rest)
MB : mem (X, CB) ((X, CA)::Rest)
============================
CA = CB
< MB: case MB.
Subgoal 1.1:
Variables: X CA Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list ((X, CA)::Rest)
============================
CA = CA
< search.
Subgoal 1.2:
Variables: X CA CB Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list ((X, CA)::Rest)
MB : mem (X, CB) Rest
============================
CA = CB
< GCL: case GCL.
Subgoal 1.2:
Variables: X CA CB Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
MB : mem (X, CB) Rest
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest ((X, CA)::Rest) -> mem (ID, C2) KRest -> false
============================
CA = CB
< apply GCL to _ MB.
Subgoal 2:
Variables: X CA CB Rest I
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list (I::Rest)
MB : mem (X, CB) (I::Rest)
MA : mem (X, CA) Rest *
============================
CA = CB
< MB: case MB.
Subgoal 2.1:
Variables: X CA CB Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list ((X, CB)::Rest)
MA : mem (X, CA) Rest *
============================
CA = CB
< GCL: case GCL.
Subgoal 2.1:
Variables: X CA CB Rest
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
MA : mem (X, CA) Rest *
GCL : forall ID C1 KRest C2,
select (ID, C1) KRest ((X, CB)::Rest) -> mem (ID, C2) KRest -> false
============================
CA = CB
< apply GCL to _ MA.
Subgoal 2.2:
Variables: X CA CB Rest I
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list (I::Rest)
MA : mem (X, CA) Rest *
MB : mem (X, CB) Rest
============================
CA = CB
< GCL': apply good_clause_list_drop to GCL.
Subgoal 2.2:
Variables: X CA CB Rest I
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list (I::Rest)
MA : mem (X, CA) Rest *
MB : mem (X, CB) Rest
GCL' : good_clause_list Rest
============================
CA = CB
< apply IH to GCL' MA MB.
Subgoal 2.2:
Variables: X CB Rest I
IH : forall L X CA CB,
good_clause_list L -> mem (X, CA) L * -> mem (X, CB) L -> CA = CB
GCL : good_clause_list (I::Rest)
MA : mem (X, CB) Rest *
MB : mem (X, CB) Rest
GCL' : good_clause_list Rest
============================
CB = CB
< search.
Proof completed.
< Theorem rupProof_help_all_mem :
forall Known A Proof ID,
rupProof_help Known A Proof -> mem ID Proof -> exists C,
lookup Known ID C.
============================
forall Known A Proof ID,
rupProof_help Known A Proof -> mem ID Proof -> exists C, lookup Known ID C
< induction on 1.
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
============================
forall Known A Proof ID,
rupProof_help Known A Proof @ -> mem ID Proof -> exists C, lookup Known ID C
< intros RUP Mem.
Variables: Known A Proof ID
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : rupProof_help Known A Proof @
Mem : mem ID Proof
============================
exists C, lookup Known ID C
< RUP: case RUP.
Subgoal 1:
Variables: Known A ID C ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
Mem : mem ID [ID1]
RUP : lookup Known ID1 C
RUP1 : unsat_clause A C
============================
exists C, lookup Known ID C
< Mem: case Mem.
Subgoal 1.1:
Variables: Known A C ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : lookup Known ID1 C
RUP1 : unsat_clause A C
============================
exists C, lookup Known ID1 C
< search.
Subgoal 1.2:
Variables: Known A ID C ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : lookup Known ID1 C
RUP1 : unsat_clause A C
Mem : mem ID []
============================
exists C, lookup Known ID C
< case Mem.
Subgoal 2:
Variables: Known A ID C L Prf ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
Mem : mem ID (ID1::Prf)
RUP : lookup Known ID1 C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
============================
exists C, lookup Known ID C
< Mem: case Mem.
Subgoal 2.1:
Variables: Known A C L Prf ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : lookup Known ID1 C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
============================
exists C, lookup Known ID1 C
< search.
Subgoal 2.2:
Variables: Known A ID C L Prf ID1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : lookup Known ID1 C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
Mem : mem ID Prf
============================
exists C, lookup Known ID C
< apply IH to RUP2 Mem.
Subgoal 2.2:
Variables: Known A ID C L Prf ID1 C1
IH : forall Known A Proof ID,
rupProof_help Known A Proof * -> mem ID Proof -> exists C,
lookup Known ID C
RUP : lookup Known ID1 C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
Mem : mem ID Prf
H1 : lookup Known ID C1
============================
exists C, lookup Known ID C
< search.
Proof completed.
< Theorem rupProof_help_is :
forall Known A Proof,
rupProof_help Known A Proof -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof.
============================
forall Known A Proof,
rupProof_help Known A Proof -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
< induction on 1.
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
============================
forall Known A Proof,
rupProof_help Known A Proof @ -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
< intros RUP IsK.
Variables: Known A Proof
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
RUP : rupProof_help Known A Proof @
IsK : is_list (is_pair is_integer is_clause) Known
============================
is_list is_integer Proof
< RUP: case RUP.
Subgoal 1:
Variables: Known A C ID
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
IsK : is_list (is_pair is_integer is_clause) Known
RUP : lookup Known ID C
RUP1 : unsat_clause A C
============================
is_list is_integer [ID]
< apply lookup_is_key to IsK RUP.
Subgoal 1:
Variables: Known A C ID
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
IsK : is_list (is_pair is_integer is_clause) Known
RUP : lookup Known ID C
RUP1 : unsat_clause A C
H1 : is_integer ID
============================
is_list is_integer [ID]
< search.
Subgoal 2:
Variables: Known A C L Prf ID
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
IsK : is_list (is_pair is_integer is_clause) Known
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
============================
is_list is_integer (ID::Prf)
< apply lookup_is_key to IsK RUP.
Subgoal 2:
Variables: Known A C L Prf ID
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
IsK : is_list (is_pair is_integer is_clause) Known
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
H1 : is_integer ID
============================
is_list is_integer (ID::Prf)
< apply IH to RUP2 IsK.
Subgoal 2:
Variables: Known A C L Prf ID
IH : forall Known A Proof,
rupProof_help Known A Proof * -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof
IsK : is_list (is_pair is_integer is_clause) Known
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
H1 : is_integer ID
H2 : is_list is_integer Prf
============================
is_list is_integer (ID::Prf)
< search.
Proof completed.
< Theorem rupProof_help_unsat :
forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof -> (forall (L : lit), mem L A -> mem L Sat) ->
(forall (InID : integer) (InC : clause),
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false.
============================
forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
< induction on 4.
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
============================
forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof @ -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
< intros IsKnown IsA IsSat RUP Expand Sat GA_A GA_Sat.
Variables: Known A Sat Proof
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
RUP : rupProof_help Known A Proof @
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
============================
false
< RUP: case RUP.
Subgoal 1:
Variables: Known A Sat C ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unsat_clause A C
============================
false
< SatC: apply Sat to RUP.
Subgoal 1:
Variables: Known A Sat C ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unsat_clause A C
SatC : sat_clause Sat C
============================
false
< M: apply lookup_mem to RUP.
Subgoal 1:
Variables: Known A Sat C ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unsat_clause A C
SatC : sat_clause Sat C
M : mem (ID, C) Known
============================
false
< Is: apply mem_is to _ M.
Subgoal 1:
Variables: Known A Sat ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unsat_clause A C1
SatC : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
============================
false
< UnsatC: apply unsat_clause_orderless to _ _ _ RUP1 Expand.
Subgoal 1:
Variables: Known A Sat ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unsat_clause A C1
SatC : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
UnsatC : unsat_clause Sat C1
============================
false
< apply unsat_sat_clause to _ _ UnsatC SatC _.
Subgoal 2:
Variables: Known A Sat C L Prf ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
============================
false
< Sat: apply Sat to RUP.
Subgoal 2:
Variables: Known A Sat C L Prf ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C
============================
false
< M: apply lookup_mem to RUP.
Subgoal 2:
Variables: Known A Sat C L Prf ID
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C
M : mem (ID, C) Known
============================
false
< Is: apply mem_is to _ M.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
============================
false
< MemL: apply unit_clause_expand to _ _ _ RUP1 _ GA_A GA_Sat Expand.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
============================
false
< MemImp: assert forall (X : lit),
mem X (L::A) -> mem X Sat.
Subgoal 2.1:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
============================
forall X, mem X (L::A) -> mem X Sat
< intros Mem.
Subgoal 2.1:
Variables: Known A Sat L Prf ID1 C1 X
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
Mem : mem X (L::A)
============================
mem X Sat
< Mem: case Mem.
Subgoal 2.1.1:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
============================
mem L Sat
< search.
Subgoal 2.1.2:
Variables: Known A Sat L Prf ID1 C1 X
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
Mem : mem X A
============================
mem X Sat
< backchain Expand.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
============================
false
< IsL: apply unit_clause_is to _ _ RUP1.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
============================
false
< backchain IH to
Known = Known
A = L::A
Sat = Sat
Proof = Prf.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
============================
good_assignment (L::A)
< unfold .
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
============================
forall L1 NL, mem L1 (L::A) -> negate_lit L1 NL -> mem NL (L::A) -> false
< intros MemL1 NegL1 MemNL.
Subgoal 2:
Variables: Known A Sat L Prf ID1 C1 L1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
MemL1 : mem L1 (L::A)
NegL1 : negate_lit L1 NL
MemNL : mem NL (L::A)
============================
false
< MemL1: case MemL1.
Subgoal 2.2:
Variables: Known A Sat L Prf ID1 C1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L NL
MemNL : mem NL (L::A)
============================
false
< MemNL: case MemNL.
Subgoal 2.2.1:
Variables: Known A Sat L Prf ID1 C1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L L
============================
false
< apply negate_lit_not_same to _ NegL1.
Subgoal 2.2.2:
Variables: Known A Sat L Prf ID1 C1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L NL
MemNL : mem NL A
============================
false
< apply unit_clause_not_assigned_negate to _ _ RUP1 NegL1 MemNL.
Subgoal 2.3:
Variables: Known A Sat L Prf ID1 C1 L1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 NL
MemNL : mem NL (L::A)
MemL1 : mem L1 A
============================
false
< MemNL: case MemNL.
Subgoal 2.3.1:
Variables: Known A Sat L Prf ID1 C1 L1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 L
MemL1 : mem L1 A
============================
false
< apply mem_is_lit to _ MemL1.
Subgoal 2.3.1:
Variables: Known A Sat L Prf ID1 C1 L1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 L
MemL1 : mem L1 A
H1 : is_lit L1
============================
false
< apply negate_lit_reverse to _ NegL1.
Subgoal 2.3.1:
Variables: Known A Sat L Prf ID1 C1 L1
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 L
MemL1 : mem L1 A
H1 : is_lit L1
H2 : negate_lit L L1
============================
false
< apply unit_clause_not_assigned_negate to _ _ RUP1 _ MemL1.
Subgoal 2.3.2:
Variables: Known A Sat L Prf ID1 C1 L1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_A : good_assignment A
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 NL
MemL1 : mem L1 A
MemNL : mem NL A
============================
false
< GA_A: case GA_A.
Subgoal 2.3.2:
Variables: Known A Sat L Prf ID1 C1 L1 NL
IH : forall Known A Sat Proof,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit A -> is_list is_lit Sat ->
rupProof_help Known A Proof * -> (forall L, mem L A -> mem L Sat) -> (forall InID InC,
lookup Known InID InC -> sat_clause Sat InC) -> good_assignment A -> good_assignment Sat ->
false
IsKnown : is_list (is_pair is_integer is_clause) Known
IsA : is_list is_lit A
IsSat : is_list is_lit Sat
Expand : forall L, mem L A -> mem L Sat
Sat : forall InID InC, lookup Known InID InC -> sat_clause Sat InC
GA_Sat : good_assignment Sat
RUP : lookup Known ID1 C1
RUP1 : unit_clause A C1 L
RUP2 : rupProof_help Known (L::A) Prf *
Sat1 : sat_clause Sat C1
M : mem (ID1, C1) Known
Is : is_integer ID1
Is1 : is_clause C1
MemL : mem L Sat
MemImp : forall X, mem X (L::A) -> mem X Sat
IsL : is_lit L
NegL1 : negate_lit L1 NL
MemL1 : mem L1 A
MemNL : mem NL A
GA_A : forall L NL, mem L A -> negate_lit L NL -> mem NL A -> false
============================
false
< apply GA_A to MemL1 NegL1 _.
Proof completed.
< Theorem rupProof_help_orderless :
forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf.
============================
forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
< induction on 4.
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
============================
forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf @ -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
< intros IsK1 IsK2 GCL2 RUPPH MemK1K2.
Variables: K1 K2 A Prf
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
RUPPH : rupProof_help K1 A Prf @
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
============================
rupProof_help K2 A Prf
< RUPPH: case RUPPH.
Subgoal 1:
Variables: K1 K2 A C ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unsat_clause A C
============================
rupProof_help K2 A [ID]
< M1: apply lookup_mem to RUPPH.
Subgoal 1:
Variables: K1 K2 A C ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unsat_clause A C
M1 : mem (ID, C) K1
============================
rupProof_help K2 A [ID]
< M2: apply MemK1K2 to M1.
Subgoal 1:
Variables: K1 K2 A C ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unsat_clause A C
M1 : mem (ID, C) K1
M2 : mem (ID, C) K2
============================
rupProof_help K2 A [ID]
< Is: apply mem_is to IsK1 M1.
Subgoal 1:
Variables: K1 K2 A ID1 C1
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unsat_clause A C1
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
============================
rupProof_help K2 A [ID1]
< L: apply is_list_mem_lookup to _ M2 _.
Subgoal 1:
Variables: K1 K2 A ID1 C1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unsat_clause A C1
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
L : lookup K2 ID1 C'
============================
rupProof_help K2 A [ID1]
< ML: apply lookup_mem to L.
Subgoal 1:
Variables: K1 K2 A ID1 C1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unsat_clause A C1
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
L : lookup K2 ID1 C'
ML : mem (ID1, C') K2
============================
rupProof_help K2 A [ID1]
< apply good_clause_list_mems to GCL2 M2 ML.
Subgoal 1:
Variables: K1 K2 A ID1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C'
RUPPH1 : unsat_clause A C'
M1 : mem (ID1, C') K1
M2 : mem (ID1, C') K2
Is : is_integer ID1
Is1 : is_clause C'
L : lookup K2 ID1 C'
ML : mem (ID1, C') K2
============================
rupProof_help K2 A [ID1]
< search.
Subgoal 2:
Variables: K1 K2 A C L Prf1 ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unit_clause A C L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
============================
rupProof_help K2 A (ID::Prf1)
< M1: apply lookup_mem to RUPPH.
Subgoal 2:
Variables: K1 K2 A C L Prf1 ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unit_clause A C L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID, C) K1
============================
rupProof_help K2 A (ID::Prf1)
< M2: apply MemK1K2 to M1.
Subgoal 2:
Variables: K1 K2 A C L Prf1 ID
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID C
RUPPH1 : unit_clause A C L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID, C) K1
M2 : mem (ID, C) K2
============================
rupProof_help K2 A (ID::Prf1)
< Is: apply mem_is to IsK1 M1.
Subgoal 2:
Variables: K1 K2 A L Prf1 ID1 C1
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unit_clause A C1 L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
============================
rupProof_help K2 A (ID1::Prf1)
< L: apply is_list_mem_lookup to _ M2 _.
Subgoal 2:
Variables: K1 K2 A L Prf1 ID1 C1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unit_clause A C1 L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
L : lookup K2 ID1 C'
============================
rupProof_help K2 A (ID1::Prf1)
< ML: apply lookup_mem to L.
Subgoal 2:
Variables: K1 K2 A L Prf1 ID1 C1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C1
RUPPH1 : unit_clause A C1 L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID1, C1) K1
M2 : mem (ID1, C1) K2
Is : is_integer ID1
Is1 : is_clause C1
L : lookup K2 ID1 C'
ML : mem (ID1, C') K2
============================
rupProof_help K2 A (ID1::Prf1)
< apply good_clause_list_mems to _ M2 ML.
Subgoal 2:
Variables: K1 K2 A L Prf1 ID1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C'
RUPPH1 : unit_clause A C' L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID1, C') K1
M2 : mem (ID1, C') K2
Is : is_integer ID1
Is1 : is_clause C'
L : lookup K2 ID1 C'
ML : mem (ID1, C') K2
============================
rupProof_help K2 A (ID1::Prf1)
< apply IH to _ _ _ RUPPH2 _.
Subgoal 2:
Variables: K1 K2 A L Prf1 ID1 C'
IH : forall K1 K2 A Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof_help K1 A Prf * -> (forall ID C,
mem (ID, C) K1 -> mem (ID, C) K2) -> rupProof_help K2 A Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL2 : good_clause_list K2
MemK1K2 : forall ID C, mem (ID, C) K1 -> mem (ID, C) K2
RUPPH : lookup K1 ID1 C'
RUPPH1 : unit_clause A C' L
RUPPH2 : rupProof_help K1 (L::A) Prf1 *
M1 : mem (ID1, C') K1
M2 : mem (ID1, C') K2
Is : is_integer ID1
Is1 : is_clause C'
L : lookup K2 ID1 C'
ML : mem (ID1, C') K2
H1 : rupProof_help K2 (L::A) Prf1
============================
rupProof_help K2 A (ID1::Prf1)
< search.
Proof completed.
< Extensible_Theorem
gatherLits_is : forall C L,
IsC : is_clause C ->
GL : gatherLits C L ->
is_list is_lit L
on GL.
Subgoal 1:
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
IsC : is_clause emptyClause
GL : gatherLits emptyClause [] @
============================
is_list is_lit []
< search.
Subgoal 2:
Variables: LRest L1 Rest
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
IsC : is_clause (or L1 Rest)
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
============================
is_list is_lit (L1::LRest)
< Is: case IsC.
Subgoal 2:
Variables: LRest L1 Rest
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
Is : is_lit L1
Is1 : is_clause Rest
============================
is_list is_lit (L1::LRest)
< apply IH to _ GL1.
Subgoal 2:
Variables: LRest L1 Rest
IH : forall C L, is_clause C -> gatherLits C L * -> is_list is_lit L
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
Is : is_lit L1
Is1 : is_clause Rest
H1 : is_list is_lit LRest
============================
is_list is_lit (L1::LRest)
< search.
Proof completed.
< Extensible_Theorem
gatherLits_exists : forall C,
IsC : is_clause C ->
exists L,
gatherLits C L
on IsC.
Subgoal 1:
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause emptyClause @
============================
exists L, gatherLits emptyClause L
< search.
Subgoal 2:
Variables: Clause Lit
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
============================
exists L, gatherLits (or Lit Clause) L
< apply IH to IsC2.
Subgoal 2:
Variables: Clause Lit L
IH : forall C, is_clause C * -> exists L, gatherLits C L
IsC : is_clause (or Lit Clause) @
IsC1 : is_lit Lit
IsC2 : is_clause Clause *
H1 : gatherLits Clause L
============================
exists L, gatherLits (or Lit Clause) L
< search.
Proof completed.
< Extensible_Theorem
gatherLits_permutation : forall C L1 L2,
IsC : is_clause C ->
GL1 : gatherLits C L1 ->
GL2 : gatherLits C L2 ->
permutation L1 L2
on GL1.
Subgoal 1:
Variables: L2
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause emptyClause
GL1 : gatherLits emptyClause [] @
GL2 : gatherLits emptyClause L2
============================
permutation [] L2
< case GL2.
Subgoal 1:
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause emptyClause
GL1 : gatherLits emptyClause [] @
============================
permutation [] []
< search.
Subgoal 2:
Variables: L2 LRest L Rest
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (or L Rest)
GL1 : gatherLits (or L Rest) (L::LRest) @
GL2 : gatherLits (or L Rest) L2
GL3 : gatherLits Rest LRest *
============================
permutation (L::LRest) L2
< GL2: case GL2.
Subgoal 2:
Variables: LRest L Rest LRest1
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
IsC : is_clause (or L Rest)
GL1 : gatherLits (or L Rest) (L::LRest) @
GL3 : gatherLits Rest LRest *
GL2 : gatherLits Rest LRest1
============================
permutation (L::LRest) (L::LRest1)
< Is: case IsC.
Subgoal 2:
Variables: LRest L Rest LRest1
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (or L Rest) (L::LRest) @
GL3 : gatherLits Rest LRest *
GL2 : gatherLits Rest LRest1
Is : is_lit L
Is1 : is_clause Rest
============================
permutation (L::LRest) (L::LRest1)
< apply IH to _ GL3 GL2.
Subgoal 2:
Variables: LRest L Rest LRest1
IH : forall C L1 L2,
is_clause C -> gatherLits C L1 * -> gatherLits C L2 -> permutation L1 L2
GL1 : gatherLits (or L Rest) (L::LRest) @
GL3 : gatherLits Rest LRest *
GL2 : gatherLits Rest LRest1
Is : is_lit L
Is1 : is_clause Rest
H1 : permutation LRest LRest1
============================
permutation (L::LRest) (L::LRest1)
< search.
Proof completed.
< Projection_Constraint proj_gatherLits :
forall C C' L,
|{clause}- C ~~> C' -> is_clause C -> gatherLits C L -> exists L',
gatherLits C' L'.
Proof completed.
< Projection_Constraint proj_gatherLits_permutation :
forall C C' L L',
|{clause}- C ~~> C' -> is_clause C -> gatherLits C L -> gatherLits C' L' -> permutation L L'.
Proof completed.
< Extensible_Theorem
gatherLits_sat : forall C Lits Sat,
IsC : is_clause C ->
IsSat : is_list is_lit Sat ->
GL : gatherLits C Lits ->
Sat : sat_clause Sat C ->
exists L,
mem L Lits /\ mem L Sat
on Sat.
Subgoal 1:
Variables: Lits Sat Rest 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
IsC : is_clause (or L Rest)
IsSat : is_list is_lit Sat
GL : gatherLits (or L Rest) Lits
Sat : sat_clause Sat (or L Rest) @
Sat1 : mem L Sat
============================
exists L, mem L Lits /\ mem L Sat
< case GL.
Subgoal 1:
Variables: Sat Rest L LRest
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 (or L Rest)
IsSat : is_list is_lit Sat
Sat : sat_clause Sat (or L Rest) @
Sat1 : mem L Sat
H1 : gatherLits Rest LRest
============================
exists L1, mem L1 (L::LRest) /\ mem L1 Sat
< search.
Subgoal 2:
Variables: Lits Sat Rest 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
IsC : is_clause (or L Rest)
IsSat : is_list is_lit Sat
GL : gatherLits (or L Rest) Lits
Sat : sat_clause Sat (or L Rest) @
Sat1 : sat_clause Sat Rest *
============================
exists L, mem L Lits /\ mem L Sat
< Is: case IsC.
Subgoal 2:
Variables: Lits Sat Rest 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
GL : gatherLits (or L Rest) Lits
Sat : sat_clause Sat (or L Rest) @
Sat1 : sat_clause Sat Rest *
Is : is_lit L
Is1 : is_clause Rest
============================
exists L, mem L Lits /\ mem L Sat
< GL: case GL.
Subgoal 2:
Variables: Sat Rest L LRest
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 (or L Rest) @
Sat1 : sat_clause Sat Rest *
Is : is_lit L
Is1 : is_clause Rest
GL : gatherLits Rest LRest
============================
exists L1, mem L1 (L::LRest) /\ mem L1 Sat
< apply IH to _ _ GL Sat1.
Subgoal 2:
Variables: Sat Rest L LRest L1
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 (or L Rest) @
Sat1 : sat_clause Sat Rest *
Is : is_lit L
Is1 : is_clause Rest
GL : gatherLits Rest LRest
H1 : mem L1 LRest
H2 : mem L1 Sat
============================
exists L1, mem L1 (L::LRest) /\ mem L1 Sat
< search.
Proof completed.
< Extensible_Theorem
gatherLits_mem_sat : forall C Lits Sat L,
IsC : is_clause C ->
IsSat : is_list is_lit Sat ->
GL : gatherLits C Lits ->
MemLits : mem L Lits ->
MemSat : mem L Sat ->
sat_clause Sat C
on GL.
Subgoal 1:
Variables: Sat L
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 emptyClause
IsSat : is_list is_lit Sat
GL : gatherLits emptyClause [] @
MemLits : mem L []
MemSat : mem L Sat
============================
sat_clause Sat emptyClause
< case MemLits.
Subgoal 2:
Variables: Sat L LRest L1 Rest
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 (or L1 Rest)
IsSat : is_list is_lit Sat
GL : gatherLits (or L1 Rest) (L1::LRest) @
MemLits : mem L (L1::LRest)
MemSat : mem L Sat
GL1 : gatherLits Rest LRest *
============================
sat_clause Sat (or L1 Rest)
< MemLits: case MemLits.
Subgoal 2.1:
Variables: Sat LRest L1 Rest
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 (or L1 Rest)
IsSat : is_list is_lit Sat
GL : gatherLits (or L1 Rest) (L1::LRest) @
MemSat : mem L1 Sat
GL1 : gatherLits Rest LRest *
============================
sat_clause Sat (or L1 Rest)
< search.
Subgoal 2.2:
Variables: Sat L LRest L1 Rest
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 (or L1 Rest)
IsSat : is_list is_lit Sat
GL : gatherLits (or L1 Rest) (L1::LRest) @
MemSat : mem L Sat
GL1 : gatherLits Rest LRest *
MemLits : mem L LRest
============================
sat_clause Sat (or L1 Rest)
< Is: case IsC.
Subgoal 2.2:
Variables: Sat L LRest L1 Rest
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 (or L1 Rest) (L1::LRest) @
MemSat : mem L Sat
GL1 : gatherLits Rest LRest *
MemLits : mem L LRest
Is : is_lit L1
Is1 : is_clause Rest
============================
sat_clause Sat (or L1 Rest)
< apply IH to _ _ GL1 MemLits MemSat.
Subgoal 2.2:
Variables: Sat L LRest L1 Rest
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 (or L1 Rest) (L1::LRest) @
MemSat : mem L Sat
GL1 : gatherLits Rest LRest *
MemLits : mem L LRest
Is : is_lit L1
Is1 : is_clause Rest
H1 : sat_clause Sat Rest
============================
sat_clause Sat (or L1 Rest)
< search.
Proof completed.
< Extensible_Theorem
gatherLits_unsat : forall C Lits Unsat L,
GA : good_assignment Unsat ->
IsC : is_clause C ->
IsUnsat : is_list is_lit Unsat ->
GL : gatherLits C Lits ->
Unsat : unsat_clause Unsat C ->
MemLits : mem L Lits ->
MemUnsat : mem L Unsat ->
false
on Unsat.
Subgoal 1:
Variables: Lits Unsat L
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 emptyClause
IsUnsat : is_list is_lit Unsat
GL : gatherLits emptyClause Lits
Unsat : unsat_clause Unsat emptyClause @
MemLits : mem L Lits
MemUnsat : mem L Unsat
============================
false
< case GL.
Subgoal 1:
Variables: Unsat L
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 emptyClause
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat emptyClause @
MemLits : mem L []
MemUnsat : mem L Unsat
============================
false
< case MemLits.
Subgoal 2:
Variables: Lits Unsat L NL Rest L1
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 (or L1 Rest)
IsUnsat : is_list is_lit Unsat
GL : gatherLits (or L1 Rest) Lits
Unsat : unsat_clause Unsat (or L1 Rest) @
MemLits : mem L Lits
MemUnsat : mem L Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
============================
false
< GL: case GL.
Subgoal 2:
Variables: Unsat L NL Rest L1 LRest
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 (or L1 Rest)
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (or L1 Rest) @
MemLits : mem L (L1::LRest)
MemUnsat : mem L Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
GL : gatherLits Rest LRest
============================
false
< MemLits: case MemLits.
Subgoal 2.1:
Variables: Unsat NL Rest L1 LRest
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 (or L1 Rest)
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (or L1 Rest) @
MemUnsat : mem L1 Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
GL : gatherLits Rest LRest
============================
false
< GA: case GA.
Subgoal 2.1:
Variables: Unsat NL Rest L1 LRest
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
IsC : is_clause (or L1 Rest)
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (or L1 Rest) @
MemUnsat : mem L1 Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
GL : gatherLits Rest LRest
GA : forall L NL, mem L Unsat -> negate_lit L NL -> mem NL Unsat -> false
============================
false
< apply GA to MemUnsat Unsat1 Unsat2.
Subgoal 2.2:
Variables: Unsat L NL Rest L1 LRest
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 (or L1 Rest)
IsUnsat : is_list is_lit Unsat
Unsat : unsat_clause Unsat (or L1 Rest) @
MemUnsat : mem L Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
GL : gatherLits Rest LRest
MemLits : mem L LRest
============================
false
< Is: case IsC.
Subgoal 2.2:
Variables: Unsat L NL Rest L1 LRest
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 (or L1 Rest) @
MemUnsat : mem L Unsat
Unsat1 : negate_lit L1 NL
Unsat2 : mem NL Unsat
Unsat3 : unsat_clause Unsat Rest *
GL : gatherLits Rest LRest
MemLits : mem L LRest
Is : is_lit L1
Is1 : is_clause Rest
============================
false
< apply IH to GA _ _ GL Unsat3 MemLits MemUnsat.
Proof completed.
< Theorem negateLitList_is :
forall L NL, is_list is_lit L -> negateLitList L NL -> is_list is_lit NL.
============================
forall L NL, is_list is_lit L -> negateLitList L NL -> is_list is_lit NL
< induction on 2.
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
============================
forall L NL, is_list is_lit L -> negateLitList L NL @ -> is_list is_lit NL
< intros IsL NLL.
Variables: L NL
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
IsL : is_list is_lit L
NLL : negateLitList L NL @
============================
is_list is_lit NL
< NLL: case NLL.
Subgoal 1:
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
IsL : is_list is_lit []
============================
is_list is_lit []
< search.
Subgoal 2:
Variables: NRest N LRest L1
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
IsL : is_list is_lit (L1::LRest)
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest *
============================
is_list is_lit (N::NRest)
< Is: case IsL.
Subgoal 2:
Variables: NRest N LRest L1
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest *
Is : is_lit L1
Is1 : is_list is_lit LRest
============================
is_list is_lit (N::NRest)
< apply IH to _ NLL1.
Subgoal 2:
Variables: NRest N LRest L1
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest *
Is : is_lit L1
Is1 : is_list is_lit LRest
H1 : is_list is_lit NRest
============================
is_list is_lit (N::NRest)
< apply negate_lit_is_lit to _ NLL.
Subgoal 2:
Variables: NRest N LRest L1
IH : forall L NL, is_list is_lit L -> negateLitList L NL * -> is_list is_lit NL
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest *
Is : is_lit L1
Is1 : is_list is_lit LRest
H1 : is_list is_lit NRest
H2 : is_lit N
============================
is_list is_lit (N::NRest)
< search.
Proof completed.
< Theorem negateLitList_exists :
forall L, is_list is_lit L -> exists NL, negateLitList L NL.
============================
forall L, is_list is_lit L -> exists NL, negateLitList L NL
< induction on 1.
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
============================
forall L, is_list is_lit L @ -> exists NL, negateLitList L NL
< intros IsL.
Variables: L
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
IsL : is_list is_lit L @
============================
exists NL, negateLitList L NL
< Is: case IsL.
Subgoal 1:
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
============================
exists NL, negateLitList [] NL
< search.
Subgoal 2:
Variables: T H
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
Is : is_lit H
Is1 : is_list is_lit T *
============================
exists NL, negateLitList (H::T) NL
< apply negate_lit_exists to Is.
Subgoal 2:
Variables: T H NL
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
Is : is_lit H
Is1 : is_list is_lit T *
H1 : negate_lit H NL
============================
exists NL, negateLitList (H::T) NL
< apply IH to Is1.
Subgoal 2:
Variables: T H NL NL1
IH : forall L, is_list is_lit L * -> exists NL, negateLitList L NL
Is : is_lit H
Is1 : is_list is_lit T *
H1 : negate_lit H NL
H2 : negateLitList T NL1
============================
exists NL, negateLitList (H::T) NL
< search.
Proof completed.
< Theorem negateLitList_mem_negate_before :
forall X NL L NX,
is_list is_lit NL -> mem X NL -> negateLitList L NL -> negate_lit X NX ->
mem NX L.
============================
forall X NL L NX,
is_list is_lit NL -> mem X NL -> negateLitList L NL -> negate_lit X NX -> mem NX L
< induction on 2.
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
============================
forall X NL L NX,
is_list is_lit NL -> mem X NL @ -> negateLitList L NL -> negate_lit X NX -> mem NX L
< intros IsNL Mem NLL Neg.
Variables: X NL L NX
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
IsNL : is_list is_lit NL
Mem : mem X NL @
NLL : negateLitList L NL
Neg : negate_lit X NX
============================
mem NX L
< Mem: case Mem.
Subgoal 1:
Variables: X L NX Rest
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
IsNL : is_list is_lit (X::Rest)
NLL : negateLitList L (X::Rest)
Neg : negate_lit X NX
============================
mem NX L
< NLL: case NLL.
Subgoal 1:
Variables: X NX Rest LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
IsNL : is_list is_lit (X::Rest)
Neg : negate_lit X NX
NLL : negate_lit L1 X
NLL1 : negateLitList LRest Rest
============================
mem NX (L1::LRest)
< Is: case IsNL.
Subgoal 1:
Variables: X NX Rest LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X NX
NLL : negate_lit L1 X
NLL1 : negateLitList LRest Rest
Is : is_lit X
Is1 : is_list is_lit Rest
============================
mem NX (L1::LRest)
< apply negate_lit_is_lit_back to _ NLL.
Subgoal 1:
Variables: X NX Rest LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X NX
NLL : negate_lit L1 X
NLL1 : negateLitList LRest Rest
Is : is_lit X
Is1 : is_list is_lit Rest
H1 : is_lit L1
============================
mem NX (L1::LRest)
< NegXL1: apply negate_lit_reverse to _ NLL.
Subgoal 1:
Variables: X NX Rest LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X NX
NLL : negate_lit L1 X
NLL1 : negateLitList LRest Rest
Is : is_lit X
Is1 : is_list is_lit Rest
H1 : is_lit L1
NegXL1 : negate_lit X L1
============================
mem NX (L1::LRest)
< apply negate_lit_unique to _ Neg NegXL1.
Subgoal 1:
Variables: X Rest LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X L1
NLL : negate_lit L1 X
NLL1 : negateLitList LRest Rest
Is : is_lit X
Is1 : is_list is_lit Rest
H1 : is_lit L1
NegXL1 : negate_lit X L1
============================
mem L1 (L1::LRest)
< search.
Subgoal 2:
Variables: X L NX Rest I
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
IsNL : is_list is_lit (I::Rest)
NLL : negateLitList L (I::Rest)
Neg : negate_lit X NX
Mem : mem X Rest *
============================
mem NX L
< NLL: case NLL.
Subgoal 2:
Variables: X NX Rest I LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
IsNL : is_list is_lit (I::Rest)
Neg : negate_lit X NX
Mem : mem X Rest *
NLL : negate_lit L1 I
NLL1 : negateLitList LRest Rest
============================
mem NX (L1::LRest)
< case IsNL.
Subgoal 2:
Variables: X NX Rest I LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X NX
Mem : mem X Rest *
NLL : negate_lit L1 I
NLL1 : negateLitList LRest Rest
H1 : is_lit I
H2 : is_list is_lit Rest
============================
mem NX (L1::LRest)
< apply IH to _ Mem _ _.
Subgoal 2:
Variables: X NX Rest I LRest L1
IH : forall X NL L NX,
is_list is_lit NL -> mem X NL * -> negateLitList L NL -> negate_lit X NX ->
mem NX L
Neg : negate_lit X NX
Mem : mem X Rest *
NLL : negate_lit L1 I
NLL1 : negateLitList LRest Rest
H1 : is_lit I
H2 : is_list is_lit Rest
H3 : mem NX LRest
============================
mem NX (L1::LRest)
< search.
Proof completed.
< Extensible_Theorem
negate_lits_unsat : forall C L NL,
IsC : is_clause C ->
GL : gatherLits C L ->
NLL : negateLitList L NL ->
unsat_clause NL C
on GL.
Subgoal 1:
Variables: NL
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
IsC : is_clause emptyClause
GL : gatherLits emptyClause [] @
NLL : negateLitList [] NL
============================
unsat_clause NL emptyClause
< search.
Subgoal 2:
Variables: NL LRest L1 Rest
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
IsC : is_clause (or L1 Rest)
GL : gatherLits (or L1 Rest) (L1::LRest) @
NLL : negateLitList (L1::LRest) NL
GL1 : gatherLits Rest LRest *
============================
unsat_clause NL (or L1 Rest)
< NLL: case NLL.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
IsC : is_clause (or L1 Rest)
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
============================
unsat_clause (N::NRest) (or L1 Rest)
< Is: case IsC.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
============================
unsat_clause (N::NRest) (or L1 Rest)
< UC: apply IH to _ GL1 NLL1.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
UC : unsat_clause NRest Rest
============================
unsat_clause (N::NRest) (or L1 Rest)
< apply negate_lit_is_lit to _ NLL.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
UC : unsat_clause NRest Rest
H1 : is_lit N
============================
unsat_clause (N::NRest) (or L1 Rest)
< apply gatherLits_is to _ GL1.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
UC : unsat_clause NRest Rest
H1 : is_lit N
H2 : is_list is_lit LRest
============================
unsat_clause (N::NRest) (or L1 Rest)
< apply negateLitList_is to _ NLL1.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
UC : unsat_clause NRest Rest
H1 : is_lit N
H2 : is_list is_lit LRest
H3 : is_list is_lit NRest
============================
unsat_clause (N::NRest) (or L1 Rest)
< apply unsat_clause_orderless to _ _ _ UC _ with
A2 = N::NRest.
Subgoal 2:
Variables: LRest L1 Rest NRest N
IH : forall C L NL,
is_clause C -> gatherLits C L * -> negateLitList L NL -> unsat_clause NL C
GL : gatherLits (or L1 Rest) (L1::LRest) @
GL1 : gatherLits Rest LRest *
NLL : negate_lit L1 N
NLL1 : negateLitList LRest NRest
Is : is_lit L1
Is1 : is_clause Rest
UC : unsat_clause NRest Rest
H1 : is_lit N
H2 : is_list is_lit LRest
H3 : is_list is_lit NRest
H4 : unsat_clause (N::NRest) Rest
============================
unsat_clause (N::NRest) (or L1 Rest)
< search.
Proof completed.
< Theorem rupProof_all_mem :
forall Known C Proof ID,
rupProof Known C Proof -> mem ID Proof -> exists C', lookup Known ID C'.
============================
forall Known C Proof ID,
rupProof Known C Proof -> mem ID Proof -> exists C', lookup Known ID C'
< intros RUP Mem.
Variables: Known C Proof ID
RUP : rupProof Known C Proof
Mem : mem ID Proof
============================
exists C', lookup Known ID C'
< RUP: case RUP.
Variables: Known C Proof ID Lits A
Mem : mem ID Proof
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Proof
============================
exists C', lookup Known ID C'
< apply rupProof_help_all_mem to RUP2 Mem.
Variables: Known C Proof ID Lits A C1
Mem : mem ID Proof
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Proof
H1 : lookup Known ID C1
============================
exists C', lookup Known ID C'
< search.
Proof completed.
< Theorem rupProof_is :
forall Known C Proof,
rupProof Known C Proof -> is_list (is_pair is_integer is_clause) Known ->
is_list is_integer Proof.
============================
forall Known C Proof,
rupProof Known C Proof -> is_list (is_pair is_integer is_clause) Known -> is_list is_integer Proof
< intros RUP IsK.
Variables: Known C Proof
RUP : rupProof Known C Proof
IsK : is_list (is_pair is_integer is_clause) Known
============================
is_list is_integer Proof
< RUP: case RUP.
Variables: Known C Proof Lits A
IsK : is_list (is_pair is_integer is_clause) Known
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Proof
============================
is_list is_integer Proof
< apply rupProof_help_is to RUP2 IsK.
Variables: Known C Proof Lits A
IsK : is_list (is_pair is_integer is_clause) Known
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Proof
H1 : is_list is_integer Proof
============================
is_list is_integer Proof
< search.
Proof completed.
< Theorem rupProof_maintains_sat :
forall Known C Prf Sat,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit Sat -> rupProof Known C Prf ->
(forall ID InC, lookup Known ID InC -> sat_clause Sat InC) -> is_clause C ->
is_list is_lit Sat -> good_assignment Sat -> exists S,
((is_list is_lit S /\ good_assignment S) /\
(forall L, mem L Sat -> mem L S)) /\
sat_clause S C.
============================
forall Known C Prf Sat,
is_list (is_pair is_integer is_clause) Known -> is_list is_lit Sat -> rupProof Known C Prf ->
(forall ID InC, lookup Known ID InC -> sat_clause Sat InC) -> is_clause C -> is_list is_lit Sat ->
good_assignment Sat -> exists S,
((is_list is_lit S /\ good_assignment S) /\
(forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< intros IsKnown IsSat RUP Sat IsC IsSat GA_Sat.
Variables: Known C Prf Sat
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
RUP : rupProof Known C Prf
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< RUP: case RUP.
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< IsLits: apply gatherLits_is to IsC RUP.
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< IsA: apply negateLitList_is to IsLits RUP1.
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< Or: apply is_list_lit_subset_or_not to IsA IsSat.
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Or : (forall X, mem X A -> mem X Sat) \/
(exists X, mem X A /\ (mem X Sat -> false))
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< Sub: case Or.
Subgoal 1:
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : forall X, mem X A -> mem X Sat
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< apply good_assignment_sub to GA_Sat Sub.
Subgoal 1:
Variables: Known C Prf Sat Lits A
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : forall X, mem X A -> mem X Sat
H1 : good_assignment A
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< apply rupProof_help_unsat to _ _ _ RUP2 Sub Sat _ GA_Sat.
Subgoal 2:
Variables: Known C Prf Sat Lits A X
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< IsX: apply mem_is_lit to _ Sub.
Subgoal 2:
Variables: Known C Prf Sat Lits A X
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< Neg: apply negate_lit_exists to IsX.
Subgoal 2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< IsNX: apply negate_lit_is_lit to IsX Neg.
Subgoal 2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< Or: apply is_list_lit_mem_or_not to IsSat IsNX.
Subgoal 2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
Or : mem NL Sat \/ (mem NL Sat -> false)
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< MemNXSat: case Or.
Subgoal 2.1:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< exists Sat.
Subgoal 2.1:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
((is_list is_lit Sat /\ good_assignment Sat) /\
(forall L, mem L Sat -> mem L Sat)) /\
sat_clause Sat C
< split.
Subgoal 2.1.1:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
is_list is_lit Sat
< search.
Subgoal 2.1.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
good_assignment Sat
< search.
Subgoal 2.1.3:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
forall L, mem L Sat -> mem L Sat
< search.
Subgoal 2.1.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
============================
sat_clause Sat C
< NegNLX: apply negate_lit_reverse to _ Neg.
Subgoal 2.1.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
NegNLX : negate_lit NL X
============================
sat_clause Sat C
< apply negateLitList_mem_negate_before to _ Sub RUP1 _.
Subgoal 2.1.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
NegNLX : negate_lit NL X
H1 : mem NL Lits
============================
sat_clause Sat C
< apply gatherLits_mem_sat to _ _ RUP _ MemNXSat.
Subgoal 2.1.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat
NegNLX : negate_lit NL X
H1 : mem NL Lits
H2 : sat_clause Sat C
============================
sat_clause Sat C
< search.
Subgoal 2.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
exists S,
((is_list is_lit S /\ good_assignment S) /\ (forall L, mem L Sat -> mem L S)) /\
sat_clause S C
< exists NL::Sat.
Subgoal 2.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
((is_list is_lit (NL::Sat) /\ good_assignment (NL::Sat)) /\
(forall L, mem L Sat -> mem L (NL::Sat))) /\
sat_clause (NL::Sat) C
< split.
Subgoal 2.2.1:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
is_list is_lit (NL::Sat)
< search.
Subgoal 2.2.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
good_assignment (NL::Sat)
< unfold .
Subgoal 2.2.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
forall L NL1, mem L (NL::Sat) -> negate_lit L NL1 -> mem NL1 (NL::Sat) -> false
< intros ML NegL MNL.
Subgoal 2.2.2:
Variables: Known C Prf Sat Lits A X NL L NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
ML : mem L (NL::Sat)
NegL : negate_lit L NL1
MNL : mem NL1 (NL::Sat)
============================
false
< ML: case ML.
Subgoal 2.2.2.1:
Variables: Known C Prf Sat Lits A X NL NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit NL NL1
MNL : mem NL1 (NL::Sat)
============================
false
< NegNXX: apply negate_lit_reverse to _ Neg.
Subgoal 2.2.2.1:
Variables: Known C Prf Sat Lits A X NL NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit NL NL1
MNL : mem NL1 (NL::Sat)
NegNXX : negate_lit NL X
============================
false
< apply negate_lit_unique to _ NegL NegNXX.
Subgoal 2.2.2.1:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit NL X
MNL : mem X (NL::Sat)
NegNXX : negate_lit NL X
============================
false
< MNL: case MNL.
Subgoal 2.2.2.1.1:
Variables: Known C Prf Sat Lits A NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem NL A
Sub1 : mem NL Sat -> false
IsX : is_lit NL
Neg : negate_lit NL NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit NL NL
NegNXX : negate_lit NL NL
============================
false
< apply negate_lit_not_same to _ NegL.
Subgoal 2.2.2.1.2:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit NL X
NegNXX : negate_lit NL X
MNL : mem X Sat
============================
false
< apply Sub1 to MNL.
Subgoal 2.2.2.2:
Variables: Known C Prf Sat Lits A X NL L NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL1
MNL : mem NL1 (NL::Sat)
ML : mem L Sat
============================
false
< MNL: case MNL.
Subgoal 2.2.2.2.1:
Variables: Known C Prf Sat Lits A X NL L
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL
ML : mem L Sat
============================
false
< NegNXX: apply negate_lit_reverse to _ Neg.
Subgoal 2.2.2.2.1:
Variables: Known C Prf Sat Lits A X NL L
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL
ML : mem L Sat
NegNXX : negate_lit NL X
============================
false
< apply mem_is_lit to _ ML.
Subgoal 2.2.2.2.1:
Variables: Known C Prf Sat Lits A X NL L
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL
ML : mem L Sat
NegNXX : negate_lit NL X
H1 : is_lit L
============================
false
< NegNXL: apply negate_lit_reverse to _ NegL.
Subgoal 2.2.2.2.1:
Variables: Known C Prf Sat Lits A X NL L
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL
ML : mem L Sat
NegNXX : negate_lit NL X
H1 : is_lit L
NegNXL : negate_lit NL L
============================
false
< apply negate_lit_unique to _ NegNXX NegNXL.
Subgoal 2.2.2.2.1:
Variables: Known C Prf Sat Lits A NL L
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem L A
Sub1 : mem L Sat -> false
IsX : is_lit L
Neg : negate_lit L NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL
ML : mem L Sat
NegNXX : negate_lit NL L
H1 : is_lit L
NegNXL : negate_lit NL L
============================
false
< apply Sub1 to ML.
Subgoal 2.2.2.2.2:
Variables: Known C Prf Sat Lits A X NL L NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL1
ML : mem L Sat
MNL : mem NL1 Sat
============================
false
< GA: case GA_Sat.
Subgoal 2.2.2.2.2:
Variables: Known C Prf Sat Lits A X NL L NL1
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
NegL : negate_lit L NL1
ML : mem L Sat
MNL : mem NL1 Sat
GA : forall L NL, mem L Sat -> negate_lit L NL -> mem NL Sat -> false
============================
false
< apply GA to ML NegL MNL.
Subgoal 2.2.3:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
forall L, mem L Sat -> mem L (NL::Sat)
< search.
Subgoal 2.2.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
============================
sat_clause (NL::Sat) C
< apply negateLitList_mem_negate_before to _ Sub RUP1 _.
Subgoal 2.2.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
H1 : mem NL Lits
============================
sat_clause (NL::Sat) C
< apply gatherLits_mem_sat to _ _ RUP _ _ with
Sat = NL::Sat.
Subgoal 2.2.4:
Variables: Known C Prf Sat Lits A X NL
IsKnown : is_list (is_pair is_integer is_clause) Known
IsSat : is_list is_lit Sat
Sat : forall ID InC, lookup Known ID InC -> sat_clause Sat InC
IsC : is_clause C
IsSat1 : is_list is_lit Sat
GA_Sat : good_assignment Sat
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help Known A Prf
IsLits : is_list is_lit Lits
IsA : is_list is_lit A
Sub : mem X A
Sub1 : mem X Sat -> false
IsX : is_lit X
Neg : negate_lit X NL
IsNX : is_lit NL
MemNXSat : mem NL Sat -> false
H1 : mem NL Lits
H2 : sat_clause (NL::Sat) C
============================
sat_clause (NL::Sat) C
< search.
Proof completed.
< Theorem rupProof_orderless :
forall K1 K2 C Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof K1 C Prf -> (forall ID C',
mem (ID, C') K1 -> mem (ID, C') K2) -> rupProof K2 C Prf.
============================
forall K1 K2 C Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof K1 C Prf -> (forall ID C',
mem (ID, C') K1 -> mem (ID, C') K2) -> rupProof K2 C Prf
< intros IsK1 IsK2 GCL RUP MemK1K2.
Variables: K1 K2 C Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
MemK1K2 : forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
============================
rupProof K2 C Prf
< RUP: case RUP.
Variables: K1 K2 C Prf Lits A
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
MemK1K2 : forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help K1 A Prf
============================
rupProof K2 C Prf
< apply rupProof_help_orderless to IsK1 IsK2 GCL RUP2 MemK1K2.
Variables: K1 K2 C Prf Lits A
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
MemK1K2 : forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
RUP : gatherLits C Lits
RUP1 : negateLitList Lits A
RUP2 : rupProof_help K1 A Prf
H1 : rupProof_help K2 A Prf
============================
rupProof K2 C Prf
< search.
Proof completed.
< Theorem rupProof_permutation :
forall K1 K2 C Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof K1 C Prf -> permutation K1 K2 -> rupProof K2 C Prf.
============================
forall K1 K2 C Prf,
is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> rupProof K1 C Prf -> permutation K1 K2 -> rupProof K2 C Prf
< intros IsK1 IsK2 GCL RUP Prm.
Variables: K1 K2 C Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
============================
rupProof K2 C Prf
< MemBoth: assert forall ID C',
mem (ID, C') K1 -> mem (ID, C') K2.
Subgoal 1:
Variables: K1 K2 C Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
============================
forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
< intros M.
Subgoal 1:
Variables: K1 K2 C Prf ID C'
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
M : mem (ID, C') K1
============================
mem (ID, C') K2
< apply permutation_mem to Prm M.
Subgoal 1:
Variables: K1 K2 C Prf ID C'
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
M : mem (ID, C') K1
H1 : mem (ID, C') K2
============================
mem (ID, C') K2
< search.
Variables: K1 K2 C Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
MemBoth : forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
============================
rupProof K2 C Prf
< apply rupProof_orderless to IsK1 IsK2 GCL RUP MemBoth.
Variables: K1 K2 C Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
RUP : rupProof K1 C Prf
Prm : permutation K1 K2
MemBoth : forall ID C', mem (ID, C') K1 -> mem (ID, C') K2
H1 : rupProof K2 C Prf
============================
rupProof K2 C Prf
< search.
Proof completed.
< Projection_Constraint proj_proof_is :
forall Known P PT,
Proj : Known |{proof}- P ~~> PT ->
IsP : is_proof P ->
IsKnown : is_list (is_pair is_integer is_clause) Known ->
GCL : good_clause_list Known ->
is_proof PT.
Proof completed.
< Projection_Constraint proj_proof_extend :
forall Known P PT Known',
Proj : Known |{proof}- P ~~> PT ->
IsP : is_proof P ->
IsKnown : is_list (is_pair is_integer is_clause) Known ->
IsKnown' : is_list (is_pair is_integer is_clause) Known' ->
GCL : good_clause_list Known ->
GCL' : good_clause_list Known' ->
Mems : (forall ID C,
mem (ID, C) Known -> mem (ID, C) Known') ->
Known' |{proof}- P ~~> PT.
Proof completed.
< Theorem sat_lemma :
forall ID C Known KRest S,
(forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC) -> remove_all Known ID KRest ->
forall CID InC, lookup ((ID, C)::KRest) CID InC -> sat_clause S InC.
============================
forall ID C Known KRest S,
(forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC) -> remove_all Known ID KRest ->
forall CID InC, lookup ((ID, C)::KRest) CID InC -> sat_clause S InC
< intros AllSat RA Lkp.
Variables: ID C Known KRest S CID InC
AllSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
RA : remove_all Known ID KRest
Lkp : lookup ((ID, C)::KRest) CID InC
============================
sat_clause S InC
< Lkp: case Lkp.
Subgoal 1:
Variables: Known KRest S CID InC
AllSat : forall CID1 InC1,
lookup ((CID, InC)::Known) CID1 InC1 -> sat_clause S InC1
RA : remove_all Known CID KRest
============================
sat_clause S InC
< backchain AllSat.
Subgoal 2:
Variables: ID C Known KRest S CID InC
AllSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
RA : remove_all Known ID KRest
Lkp : ID = CID -> false
Lkp1 : lookup KRest CID InC
============================
sat_clause S InC
< apply remove_all_lookup_after to RA Lkp1.
Subgoal 2:
Variables: ID C Known KRest S CID InC
AllSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
RA : remove_all Known ID KRest
Lkp : ID = CID -> false
Lkp1 : lookup KRest CID InC
H1 : lookup Known CID InC
============================
sat_clause S InC
< backchain AllSat.
Proof completed.
< Extensible_Theorem
check_proof_correct : forall Known P Sat,
IsP : is_proof P ->
IsSat : is_list is_lit Sat ->
GA_Sat : good_assignment Sat ->
GCL : good_clause_list Known ->
IsKnown : is_list (is_pair is_integer is_clause) Known ->
CP : checkProof Known P ->
Sat : (forall CID C,
lookup Known CID C -> sat_clause Sat C) ->
false
on CP.
Subgoal 1:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
============================
false
< assert good_assignment [].
Subgoal 1.1:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
============================
good_assignment []
< unfold .
Subgoal 1.1:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
============================
forall L NL, mem L [] -> negate_lit L NL -> mem NL [] -> false
< intros M.
Subgoal 1.1:
Variables: Known Sat Prf ID L NL
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
M : mem L []
H1 : negate_lit L NL
H2 : mem NL []
============================
false
< case M.
Subgoal 1:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
H1 : good_assignment []
============================
false
< assert forall L,
mem L [] -> mem L Sat.
Subgoal 1.2:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
H1 : good_assignment []
============================
forall L, mem L [] -> mem L Sat
< intros M.
Subgoal 1.2:
Variables: Known Sat Prf ID L
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
H1 : good_assignment []
M : mem L []
============================
mem L Sat
< case M.
Subgoal 1:
Variables: Known Sat Prf ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
H1 : good_assignment []
H2 : forall L, mem L [] -> mem L Sat
============================
false
< S: apply rupProof_maintains_sat to _ _ CP1 Sat _ IsSat GA_Sat.
Subgoal 1:
Variables: Known Sat Prf ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (emptyLrat ID Prf)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (emptyLrat ID Prf) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : rupProof Known emptyClause Prf
H1 : good_assignment []
H2 : forall L, mem L [] -> mem L Sat
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S emptyClause
============================
false
< case S3.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
============================
false
< GA_Empty: assert good_assignment [].
Subgoal 2.1:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
============================
good_assignment []
< unfold .
Subgoal 2.1:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
============================
forall L NL, mem L [] -> negate_lit L NL -> mem NL [] -> false
< intros M.
Subgoal 2.1:
Variables: Known Sat KRest Rest Prf C ID L NL
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
M : mem L []
H1 : negate_lit L NL
H2 : mem NL []
============================
false
< case M.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
============================
false
< ExpandEmpty: assert forall L,
mem L [] -> mem L Sat.
Subgoal 2.2:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
============================
forall L, mem L [] -> mem L Sat
< intros M.
Subgoal 2.2:
Variables: Known Sat KRest Rest Prf C ID L
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
M : mem L []
============================
mem L Sat
< case M.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (addLrupProof ID C Prf Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
============================
false
< Is: case IsP.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
============================
false
< S: apply rupProof_maintains_sat to _ _ CP2 Sat _ IsSat GA_Sat.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
============================
false
< NewSat: assert forall CID InC,
lookup ((ID, C)::Known) CID InC -> sat_clause S InC.
Subgoal 2.3:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
============================
forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
< intros Lkp.
Subgoal 2.3:
Variables: Known Sat KRest Rest Prf C ID S CID InC
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : lookup ((ID, C)::Known) CID InC
============================
sat_clause S InC
< Lkp: case Lkp.
Subgoal 2.3.1:
Variables: Known Sat KRest Rest Prf S CID InC
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof CID InC Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known CID KRest
CP2 : rupProof Known InC Prf
CP3 : checkProof ((CID, InC)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer CID
Is1 : is_clause InC
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S InC
============================
sat_clause S InC
< search.
Subgoal 2.3.2:
Variables: Known Sat KRest Rest Prf C ID S CID InC
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : ID = CID -> false
Lkp1 : lookup Known CID InC
============================
sat_clause S InC
< SC: apply Sat to Lkp1.
Subgoal 2.3.2:
Variables: Known Sat KRest Rest Prf C ID S CID InC
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : ID = CID -> false
Lkp1 : lookup Known CID InC
SC : sat_clause Sat InC
============================
sat_clause S InC
< M: apply lookup_mem to Lkp1.
Subgoal 2.3.2:
Variables: Known Sat KRest Rest Prf C ID S CID InC
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : ID = CID -> false
Lkp1 : lookup Known CID InC
SC : sat_clause Sat InC
M : mem (CID, InC) Known
============================
sat_clause S InC
< Is: apply mem_is to _ M.
Subgoal 2.3.2:
Variables: Known Sat KRest Rest Prf C ID S ID1 C1
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : ID = ID1 -> false
Lkp1 : lookup Known ID1 C1
SC : sat_clause Sat C1
M : mem (ID1, C1) Known
Is4 : is_integer ID1
Is5 : is_clause C1
============================
sat_clause S C1
< apply sat_clause_orderless to _ _ _ SC _.
Subgoal 2.3.2:
Variables: Known Sat KRest Rest Prf C ID S ID1 C1
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
Lkp : ID = ID1 -> false
Lkp1 : lookup Known ID1 C1
SC : sat_clause Sat C1
M : mem (ID1, C1) Known
Is4 : is_integer ID1
Is5 : is_clause C1
H1 : sat_clause S C1
============================
sat_clause S C1
< search.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
NewSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
============================
false
< GCL_New: apply good_clause_list_remove_all_add to GCL CP1 with
C = C.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
NewSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
GCL_New : good_clause_list ((ID, C)::KRest)
============================
false
< IsKRest: apply remove_all_is to IsKnown CP1.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
NewSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
GCL_New : good_clause_list ((ID, C)::KRest)
IsKRest : is_list (is_pair is_integer is_clause) KRest
============================
false
< apply IH to Is3 S S1 GCL_New _ CP3 _.
Subgoal 2:
Variables: Known Sat KRest Rest Prf C ID S
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (addLrupProof ID C Prf Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : remove_all Known ID KRest
CP2 : rupProof Known C Prf
CP3 : checkProof ((ID, C)::KRest) Rest *
GA_Empty : good_assignment []
ExpandEmpty : forall L, mem L [] -> mem L Sat
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
S : is_list is_lit S
S1 : good_assignment S
S2 : forall L, mem L Sat -> mem L S
S3 : sat_clause S C
NewSat : forall CID InC, lookup ((ID, C)::Known) CID InC -> sat_clause S InC
GCL_New : good_clause_list ((ID, C)::KRest)
IsKRest : is_list (is_pair is_integer is_clause) KRest
============================
forall CID C1, lookup ((ID, C)::KRest) CID C1 -> sat_clause S C1
< backchain sat_lemma.
Subgoal 3:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsP : is_proof (deleteLratProof ID Rest)
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
============================
false
< Is: case IsP.
Subgoal 3:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
============================
false
< SatKRest: assert forall CID C,
lookup KRest CID C -> sat_clause Sat C.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
============================
forall CID C, lookup KRest CID C -> sat_clause Sat C
< assert forall I C1 C2,
mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2.
Subgoal 3.1.1:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
============================
forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
< intros MA MB.
Subgoal 3.1.1:
Variables: Known Sat C KRest Rest ID I C1 C2
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
MA : mem (I, C1) Known
MB : mem (I, C2) Known
============================
C1 = C2
< apply good_clause_list_mems to _ MA MB.
Subgoal 3.1.1:
Variables: Known Sat C KRest Rest ID I C2
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
MA : mem (I, C2) Known
MB : mem (I, C2) Known
============================
C2 = C2
< search.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
============================
forall CID C, lookup KRest CID C -> sat_clause Sat C
< intros Lkp.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID CID C1
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Lkp : lookup KRest CID C1
============================
sat_clause Sat C1
< MemKRest: apply lookup_mem to Lkp.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID CID C1
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Lkp : lookup KRest CID C1
MemKRest : mem (CID, C1) KRest
============================
sat_clause Sat C1
< MemKnown: apply mem_after_select_before to CP1 MemKRest.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID CID C1
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Lkp : lookup KRest CID C1
MemKRest : mem (CID, C1) KRest
MemKnown : mem (CID, C1) Known
============================
sat_clause Sat C1
< apply mem_is to IsKnown MemKnown.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID ID1 C2
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Lkp : lookup KRest ID1 C2
MemKRest : mem (ID1, C2) KRest
MemKnown : mem (ID1, C2) Known
H2 : is_integer ID1
H3 : is_clause C2
============================
sat_clause Sat C2
< apply lookup_after_select to IsKnown _ _ CP1 Lkp.
Subgoal 3.1:
Variables: Known Sat C KRest Rest ID ID1 C2
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
H1 : forall I C1 C2, mem (I, C1) Known -> mem (I, C2) Known -> C1 = C2
Lkp : lookup KRest ID1 C2
MemKRest : mem (ID1, C2) KRest
MemKnown : mem (ID1, C2) Known
H2 : is_integer ID1
H3 : is_clause C2
H4 : lookup Known ID1 C2
============================
sat_clause Sat C2
< backchain Sat.
Subgoal 3:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
SatKRest : forall CID C, lookup KRest CID C -> sat_clause Sat C
============================
false
< GCL_KRest: apply good_clause_list_select to GCL CP1.
Subgoal 3:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
SatKRest : forall CID C, lookup KRest CID C -> sat_clause Sat C
GCL_KRest : good_clause_list KRest
============================
false
< IsKRest: apply select_is to IsKnown CP1.
Subgoal 3:
Variables: Known Sat C KRest Rest ID
IH : forall Known P Sat,
is_proof P -> is_list is_lit Sat -> good_assignment Sat -> good_clause_list Known ->
is_list (is_pair is_integer is_clause) Known -> checkProof Known P * -> (forall CID C,
lookup Known CID C -> sat_clause Sat C) -> false
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
GCL : good_clause_list Known
IsKnown : is_list (is_pair is_integer is_clause) Known
CP : checkProof Known (deleteLratProof ID Rest) @
Sat : forall CID C, lookup Known CID C -> sat_clause Sat C
CP1 : select (ID, C) KRest Known
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
SatKRest : forall CID C, lookup KRest CID C -> sat_clause Sat C
GCL_KRest : good_clause_list KRest
IsKRest : is_list (is_pair is_integer is_clause) KRest
============================
false
< apply IH to Is1 IsSat GA_Sat GCL_KRest IsKRest CP2 SatKRest.
Proof completed.
< Extensible_Theorem
checkProof_orderless : forall K1 K2 Prf,
IsP : is_proof Prf ->
IsK1 : is_list (is_pair is_integer is_clause) K1 ->
IsK2 : is_list (is_pair is_integer is_clause) K2 ->
GCL : good_clause_list K2 ->
CP : checkProof K1 Prf ->
Prm : permutation K1 K2 ->
checkProof K2 Prf
on CP.
Subgoal 1:
Variables: K1 K2 Prf1 ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsP : is_proof (emptyLrat ID Prf1)
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (emptyLrat ID Prf1) @
Prm : permutation K1 K2
CP1 : rupProof K1 emptyClause Prf1
============================
checkProof K2 (emptyLrat ID Prf1)
< apply rupProof_permutation to IsK1 IsK2 GCL CP1 Prm.
Subgoal 1:
Variables: K1 K2 Prf1 ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsP : is_proof (emptyLrat ID Prf1)
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (emptyLrat ID Prf1) @
Prm : permutation K1 K2
CP1 : rupProof K1 emptyClause Prf1
H1 : rupProof K2 emptyClause Prf1
============================
checkProof K2 (emptyLrat ID Prf1)
< search.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsP : is_proof (addLrupProof ID C Prf1 Rest)
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< Is: case IsP.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< Prm': apply permutation_symmetric to Prm.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< GCL_K1: apply permutation_good_clause_list to _ Prm' GCL.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< RUPP: apply rupProof_permutation to IsK1 IsK2 GCL CP2 Prm.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< RA': apply remove_all_permutation to _ _ CP1 Prm.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< Prm': assert permutation ((ID, C)::KRest) ((ID, C)::P').
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
Prm'1 : permutation ((ID, C)::KRest) ((ID, C)::P')
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< GCL_P': apply good_clause_list_remove_all_add to GCL RA' with
C = C.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
Prm'1 : permutation ((ID, C)::KRest) ((ID, C)::P')
GCL_P' : good_clause_list ((ID, C)::P')
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< apply remove_all_is to _ RA'.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
Prm'1 : permutation ((ID, C)::KRest) ((ID, C)::P')
GCL_P' : good_clause_list ((ID, C)::P')
H1 : is_list (is_pair is_integer is_clause) P'
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< apply remove_all_is to _ CP1.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
Prm'1 : permutation ((ID, C)::KRest) ((ID, C)::P')
GCL_P' : good_clause_list ((ID, C)::P')
H1 : is_list (is_pair is_integer is_clause) P'
H2 : is_list (is_pair is_integer is_clause) KRest
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< apply IH to Is3 _ _ GCL_P' CP3 _.
Subgoal 2:
Variables: K1 K2 KRest Rest Prf1 C ID P'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (addLrupProof ID C Prf1 Rest) @
Prm : permutation K1 K2
CP1 : remove_all K1 ID KRest
CP2 : rupProof K1 C Prf1
CP3 : checkProof ((ID, C)::KRest) Rest *
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf1
Is3 : is_proof Rest
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
RUPP : rupProof K2 C Prf1
RA' : remove_all K2 ID P'
RA'1 : permutation KRest P'
Prm'1 : permutation ((ID, C)::KRest) ((ID, C)::P')
GCL_P' : good_clause_list ((ID, C)::P')
H1 : is_list (is_pair is_integer is_clause) P'
H2 : is_list (is_pair is_integer is_clause) KRest
H3 : checkProof ((ID, C)::P') Rest
============================
checkProof K2 (addLrupProof ID C Prf1 Rest)
< search.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsP : is_proof (deleteLratProof ID Rest)
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
============================
checkProof K2 (deleteLratProof ID Rest)
< Is: case IsP.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
============================
checkProof K2 (deleteLratProof ID Rest)
< IsKRest: apply select_is to _ CP1.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
============================
checkProof K2 (deleteLratProof ID Rest)
< MK1: apply select_mem to CP1.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
============================
checkProof K2 (deleteLratProof ID Rest)
< MK2: apply permutation_mem to Prm MK1.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
============================
checkProof K2 (deleteLratProof ID Rest)
< S: apply mem_select to MK2.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
============================
checkProof K2 (deleteLratProof ID Rest)
< Prm': apply permutation_symmetric to Prm.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
============================
checkProof K2 (deleteLratProof ID Rest)
< GCL_K1: apply permutation_good_clause_list to _ Prm' GCL.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
============================
checkProof K2 (deleteLratProof ID Rest)
< GCL_L': apply good_clause_list_select to GCL S.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
GCL_L' : good_clause_list L'
============================
checkProof K2 (deleteLratProof ID Rest)
< IsL': apply select_is to _ S.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
GCL_L' : good_clause_list L'
IsL' : is_list (is_pair is_integer is_clause) L'
============================
checkProof K2 (deleteLratProof ID Rest)
< P': apply selects_permutation to _ _ Prm' _ _.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
GCL_L' : good_clause_list L'
IsL' : is_list (is_pair is_integer is_clause) L'
P' : permutation L' KRest
============================
checkProof K2 (deleteLratProof ID Rest)
< PrmSub: apply permutation_symmetric to P'.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
GCL_L' : good_clause_list L'
IsL' : is_list (is_pair is_integer is_clause) L'
P' : permutation L' KRest
PrmSub : permutation KRest L'
============================
checkProof K2 (deleteLratProof ID Rest)
< apply IH to Is1 _ _ GCL_L' CP2 PrmSub.
Subgoal 3:
Variables: K1 K2 C KRest Rest ID L'
IH : forall K1 K2 Prf,
is_proof Prf -> is_list (is_pair is_integer is_clause) K1 -> is_list (is_pair is_integer is_clause) K2 ->
good_clause_list K2 -> checkProof K1 Prf * -> permutation K1 K2 -> checkProof K2 Prf
IsK1 : is_list (is_pair is_integer is_clause) K1
IsK2 : is_list (is_pair is_integer is_clause) K2
GCL : good_clause_list K2
CP : checkProof K1 (deleteLratProof ID Rest) @
Prm : permutation K1 K2
CP1 : select (ID, C) KRest K1
CP2 : checkProof KRest Rest *
Is : is_integer ID
Is1 : is_proof Rest
IsKRest : is_list (is_pair is_integer is_clause) KRest
MK1 : mem (ID, C) K1
MK2 : mem (ID, C) K2
S : select (ID, C) L' K2
Prm' : permutation K2 K1
GCL_K1 : good_clause_list K1
GCL_L' : good_clause_list L'
IsL' : is_list (is_pair is_integer is_clause) L'
P' : permutation L' KRest
PrmSub : permutation KRest L'
H1 : checkProof L' Rest
============================
checkProof K2 (deleteLratProof ID Rest)
< search.
Proof completed.
< Ext_Size checkProof Known P.
Proof completed.
< Proj_Rel checkProof Known P.
Proof completed.
< Ext_Ind forall Known P, checkProof Known P with
IsP : is_proof P, IsKnown : is_list (is_pair is_integer is_clause) Known, GCL : good_clause_list Known.
Subgoal 1:
Variables: Known Prf ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (emptyLrat ID Prf) 0 @@
Acc : acc 0 @
IsP : is_proof (emptyLrat ID Prf)
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : rupProof Known emptyClause Prf
============================
<checkProof {P}> Known (emptyLrat ID Prf)
< search.
Subgoal 2:
Variables: N Known KRest Rest Prf C ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (addLrupProof ID C Prf Rest) N @@
Acc : acc N @
IsP : is_proof (addLrupProof ID C Prf Rest)
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : remove_all Known ID KRest
R2 : rupProof Known C Prf
R3 : <checkProof {ES}> ((ID, C)::KRest) Rest N **
============================
<checkProof {P}> Known (addLrupProof ID C Prf Rest)
< case IsP.
Subgoal 2:
Variables: N Known KRest Rest Prf C ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (addLrupProof ID C Prf Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : remove_all Known ID KRest
R2 : rupProof Known C Prf
R3 : <checkProof {ES}> ((ID, C)::KRest) Rest N **
H1 : is_integer ID
H2 : is_clause C
H3 : is_list is_integer Prf
H4 : is_proof Rest
============================
<checkProof {P}> Known (addLrupProof ID C Prf Rest)
< apply remove_all_is to _ R1.
Subgoal 2:
Variables: N Known KRest Rest Prf C ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (addLrupProof ID C Prf Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : remove_all Known ID KRest
R2 : rupProof Known C Prf
R3 : <checkProof {ES}> ((ID, C)::KRest) Rest N **
H1 : is_integer ID
H2 : is_clause C
H3 : is_list is_integer Prf
H4 : is_proof Rest
H5 : is_list (is_pair is_integer is_clause) KRest
============================
<checkProof {P}> Known (addLrupProof ID C Prf Rest)
< apply good_clause_list_remove_all_add to GCL R1 with
C = C.
Subgoal 2:
Variables: N Known KRest Rest Prf C ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (addLrupProof ID C Prf Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : remove_all Known ID KRest
R2 : rupProof Known C Prf
R3 : <checkProof {ES}> ((ID, C)::KRest) Rest N **
H1 : is_integer ID
H2 : is_clause C
H3 : is_list is_integer Prf
H4 : is_proof Rest
H5 : is_list (is_pair is_integer is_clause) KRest
H6 : good_clause_list ((ID, C)::KRest)
============================
<checkProof {P}> Known (addLrupProof ID C Prf Rest)
< apply IH1 to R3 Acc _ _ _.
Subgoal 2:
Variables: N Known KRest Rest Prf C ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (addLrupProof ID C Prf Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : remove_all Known ID KRest
R2 : rupProof Known C Prf
R3 : <checkProof {ES}> ((ID, C)::KRest) Rest N **
H1 : is_integer ID
H2 : is_clause C
H3 : is_list is_integer Prf
H4 : is_proof Rest
H5 : is_list (is_pair is_integer is_clause) KRest
H6 : good_clause_list ((ID, C)::KRest)
H7 : <checkProof {P}> ((ID, C)::KRest) Rest
============================
<checkProof {P}> Known (addLrupProof ID C Prf Rest)
< search.
Subgoal 3:
Variables: N Known C KRest Rest ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (deleteLratProof ID Rest) N @@
Acc : acc N @
IsP : is_proof (deleteLratProof ID Rest)
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : select (ID, C) KRest Known
R2 : <checkProof {ES}> KRest Rest N **
============================
<checkProof {P}> Known (deleteLratProof ID Rest)
< case IsP.
Subgoal 3:
Variables: N Known C KRest Rest ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (deleteLratProof ID Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : select (ID, C) KRest Known
R2 : <checkProof {ES}> KRest Rest N **
H1 : is_integer ID
H2 : is_proof Rest
============================
<checkProof {P}> Known (deleteLratProof ID Rest)
< apply select_is to _ R1.
Subgoal 3:
Variables: N Known C KRest Rest ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (deleteLratProof ID Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : select (ID, C) KRest Known
R2 : <checkProof {ES}> KRest Rest N **
H1 : is_integer ID
H2 : is_proof Rest
H3 : is_list (is_pair is_integer is_clause) KRest
============================
<checkProof {P}> Known (deleteLratProof ID Rest)
< apply good_clause_list_select to GCL R1.
Subgoal 3:
Variables: N Known C KRest Rest ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (deleteLratProof ID Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : select (ID, C) KRest Known
R2 : <checkProof {ES}> KRest Rest N **
H1 : is_integer ID
H2 : is_proof Rest
H3 : is_list (is_pair is_integer is_clause) KRest
H4 : good_clause_list KRest
============================
<checkProof {P}> Known (deleteLratProof ID Rest)
< apply IH1 to R2 Acc _ _ _.
Subgoal 3:
Variables: N Known C KRest Rest ID
IH : forall N Known P,
<checkProof {ES}> Known P N -> acc N * -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
IH1 : forall N Known P,
<checkProof {ES}> Known P N ** -> acc N @ -> is_proof P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> <checkProof {P}> Known P
R : <checkProof {ES}> Known (deleteLratProof ID Rest) N @@
Acc : acc N @
IsKnown : is_list (is_pair is_integer is_clause) Known
GCL : good_clause_list Known
R1 : select (ID, C) KRest Known
R2 : <checkProof {ES}> KRest Rest N **
H1 : is_integer ID
H2 : is_proof Rest
H3 : is_list (is_pair is_integer is_clause) KRest
H4 : good_clause_list KRest
H5 : <checkProof {P}> KRest Rest
============================
<checkProof {P}> Known (deleteLratProof ID Rest)
< search.
Proof completed.
< Projection_Constraint proj_checkProof :
forall Known P P',
Known |{proof}- P ~~> P' -> checkProof Known P -> is_list (is_pair is_integer is_clause) Known ->
good_clause_list Known -> checkProof Known P'.
Proof completed.
< Extensible_Theorem
formulaToKnown_unique : forall F ID KA KB,
IsF : is_formula F ->
IsID : is_integer ID ->
FTKA : formulaToKnown ID F KA ->
FTKB : formulaToKnown ID F KB ->
KA = KB
on FTKA.
Subgoal 1:
Variables: ID KB
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula emptyFormula
IsID : is_integer ID
FTKA : formulaToKnown ID emptyFormula [] @
FTKB : formulaToKnown ID emptyFormula KB
============================
[] = KB
< case FTKB.
Subgoal 1:
Variables: ID
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula emptyFormula
IsID : is_integer ID
FTKA : formulaToKnown ID emptyFormula [] @
============================
[] = []
< search.
Subgoal 2:
Variables: ID KB NewID KRest C Rest
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTKB : formulaToKnown ID (and C Rest) KB
FTKA1 : ID + 1 = NewID
FTKA2 : formulaToKnown NewID Rest KRest *
============================
(ID, C)::KRest = KB
< FTKB: case FTKB.
Subgoal 2:
Variables: ID NewID KRest C Rest NewID1 KRest1
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTKA1 : ID + 1 = NewID
FTKA2 : formulaToKnown NewID Rest KRest *
FTKB : ID + 1 = NewID1
FTKB1 : formulaToKnown NewID1 Rest KRest1
============================
(ID, C)::KRest = (ID, C)::KRest1
< apply plus_integer_unique to FTKA1 FTKB.
Subgoal 2:
Variables: ID KRest C Rest NewID1 KRest1
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTKA1 : ID + 1 = NewID1
FTKA2 : formulaToKnown NewID1 Rest KRest *
FTKB : ID + 1 = NewID1
FTKB1 : formulaToKnown NewID1 Rest KRest1
============================
(ID, C)::KRest = (ID, C)::KRest1
< apply plus_integer_is_integer to _ _ FTKA1.
Subgoal 2:
Variables: ID KRest C Rest NewID1 KRest1
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTKA1 : ID + 1 = NewID1
FTKA2 : formulaToKnown NewID1 Rest KRest *
FTKB : ID + 1 = NewID1
FTKB1 : formulaToKnown NewID1 Rest KRest1
H1 : is_integer NewID1
============================
(ID, C)::KRest = (ID, C)::KRest1
< case IsF.
Subgoal 2:
Variables: ID KRest C Rest NewID1 KRest1
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTKA1 : ID + 1 = NewID1
FTKA2 : formulaToKnown NewID1 Rest KRest *
FTKB : ID + 1 = NewID1
FTKB1 : formulaToKnown NewID1 Rest KRest1
H1 : is_integer NewID1
H2 : is_clause C
H3 : is_formula Rest
============================
(ID, C)::KRest = (ID, C)::KRest1
< apply IH to _ _ FTKA2 FTKB1.
Subgoal 2:
Variables: ID C Rest NewID1 KRest1
IH : forall F ID KA KB,
is_formula F -> is_integer ID -> formulaToKnown ID F KA * -> formulaToKnown ID F KB ->
KA = KB
IsID : is_integer ID
FTKA : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
FTKA1 : ID + 1 = NewID1
FTKA2 : formulaToKnown NewID1 Rest KRest1 *
FTKB : ID + 1 = NewID1
FTKB1 : formulaToKnown NewID1 Rest KRest1
H1 : is_integer NewID1
H2 : is_clause C
H3 : is_formula Rest
============================
(ID, C)::KRest1 = (ID, C)::KRest1
< search.
Proof completed.
< Extensible_Theorem
formulaToKnown_all_greater : forall F ID K CID C,
FTK : formulaToKnown ID F K ->
Mem : mem (CID, C) K ->
IsID : is_integer ID ->
CID >= ID
on FTK.
Subgoal 1:
Variables: ID CID C
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID emptyFormula [] @
Mem : mem (CID, C) []
IsID : is_integer ID
============================
CID >= ID
< case Mem.
Subgoal 2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
Mem : mem (CID, C) ((ID, C1)::KRest)
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
============================
CID >= ID
< Mem: case Mem.
Subgoal 2.1:
Variables: ID NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
============================
ID >= ID
< backchain is_integer_greatereq.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
============================
CID >= ID
< IsNewID: apply plus_integer_is_integer to _ _ FTK1.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
IsNewID : is_integer NewID
============================
CID >= ID
< GEq: apply IH to FTK2 Mem IsNewID.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
IsNewID : is_integer NewID
GEq : CID >= NewID
============================
CID >= ID
< G_ID: apply is_integer_greatereq to IsID.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
IsNewID : is_integer NewID
GEq : CID >= NewID
G_ID : ID >= ID
============================
CID >= ID
< G_New: apply greatereq_integer__add_positive to G_ID _ FTK1.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
IsNewID : is_integer NewID
GEq : CID >= NewID
G_ID : ID >= ID
G_New : NewID >= ID
============================
CID >= ID
< apply greatereq_integer_transitive to GEq G_New.
Subgoal 2.2:
Variables: ID CID C NewID KRest C1 Rest
IH : forall F ID K CID C,
formulaToKnown ID F K * -> mem (CID, C) K -> is_integer ID -> CID >= ID
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Mem : mem (CID, C) KRest
IsNewID : is_integer NewID
GEq : CID >= NewID
G_ID : ID >= ID
G_New : NewID >= ID
H1 : CID >= ID
============================
CID >= ID
< search.
Proof completed.
< Extensible_Theorem
formulaToKnown_all_unique : forall F ID K CID CA KRest CB,
FTK : formulaToKnown ID F K ->
IsID : is_integer ID ->
Slct : select (CID, CA) KRest K ->
Mem : mem (CID, CB) KRest ->
false
on FTK.
Subgoal 1:
Variables: ID CID CA KRest CB
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID emptyFormula [] @
IsID : is_integer ID
Slct : select (CID, CA) KRest []
Mem : mem (CID, CB) KRest
============================
false
< case Slct.
Subgoal 2:
Variables: ID CID CA KRest CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Slct : select (CID, CA) KRest ((ID, C)::KRest1)
Mem : mem (CID, CB) KRest
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
============================
false
< IsNewID: apply plus_integer_is_integer to _ _ FTK1.
Subgoal 2:
Variables: ID CID CA KRest CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Slct : select (CID, CA) KRest ((ID, C)::KRest1)
Mem : mem (CID, CB) KRest
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
============================
false
< G: apply greater_plus_positive to _ _ FTK1 _.
Subgoal 2:
Variables: ID CID CA KRest CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Slct : select (CID, CA) KRest ((ID, C)::KRest1)
Mem : mem (CID, CB) KRest
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
============================
false
< Slct: case Slct.
Subgoal 2.1:
Variables: ID CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (ID, CB) KRest1
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
============================
false
< GEq: apply formulaToKnown_all_greater to FTK2 Mem IsNewID.
Subgoal 2.1:
Variables: ID CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (ID, CB) KRest1
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
GEq : ID >= NewID
============================
false
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.1:
Variables: ID CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (ID, CB) KRest1
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
GEq : ID >= NewID
Or : ID > NewID \/ ID = NewID
============================
false
< Or: case Or.
Subgoal 2.1.1:
Variables: ID CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (ID, CB) KRest1
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
GEq : ID >= NewID
Or : ID > NewID
============================
false
< L: apply greater_integer_flip_less to Or.
Subgoal 2.1.1:
Variables: ID CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (ID, CB) KRest1
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
GEq : ID >= NewID
Or : ID > NewID
L : NewID < ID
============================
false
< apply greater_less_impossible to G L.
Subgoal 2.1.2:
Variables: CB NewID KRest1 C Rest
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown NewID (and C Rest) ((NewID, C)::KRest1) @
IsID : is_integer NewID
Mem : mem (NewID, CB) KRest1
FTK1 : NewID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > NewID
GEq : NewID >= NewID
============================
false
< apply greater_integer_not_eq to G.
Subgoal 2.2:
Variables: ID CID CA CB NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
Mem : mem (CID, CB) ((ID, C)::L1)
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (CID, CA) L1 KRest1
============================
false
< Mem: case Mem.
Subgoal 2.2.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
============================
false
< MS: apply select_mem to Slct.
Subgoal 2.2.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
MS : mem (ID, CA) KRest1
============================
false
< GEq: apply formulaToKnown_all_greater to FTK2 MS IsNewID.
Subgoal 2.2.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
MS : mem (ID, CA) KRest1
GEq : ID >= NewID
============================
false
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.2.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
MS : mem (ID, CA) KRest1
GEq : ID >= NewID
Or : ID > NewID \/ ID = NewID
============================
false
< Or: case Or.
Subgoal 2.2.1.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
MS : mem (ID, CA) KRest1
GEq : ID >= NewID
Or : ID > NewID
============================
false
< L: apply greater_integer_flip_less to Or.
Subgoal 2.2.1.1:
Variables: ID CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (ID, CA) L1 KRest1
MS : mem (ID, CA) KRest1
GEq : ID >= NewID
Or : ID > NewID
L : NewID < ID
============================
false
< apply greater_less_impossible to G L.
Subgoal 2.2.1.2:
Variables: CA NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown NewID (and C Rest) ((NewID, C)::KRest1) @
IsID : is_integer NewID
FTK1 : NewID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > NewID
Slct : select (NewID, CA) L1 KRest1
MS : mem (NewID, CA) KRest1
GEq : NewID >= NewID
============================
false
< apply greater_integer_not_eq to G.
Subgoal 2.2.2:
Variables: ID CID CA CB NewID KRest1 C Rest L1
IH : forall F ID K CID CA KRest CB,
formulaToKnown ID F K * -> is_integer ID -> select (CID, CA) KRest K -> mem (CID, CB) KRest ->
false
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest1) @
IsID : is_integer ID
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest1 *
IsNewID : is_integer NewID
G : NewID > ID
Slct : select (CID, CA) L1 KRest1
Mem : mem (CID, CB) L1
============================
false
< apply IH to FTK2 IsNewID Slct Mem.
Proof completed.
< Extensible_Theorem
formulaToKnown_sat_formula : forall F ID K A CID C,
FTK : formulaToKnown ID F K ->
Sat : sat_formula A F ->
Mem : mem (CID, C) K ->
sat_clause A C
on FTK.
Subgoal 1:
Variables: ID A CID C
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID emptyFormula [] @
Sat : sat_formula A emptyFormula
Mem : mem (CID, C) []
============================
sat_clause A C
< case Mem.
Subgoal 2:
Variables: ID A CID C NewID KRest C1 Rest
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
Sat : sat_formula A (and C1 Rest)
Mem : mem (CID, C) ((ID, C1)::KRest)
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
============================
sat_clause A C
< Sat: case Sat.
Subgoal 2:
Variables: ID A CID C NewID KRest C1 Rest
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
Mem : mem (CID, C) ((ID, C1)::KRest)
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Sat : sat_clause A C1
Sat1 : sat_formula A Rest
============================
sat_clause A C
< Mem: case Mem.
Subgoal 2.1:
Variables: ID A NewID KRest C1 Rest
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Sat : sat_clause A C1
Sat1 : sat_formula A Rest
============================
sat_clause A C1
< search.
Subgoal 2.2:
Variables: ID A CID C NewID KRest C1 Rest
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Sat : sat_clause A C1
Sat1 : sat_formula A Rest
Mem : mem (CID, C) KRest
============================
sat_clause A C
< apply IH to FTK2 Sat1 Mem.
Subgoal 2.2:
Variables: ID A CID C NewID KRest C1 Rest
IH : forall F ID K A CID C,
formulaToKnown ID F K * -> sat_formula A F -> mem (CID, C) K -> sat_clause A C
FTK : formulaToKnown ID (and C1 Rest) ((ID, C1)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
Sat : sat_clause A C1
Sat1 : sat_formula A Rest
Mem : mem (CID, C) KRest
H1 : sat_clause A C
============================
sat_clause A C
< search.
Proof completed.
< Extensible_Theorem
formulaToKnown_is : forall F ID K,
IsF : is_formula F ->
IsID : is_integer ID ->
FTK : formulaToKnown ID F K ->
is_list (is_pair is_integer is_clause) K
on FTK.
Subgoal 1:
Variables: ID
IH : forall F ID K,
is_formula F -> is_integer ID -> formulaToKnown ID F K * -> is_list (is_pair is_integer is_clause) K
IsF : is_formula emptyFormula
IsID : is_integer ID
FTK : formulaToKnown ID emptyFormula [] @
============================
is_list (is_pair is_integer is_clause) []
< search.
Subgoal 2:
Variables: ID NewID KRest C Rest
IH : forall F ID K,
is_formula F -> is_integer ID -> formulaToKnown ID F K * -> is_list (is_pair is_integer is_clause) K
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
============================
is_list (is_pair is_integer is_clause) ((ID, C)::KRest)
< IsNewID: apply plus_integer_is_integer to IsID _ FTK1.
Subgoal 2:
Variables: ID NewID KRest C Rest
IH : forall F ID K,
is_formula F -> is_integer ID -> formulaToKnown ID F K * -> is_list (is_pair is_integer is_clause) K
IsF : is_formula (and C Rest)
IsID : is_integer ID
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
IsNewID : is_integer NewID
============================
is_list (is_pair is_integer is_clause) ((ID, C)::KRest)
< Is: case IsF.
Subgoal 2:
Variables: ID NewID KRest C Rest
IH : forall F ID K,
is_formula F -> is_integer ID -> formulaToKnown ID F K * -> is_list (is_pair is_integer is_clause) K
IsID : is_integer ID
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
IsNewID : is_integer NewID
Is : is_clause C
Is1 : is_formula Rest
============================
is_list (is_pair is_integer is_clause) ((ID, C)::KRest)
< apply IH to Is1 IsNewID FTK2.
Subgoal 2:
Variables: ID NewID KRest C Rest
IH : forall F ID K,
is_formula F -> is_integer ID -> formulaToKnown ID F K * -> is_list (is_pair is_integer is_clause) K
IsID : is_integer ID
FTK : formulaToKnown ID (and C Rest) ((ID, C)::KRest) @
FTK1 : ID + 1 = NewID
FTK2 : formulaToKnown NewID Rest KRest *
IsNewID : is_integer NewID
Is : is_clause C
Is1 : is_formula Rest
H1 : is_list (is_pair is_integer is_clause) KRest
============================
is_list (is_pair is_integer is_clause) ((ID, C)::KRest)
< search.
Proof completed.
< Theorem proveFormula_correct :
forall F Prf Sat,
is_formula F -> is_proof Prf -> is_list is_lit Sat -> good_assignment Sat ->
proveFormula F Prf -> sat_formula Sat F -> false.
============================
forall F Prf Sat,
is_formula F -> is_proof Prf -> is_list is_lit Sat -> good_assignment Sat -> proveFormula F Prf ->
sat_formula Sat F -> false
< intros IsF IsP IsSat GA_Sat PF Sat.
Variables: F Prf Sat
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
PF : proveFormula F Prf
Sat : sat_formula Sat F
============================
false
< PF: case PF.
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
============================
false
< GCL: assert good_clause_list KnownClauses.
Subgoal 1:
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
============================
good_clause_list KnownClauses
< unfold .
Subgoal 1:
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
============================
forall ID C1 KRest C2,
select (ID, C1) KRest KnownClauses -> mem (ID, C2) KRest -> false
< intros S M.
Subgoal 1:
Variables: F Prf Sat KnownClauses ID C1 KRest C2
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
S : select (ID, C1) KRest KnownClauses
M : mem (ID, C2) KRest
============================
false
< backchain formulaToKnown_all_unique.
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
============================
false
< SatC: assert forall CID C,
lookup KnownClauses CID C -> sat_clause Sat C.
Subgoal 2:
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
============================
forall CID C, lookup KnownClauses CID C -> sat_clause Sat C
< intros Lkp.
Subgoal 2:
Variables: F Prf Sat KnownClauses CID C
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
Lkp : lookup KnownClauses CID C
============================
sat_clause Sat C
< M: apply lookup_mem to Lkp.
Subgoal 2:
Variables: F Prf Sat KnownClauses CID C
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
Lkp : lookup KnownClauses CID C
M : mem (CID, C) KnownClauses
============================
sat_clause Sat C
< apply formulaToKnown_sat_formula to PF Sat M.
Subgoal 2:
Variables: F Prf Sat KnownClauses CID C
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
Lkp : lookup KnownClauses CID C
M : mem (CID, C) KnownClauses
H1 : sat_clause Sat C
============================
sat_clause Sat C
< search.
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
SatC : forall CID C, lookup KnownClauses CID C -> sat_clause Sat C
============================
false
< IsK: apply formulaToKnown_is to IsF _ PF.
Variables: F Prf Sat KnownClauses
IsF : is_formula F
IsP : is_proof Prf
IsSat : is_list is_lit Sat
GA_Sat : good_assignment Sat
Sat : sat_formula Sat F
PF : formulaToKnown 1 F KnownClauses
PF1 : checkProof KnownClauses Prf
GCL : good_clause_list KnownClauses
SatC : forall CID C, lookup KnownClauses CID C -> sat_clause Sat C
IsK : is_list (is_pair is_integer is_clause) KnownClauses
============================
false
< apply check_proof_correct to IsP IsSat GA_Sat GCL IsK PF1 SatC.
Proof completed.
