< Module unsat_proofs:drat.
< Prove_Constraint unsat_proofs:lrat:proj_lit_unique.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_lit_is.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_clause_unique.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_clause_is.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_formula_unique.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_formula_is.
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:is_clause.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:is_clause.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:is_formula.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:is_formula.
Warning: No definition of Ext Size for all relations in Ext Ind; defaulting to proving Ext Ind without Ext Size
Proof completed.
< Prove unsat_proofs:lrat:is_lit_pos_or_neg.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_empty_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_or_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_clause_eq_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_empty_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_and_or_not.
Proof completed.
< Prove unsat_proofs:lrat:is_formula_eq_or_not.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_unique.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_reverse.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_not_same.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_is_lit.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_is_lit_back.
Proof completed.
< Prove unsat_proofs:lrat:negate_lit_exists.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_clause_ext_to_proj.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_clause_proj_to_ext.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:unsat_clause_ext_to_proj.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:unsat_clause_proj_to_ext.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_formula_ext_to_proj.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:sat_formula_proj_to_ext.
Proof completed.
< Prove unsat_proofs:lrat:unsat_sat_clause.
Proof completed.
< Prove unsat_proofs:lrat:sat_clause_orderless.
Proof completed.
< Prove unsat_proofs:lrat:sat_formula_orderless.
Proof completed.
< Prove unsat_proofs:lrat:unsat_clause_orderless.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_is.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_unique.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_not_assigned.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_not_assigned_negate.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_expand.
Proof completed.
< Prove unsat_proofs:lrat:unit_clause_add.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_is.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_exists.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_permutation.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_gatherLits.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_gatherLits_permutation.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_sat.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_mem_sat.
Proof completed.
< Prove unsat_proofs:lrat:gatherLits_unsat.
Proof completed.
< Prove unsat_proofs:lrat:negate_lits_unsat.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_proof_is.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_proof_extend.
Proof completed.
< Prove unsat_proofs:lrat:check_proof_correct.
Proof completed.
< Prove unsat_proofs:lrat:checkProof_orderless.
Proof completed.
< Add_Ext_Size unsat_proofs:lrat:checkProof.
Proof completed.
< Add_Proj_Rel unsat_proofs:lrat:checkProof.
Proof completed.
< Prove_Ext_Ind unsat_proofs:lrat:checkProof.
Proof completed.
< Prove_Constraint unsat_proofs:lrat:proj_checkProof.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_unique.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_all_greater.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_all_unique.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_sat_formula.
Proof completed.
< Prove unsat_proofs:lrat:formulaToKnown_is.
Proof completed.
< Theorem rupProof_help__drup_help :
forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf -> values KnownL KnownD -> drup_help KnownD A.
============================
forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf -> values KnownL KnownD -> drup_help KnownD A
< induction on 1.
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
============================
forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf @ -> values KnownL KnownD -> drup_help KnownD A
< intros RUP V.
Variables: KnownL KnownD A Prf
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
RUP : rupProof_help KnownL A Prf @
V : values KnownL KnownD
============================
drup_help KnownD A
< RUP: case RUP.
Subgoal 1:
Variables: KnownL KnownD A C ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unsat_clause A C
============================
drup_help KnownD A
< MemL: apply lookup_mem to RUP.
Subgoal 1:
Variables: KnownL KnownD A C ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unsat_clause A C
MemL : mem (ID, C) KnownL
============================
drup_help KnownD A
< MemD: apply values_mem to MemL V.
Subgoal 1:
Variables: KnownL KnownD A C ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unsat_clause A C
MemL : mem (ID, C) KnownL
MemD : mem C KnownD
============================
drup_help KnownD A
< search.
Subgoal 2:
Variables: KnownL KnownD A C L Prf1 ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help KnownL (L::A) Prf1 *
============================
drup_help KnownD A
< MemL: apply lookup_mem to RUP.
Subgoal 2:
Variables: KnownL KnownD A C L Prf1 ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help KnownL (L::A) Prf1 *
MemL : mem (ID, C) KnownL
============================
drup_help KnownD A
< MemD: apply values_mem to MemL V.
Subgoal 2:
Variables: KnownL KnownD A C L Prf1 ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help KnownL (L::A) Prf1 *
MemL : mem (ID, C) KnownL
MemD : mem C KnownD
============================
drup_help KnownD A
< apply IH to RUP2 _.
Subgoal 2:
Variables: KnownL KnownD A C L Prf1 ID
IH : forall KnownL KnownD A Prf,
rupProof_help KnownL A Prf * -> values KnownL KnownD -> drup_help KnownD A
V : values KnownL KnownD
RUP : lookup KnownL ID C
RUP1 : unit_clause A C L
RUP2 : rupProof_help KnownL (L::A) Prf1 *
MemL : mem (ID, C) KnownL
MemD : mem C KnownD
H1 : drup_help KnownD (L::A)
============================
drup_help KnownD A
< search.
Proof completed.
< Theorem rupProof__drup :
forall KnownL KnownD C Prf,
rupProof KnownL C Prf -> values KnownL KnownD -> drup KnownD C.
============================
forall KnownL KnownD C Prf,
rupProof KnownL C Prf -> values KnownL KnownD -> drup KnownD C
< intros R Vals.
Variables: KnownL KnownD C Prf
R : rupProof KnownL C Prf
Vals : values KnownL KnownD
============================
drup KnownD C
< R: case R.
Variables: KnownL KnownD C Prf Lits A
Vals : values KnownL KnownD
R : gatherLits C Lits
R1 : negateLitList Lits A
R2 : rupProof_help KnownL A Prf
============================
drup KnownD C
< apply rupProof_help__drup_help to R2 Vals.
Variables: KnownL KnownD C Prf Lits A
Vals : values KnownL KnownD
R : gatherLits C Lits
R1 : negateLitList Lits A
R2 : rupProof_help KnownL A Prf
H1 : drup_help KnownD A
============================
drup KnownD C
< search.
Proof completed.
< Theorem remove_all_no_mem_same :
forall K ID KRest,
remove_all K ID KRest -> ((exists C, mem (ID, C) K) -> false) -> K = KRest.
============================
forall K ID KRest,
remove_all K ID KRest -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
< induction on 1.
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
============================
forall K ID KRest,
remove_all K ID KRest @ -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
< intros RA NEq.
Variables: K ID KRest
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
RA : remove_all K ID KRest @
NEq : (exists C, mem (ID, C) K) -> false
============================
K = KRest
< RA: case RA.
Subgoal 1:
Variables: ID
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C, mem (ID, C) []) -> false
============================
[] = []
< search.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((ID, C)::IRest)) -> false
RA : remove_all IRest ID KRest *
============================
(ID, C)::IRest = KRest
< apply NEq to _.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::IRest)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
(A, C)::IRest = (A, C)::Rest
< assert (exists C, mem (ID, C) IRest) -> false.
Subgoal 3.1:
Variables: ID Rest C A IRest
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::IRest)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
(exists C1, mem (ID, C1) IRest) -> false
< intros Ex.
Subgoal 3.1:
Variables: ID Rest C A IRest
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::IRest)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Ex : exists C1, mem (ID, C1) IRest
============================
false
< case Ex.
Subgoal 3.1:
Variables: ID Rest C A IRest C1
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::IRest)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
H1 : mem (ID, C1) IRest
============================
false
< backchain NEq.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::IRest)) -> false
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
H1 : (exists C1, mem (ID, C1) IRest) -> false
============================
(A, C)::IRest = (A, C)::Rest
< apply IH to RA1 _.
Subgoal 3:
Variables: ID Rest C A
IH : forall K ID KRest,
remove_all K ID KRest * -> ((exists C, mem (ID, C) K) -> false) -> K = KRest
NEq : (exists C1, mem (ID, C1) ((A, C)::Rest)) -> false
RA : A = ID -> false
RA1 : remove_all Rest ID Rest *
H1 : (exists C1, mem (ID, C1) Rest) -> false
============================
(A, C)::Rest = (A, C)::Rest
< search.
Proof completed.
< Theorem remove_all_good_clause_list_select :
forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA -> select (ID, C) KS K -> KRA = KS.
============================
forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA -> select (ID, C) KS K -> KRA = KS
< induction on 2.
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
============================
forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA @ -> select (ID, C) KS K -> KRA = KS
< intros GCL RA Slct.
Variables: K ID KRA C KS
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list K
RA : remove_all K ID KRA @
Slct : select (ID, C) KS K
============================
KRA = KS
< RA: case RA.
Subgoal 1:
Variables: ID C KS
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list []
Slct : select (ID, C) KS []
============================
[] = KS
< case Slct.
Subgoal 2:
Variables: ID KRA C KS IRest C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
Slct : select (ID, C) KS ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
============================
KRA = KS
< Slct: case Slct.
Subgoal 2.1:
Variables: ID KRA IRest C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
============================
KRA = IRest
< assert (exists C', mem (ID, C') IRest) -> false.
Subgoal 2.1.1:
Variables: ID KRA IRest C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
============================
(exists C', mem (ID, C') IRest) -> false
< intros Ex.
Subgoal 2.1.1:
Variables: ID KRA IRest C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
Ex : exists C', mem (ID, C') IRest
============================
false
< M: case Ex.
Subgoal 2.1.1:
Variables: ID KRA IRest C1 C'
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
M : mem (ID, C') IRest
============================
false
< GCL: case GCL.
Subgoal 2.1.1:
Variables: ID KRA IRest C1 C'
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
RA : remove_all IRest ID KRA *
M : mem (ID, C') IRest
GCL : forall ID1 C2 KRest C3,
select (ID1, C2) KRest ((ID, C1)::IRest) -> mem (ID1, C3) KRest -> false
============================
false
< backchain GCL.
Subgoal 2.1:
Variables: ID KRA IRest C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
H1 : (exists C', mem (ID, C') IRest) -> false
============================
KRA = IRest
< apply remove_all_no_mem_same to RA _.
Subgoal 2.1:
Variables: ID KRA C1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::KRA)
RA : remove_all KRA ID KRA *
H1 : (exists C', mem (ID, C') KRA) -> false
============================
KRA = KRA
< search.
Subgoal 2.2:
Variables: ID KRA C IRest C1 L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
Slct : select (ID, C) L1 IRest
============================
KRA = (ID, C1)::L1
< M: apply select_mem to Slct.
Subgoal 2.2:
Variables: ID KRA C IRest C1 L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((ID, C1)::IRest)
RA : remove_all IRest ID KRA *
Slct : select (ID, C) L1 IRest
M : mem (ID, C) IRest
============================
KRA = (ID, C1)::L1
< GCL: case GCL.
Subgoal 2.2:
Variables: ID KRA C IRest C1 L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
RA : remove_all IRest ID KRA *
Slct : select (ID, C) L1 IRest
M : mem (ID, C) IRest
GCL : forall ID1 C2 KRest C3,
select (ID1, C2) KRest ((ID, C1)::IRest) -> mem (ID1, C3) KRest -> false
============================
KRA = (ID, C1)::L1
< apply GCL to _ M.
Subgoal 3:
Variables: ID C KS Rest C1 A IRest
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((A, C1)::IRest)
Slct : select (ID, C) KS ((A, C1)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
(A, C1)::Rest = KS
< Slct: case Slct.
Subgoal 3.1:
Variables: Rest C1 A IRest
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((A, C1)::IRest)
RA : A = A -> false
RA1 : remove_all IRest A Rest *
============================
(A, C1)::Rest = IRest
< apply RA to _.
Subgoal 3.2:
Variables: ID C Rest C1 A IRest L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((A, C1)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Slct : select (ID, C) L1 IRest
============================
(A, C1)::Rest = (A, C1)::L1
< apply good_clause_list_drop to GCL.
Subgoal 3.2:
Variables: ID C Rest C1 A IRest L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((A, C1)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
Slct : select (ID, C) L1 IRest
H1 : good_clause_list IRest
============================
(A, C1)::Rest = (A, C1)::L1
< apply IH to _ RA1 Slct.
Subgoal 3.2:
Variables: ID C C1 A IRest L1
IH : forall K ID KRA C KS,
good_clause_list K -> remove_all K ID KRA * -> select (ID, C) KS K -> KRA = KS
GCL : good_clause_list ((A, C1)::IRest)
RA : A = ID -> false
RA1 : remove_all IRest ID L1 *
Slct : select (ID, C) L1 IRest
H1 : good_clause_list IRest
============================
(A, C1)::L1 = (A, C1)::L1
< search.
Proof completed.
< Theorem remove_all_subset :
forall K ID KRest, remove_all K ID KRest -> subset KRest K.
============================
forall K ID KRest, remove_all K ID KRest -> subset KRest K
< induction on 1.
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
============================
forall K ID KRest, remove_all K ID KRest @ -> subset KRest K
< intros RA.
Variables: K ID KRest
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : remove_all K ID KRest @
============================
subset KRest K
< RA: case RA.
Subgoal 1:
Variables: ID
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
============================
subset [] []
< search.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : remove_all IRest ID KRest *
============================
subset KRest ((ID, C)::IRest)
< S: apply IH to RA.
Subgoal 2:
Variables: ID KRest IRest C
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : remove_all IRest ID KRest *
S : subset KRest IRest
============================
subset KRest ((ID, C)::IRest)
< backchain subset_add_right.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
subset ((A, C)::Rest) ((A, C)::IRest)
< S: apply IH to RA1.
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
S : subset Rest IRest
============================
subset ((A, C)::Rest) ((A, C)::IRest)
< apply subset_add_right to S with
A = (A, C).
Subgoal 3:
Variables: ID Rest C A IRest
IH : forall K ID KRest, remove_all K ID KRest * -> subset KRest K
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
S : subset Rest IRest
H1 : subset Rest ((A, C)::IRest)
============================
subset ((A, C)::Rest) ((A, C)::IRest)
< search.
Proof completed.
< Theorem subset_values [A, B] :
forall (A : list (pair A B)) (B : list (pair A B)) VA VB,
subset A B -> values A VA -> values B VB -> subset VA VB.
============================
forall A B VA VB, subset A B -> values A VA -> values B VB -> subset VA VB
< induction on 1.
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
============================
forall A B VA VB, subset A B @ -> values A VA -> values B VB -> subset VA VB
< intros S VA VB.
Variables: A B VA VB
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
S : subset A B @
VA : values A VA
VB : values B VB
============================
subset VA VB
< S: case S.
Subgoal 1:
Variables: B VA VB
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VA : values [] VA
VB : values B VB
============================
subset VA VB
< case VA.
Subgoal 1:
Variables: B VB
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VB : values B VB
============================
subset [] VB
< search.
Subgoal 2:
Variables: B VA VB Rest X
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VA : values (X::Rest) VA
VB : values B VB
S : mem X B
S1 : subset Rest B *
============================
subset VA VB
< VA: case VA.
Subgoal 2:
Variables: B VB Rest VRest B1 A1
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VB : values B VB
S : mem (A1, B1) B
S1 : subset Rest B *
VA : values Rest VRest
============================
subset (B1::VRest) VB
< apply IH to S1 VA VB.
Subgoal 2:
Variables: B VB Rest VRest B1 A1
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VB : values B VB
S : mem (A1, B1) B
S1 : subset Rest B *
VA : values Rest VRest
H1 : subset VRest VB
============================
subset (B1::VRest) VB
< apply values_mem to S VB.
Subgoal 2:
Variables: B VB Rest VRest B1 A1
IH : forall A B VA VB,
subset A B * -> values A VA -> values B VB -> subset VA VB
VB : values B VB
S : mem (A1, B1) B
S1 : subset Rest B *
VA : values Rest VRest
H1 : subset VRest VB
H2 : mem B1 VB
============================
subset (B1::VRest) VB
< search.
Proof completed.
< Theorem values_exist :
forall K, is_list (is_pair is_integer is_clause) K -> exists V, values K V.
============================
forall K, is_list (is_pair is_integer is_clause) K -> exists V, values K V
< induction on 1.
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
============================
forall K, is_list (is_pair is_integer is_clause) K @ -> exists V, values K V
< intros Is.
Variables: K
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
Is : is_list (is_pair is_integer is_clause) K @
============================
exists V, values K V
< Is: case Is.
Subgoal 1:
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
============================
exists V, values [] V
< search.
Subgoal 2:
Variables: T H
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
Is : is_pair is_integer is_clause H
Is1 : is_list (is_pair is_integer is_clause) T *
============================
exists V, values (H::T) V
< case Is.
Subgoal 2:
Variables: T B A
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : is_integer A
H2 : is_clause B
============================
exists V, values ((A, B)::T) V
< apply IH to Is1.
Subgoal 2:
Variables: T B A V
IH : forall K,
is_list (is_pair is_integer is_clause) K * -> exists V, values K V
Is1 : is_list (is_pair is_integer is_clause) T *
H1 : is_integer A
H2 : is_clause B
H3 : values T V
============================
exists V, values ((A, B)::T) V
< search.
Proof completed.
< Theorem remove_all_unique :
forall K ID KA KB, remove_all K ID KA -> remove_all K ID KB -> KA = KB.
============================
forall K ID KA KB, remove_all K ID KA -> remove_all K ID KB -> KA = KB
< induction on 1.
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
============================
forall K ID KA KB, remove_all K ID KA @ -> remove_all K ID KB -> KA = KB
< intros RAA RAB.
Variables: K ID KA KB
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : remove_all K ID KA @
RAB : remove_all K ID KB
============================
KA = KB
< RAA: case RAA.
Subgoal 1:
Variables: ID KB
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAB : remove_all [] ID KB
============================
[] = KB
< case RAB.
Subgoal 1:
Variables: ID
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
============================
[] = []
< search.
Subgoal 2:
Variables: ID KA KB IRest C
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAB : remove_all ((ID, C)::IRest) ID KB
RAA : remove_all IRest ID KA *
============================
KA = KB
< RAB: case RAB.
Subgoal 2.1:
Variables: ID KA KB IRest C
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : remove_all IRest ID KA *
RAB : remove_all IRest ID KB
============================
KA = KB
< apply IH to RAA RAB.
Subgoal 2.1:
Variables: ID KB IRest C
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : remove_all IRest ID KB *
RAB : remove_all IRest ID KB
============================
KB = KB
< search.
Subgoal 2.2:
Variables: ID KA IRest C Rest
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : remove_all IRest ID KA *
RAB : ID = ID -> false
RAB1 : remove_all IRest ID Rest
============================
KA = (ID, C)::Rest
< apply RAB to _.
Subgoal 3:
Variables: ID KB Rest C A IRest
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAB : remove_all ((A, C)::IRest) ID KB
RAA : A = ID -> false
RAA1 : remove_all IRest ID Rest *
============================
(A, C)::Rest = KB
< RAB: case RAB.
Subgoal 3.1:
Variables: ID KB Rest C IRest
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : ID = ID -> false
RAA1 : remove_all IRest ID Rest *
RAB : remove_all IRest ID KB
============================
(ID, C)::Rest = KB
< apply RAA to _.
Subgoal 3.2:
Variables: ID Rest C A IRest Rest1
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : A = ID -> false
RAA1 : remove_all IRest ID Rest *
RAB : A = ID -> false
RAB1 : remove_all IRest ID Rest1
============================
(A, C)::Rest = (A, C)::Rest1
< apply IH to RAA1 RAB1.
Subgoal 3.2:
Variables: ID C A IRest Rest1
IH : forall K ID KA KB, remove_all K ID KA * -> remove_all K ID KB -> KA = KB
RAA : A = ID -> false
RAA1 : remove_all IRest ID Rest1 *
RAB : A = ID -> false
RAB1 : remove_all IRest ID Rest1
============================
(A, C)::Rest1 = (A, C)::Rest1
< search.
Proof completed.
< Theorem drup_help_subset :
forall KA C KB, drup_help KA C -> subset KA KB -> drup_help KB C.
============================
forall KA C KB, drup_help KA C -> subset KA KB -> drup_help KB C
< induction on 1.
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
============================
forall KA C KB, drup_help KA C @ -> subset KA KB -> drup_help KB C
< intros D S.
Variables: KA C KB
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
D : drup_help KA C @
S : subset KA KB
============================
drup_help KB C
< D: case D.
Subgoal 1:
Variables: KA C KB C1
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
S : subset KA KB
D : mem C1 KA
D1 : unsat_clause C C1
============================
drup_help KB C
< apply subset_mem to S D.
Subgoal 1:
Variables: KA C KB C1
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
S : subset KA KB
D : mem C1 KA
D1 : unsat_clause C C1
H1 : mem C1 KB
============================
drup_help KB C
< search.
Subgoal 2:
Variables: KA C KB C1 L
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
S : subset KA KB
D : mem C1 KA
D1 : unit_clause C C1 L
D2 : drup_help KA (L::C) *
============================
drup_help KB C
< apply IH to D2 S.
Subgoal 2:
Variables: KA C KB C1 L
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
S : subset KA KB
D : mem C1 KA
D1 : unit_clause C C1 L
D2 : drup_help KA (L::C) *
H1 : drup_help KB (L::C)
============================
drup_help KB C
< apply subset_mem to S D.
Subgoal 2:
Variables: KA C KB C1 L
IH : forall KA C KB, drup_help KA C * -> subset KA KB -> drup_help KB C
S : subset KA KB
D : mem C1 KA
D1 : unit_clause C C1 L
D2 : drup_help KA (L::C) *
H1 : drup_help KB (L::C)
H2 : mem C1 KB
============================
drup_help KB C
< search.
Proof completed.
< Theorem drup_subset :
forall KA C KB, drup KA C -> subset KA KB -> drup KB C.
============================
forall KA C KB, drup KA C -> subset KA KB -> drup KB C
< intros D S.
Variables: KA C KB
D : drup KA C
S : subset KA KB
============================
drup KB C
< D: case D.
Variables: KA C KB L NL
S : subset KA KB
D : gatherLits C L
D1 : negateLitList L NL
D2 : drup_help KA NL
============================
drup KB C
< apply drup_help_subset to D2 S.
Variables: KA C KB L NL
S : subset KA KB
D : gatherLits C L
D1 : negateLitList L NL
D2 : drup_help KA NL
H1 : drup_help KB NL
============================
drup KB C
< search.
Proof completed.
< Theorem good_clause_list_selects :
forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K -> select (ID, CB) KB K -> KA = KB.
============================
forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K -> select (ID, CB) KB K -> KA = KB
< induction on 2.
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
============================
forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K @ -> select (ID, CB) KB K -> KA = KB
< intros GCL SA SB.
Variables: K ID CA KA CB KB
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list K
SA : select (ID, CA) KA K @
SB : select (ID, CB) KB K
============================
KA = KB
< SA: case SA.
Subgoal 1:
Variables: ID CA KA CB KB
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list ((ID, CA)::KA)
SB : select (ID, CB) KB ((ID, CA)::KA)
============================
KA = KB
< SB: case SB.
Subgoal 1.1:
Variables: ID CA KA
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list ((ID, CA)::KA)
============================
KA = KA
< search.
Subgoal 1.2:
Variables: ID CA KA CB L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list ((ID, CA)::KA)
SB : select (ID, CB) L1 KA
============================
KA = (ID, CA)::L1
< GCL: case GCL.
Subgoal 1.2:
Variables: ID CA KA CB L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
SB : select (ID, CB) L1 KA
GCL : forall ID1 C1 KRest C2,
select (ID1, C1) KRest ((ID, CA)::KA) -> mem (ID1, C2) KRest -> false
============================
KA = (ID, CA)::L1
< M: apply select_mem to SB.
Subgoal 1.2:
Variables: ID CA KA CB L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
SB : select (ID, CB) L1 KA
GCL : forall ID1 C1 KRest C2,
select (ID1, C1) KRest ((ID, CA)::KA) -> mem (ID1, C2) KRest -> false
M : mem (ID, CB) KA
============================
KA = (ID, CA)::L1
< apply GCL to _ M.
Subgoal 2:
Variables: ID CA CB KB L2 I L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list (I::L2)
SB : select (ID, CB) KB (I::L2)
SA : select (ID, CA) L1 L2 *
============================
I::L1 = KB
< SB: case SB.
Subgoal 2.1:
Variables: ID CA CB L2 L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list ((ID, CB)::L2)
SA : select (ID, CA) L1 L2 *
============================
(ID, CB)::L1 = L2
< GCL: case GCL.
Subgoal 2.1:
Variables: ID CA CB L2 L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
SA : select (ID, CA) L1 L2 *
GCL : forall ID1 C1 KRest C2,
select (ID1, C1) KRest ((ID, CB)::L2) -> mem (ID1, C2) KRest -> false
============================
(ID, CB)::L1 = L2
< M: apply select_mem to SA.
Subgoal 2.1:
Variables: ID CA CB L2 L1
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
SA : select (ID, CA) L1 L2 *
GCL : forall ID1 C1 KRest C2,
select (ID1, C1) KRest ((ID, CB)::L2) -> mem (ID1, C2) KRest -> false
M : mem (ID, CA) L2
============================
(ID, CB)::L1 = L2
< apply GCL to _ M.
Subgoal 2.2:
Variables: ID CA CB L2 I L1 L3
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list (I::L2)
SA : select (ID, CA) L1 L2 *
SB : select (ID, CB) L3 L2
============================
I::L1 = I::L3
< apply good_clause_list_drop to GCL.
Subgoal 2.2:
Variables: ID CA CB L2 I L1 L3
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list (I::L2)
SA : select (ID, CA) L1 L2 *
SB : select (ID, CB) L3 L2
H1 : good_clause_list L2
============================
I::L1 = I::L3
< apply IH to _ SA SB.
Subgoal 2.2:
Variables: ID CA CB L2 I L3
IH : forall K ID CA KA CB KB,
good_clause_list K -> select (ID, CA) KA K * -> select (ID, CB) KB K -> KA = KB
GCL : good_clause_list (I::L2)
SA : select (ID, CA) L3 L2 *
SB : select (ID, CB) L3 L2
H1 : good_clause_list L2
============================
I::L3 = I::L3
< search.
Proof completed.
< Theorem values_is :
forall K V,
is_list (is_pair is_integer is_clause) K -> values K V -> is_list is_clause V.
============================
forall K V,
is_list (is_pair is_integer is_clause) K -> values K V -> is_list is_clause V
< induction on 2.
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
============================
forall K V,
is_list (is_pair is_integer is_clause) K -> values K V @ -> is_list is_clause V
< intros IsK V.
Variables: K V
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
IsK : is_list (is_pair is_integer is_clause) K
V : values K V @
============================
is_list is_clause V
< V: case V.
Subgoal 1:
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
IsK : is_list (is_pair is_integer is_clause) []
============================
is_list is_clause []
< search.
Subgoal 2:
Variables: VRest B Rest A
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
IsK : is_list (is_pair is_integer is_clause) ((A, B)::Rest)
V : values Rest VRest *
============================
is_list is_clause (B::VRest)
< Is: case IsK.
Subgoal 2:
Variables: VRest B Rest A
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
V : values Rest VRest *
Is : is_pair is_integer is_clause (A, B)
Is1 : is_list (is_pair is_integer is_clause) Rest
============================
is_list is_clause (B::VRest)
< apply IH to Is1 V.
Subgoal 2:
Variables: VRest B Rest A
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
V : values Rest VRest *
Is : is_pair is_integer is_clause (A, B)
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_list is_clause VRest
============================
is_list is_clause (B::VRest)
< case Is.
Subgoal 2:
Variables: VRest B Rest A
IH : forall K V,
is_list (is_pair is_integer is_clause) K -> values K V * -> is_list is_clause V
V : values Rest VRest *
Is1 : is_list (is_pair is_integer is_clause) Rest
H1 : is_list is_clause VRest
H2 : is_integer A
H3 : is_clause B
============================
is_list is_clause (B::VRest)
< search.
Proof completed.
< Theorem select_is_clause :
forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known -> is_list is_clause KRest.
============================
forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known -> is_list is_clause KRest
< induction on 2.
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
============================
forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known @ -> is_list is_clause KRest
< intros Is Slct.
Variables: Known KRest IDC
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
Is : is_list is_clause Known
Slct : select IDC KRest Known @
============================
is_list is_clause KRest
< Slct: case Slct.
Subgoal 1:
Variables: KRest IDC
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
Is : is_list is_clause (IDC::KRest)
============================
is_list is_clause KRest
< case Is.
Subgoal 1:
Variables: KRest IDC
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
H1 : is_clause IDC
H2 : is_list is_clause KRest
============================
is_list is_clause KRest
< search.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
Is : is_list is_clause (I::L2)
Slct : select IDC L1 L2 *
============================
is_list is_clause (I::L1)
< Is: case Is.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
Slct : select IDC L1 L2 *
Is : is_clause I
Is1 : is_list is_clause L2
============================
is_list is_clause (I::L1)
< apply IH to _ Slct.
Subgoal 2:
Variables: IDC L2 I L1
IH : forall Known KRest IDC,
is_list is_clause Known -> select IDC KRest Known * -> is_list is_clause KRest
Slct : select IDC L1 L2 *
Is : is_clause I
Is1 : is_list is_clause L2
H1 : is_list is_clause L1
============================
is_list is_clause (I::L1)
< search.
Proof completed.
< Theorem mem_is_clause :
forall Known C, is_list is_clause Known -> mem C Known -> is_clause C.
============================
forall Known C, is_list is_clause Known -> mem C Known -> is_clause C
< induction on 2.
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
============================
forall Known C, is_list is_clause Known -> mem C Known @ -> is_clause C
< intros Is Mem.
Variables: Known C
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Is : is_list is_clause Known
Mem : mem C Known @
============================
is_clause C
< Mem: case Mem.
Subgoal 1:
Variables: C Rest
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Is : is_list is_clause (C::Rest)
============================
is_clause C
< Is: case Is.
Subgoal 1:
Variables: C Rest
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Is : is_clause C
Is1 : is_list is_clause Rest
============================
is_clause C
< search.
Subgoal 2:
Variables: C Rest I
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Is : is_list is_clause (I::Rest)
Mem : mem C Rest *
============================
is_clause C
< Is: case Is.
Subgoal 2:
Variables: C Rest I
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Mem : mem C Rest *
Is : is_clause I
Is1 : is_list is_clause Rest
============================
is_clause C
< apply IH to _ Mem.
Subgoal 2:
Variables: C Rest I
IH : forall Known C, is_list is_clause Known -> mem C Known * -> is_clause C
Mem : mem C Rest *
Is : is_clause I
Is1 : is_list is_clause Rest
H1 : is_clause C
============================
is_clause C
< search.
Proof completed.
< Theorem is_count_exists_clause :
forall L C, is_list is_clause L -> is_clause C -> exists N, count C L N.
============================
forall L C, is_list is_clause L -> is_clause C -> exists N, count C L N
< induction on 1.
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
============================
forall L C, is_list is_clause L @ -> is_clause C -> exists N, count C L N
< intros IsL IsC.
Variables: L C
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsL : is_list is_clause L @
IsC : is_clause C
============================
exists N, count C L N
< Is: case IsL.
Subgoal 1:
Variables: C
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause C
============================
exists N, count C [] N
< search.
Subgoal 2:
Variables: C T H
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause C
Is : is_clause H
Is1 : is_list is_clause T *
============================
exists N, count C (H::T) N
< Or: apply is_clause_eq_or_not to IsC Is.
Subgoal 2:
Variables: C T H
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause C
Is : is_clause H
Is1 : is_list is_clause T *
Or : C = H \/ (C = H -> false)
============================
exists N, count C (H::T) N
< C: apply IH to Is1 IsC.
Subgoal 2:
Variables: C T H N
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause C
Is : is_clause H
Is1 : is_list is_clause T *
Or : C = H \/ (C = H -> false)
C : count C T N
============================
exists N, count C (H::T) N
< Eq: case Or.
Subgoal 2.1:
Variables: T H N
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause H
Is : is_clause H
Is1 : is_list 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 C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause H
Is : is_clause H
Is1 : is_list 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 C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause H
Is : is_clause H
Is1 : is_list 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: C T H N
IH : forall L C, is_list is_clause L * -> is_clause C -> exists N, count C L N
IsC : is_clause C
Is : is_clause H
Is1 : is_list is_clause T *
C : count C T N
Eq : C = H -> false
============================
exists N, count C (H::T) N
< search.
Proof completed.
< Theorem counts_drop_head [A] :
forall (H : A) T X N N', count X (H::T) N -> count X T N' -> N >= N'.
============================
forall H T X N N', count X (H::T) N -> count X T N' -> N >= N'
< intros C CT.
Variables: H T X N N'
C : count X (H::T) N
CT : count X T N'
============================
N >= N'
< C: case C.
Subgoal 1:
Variables: H T N N' N1
CT : count H T N'
C : count H T N1
C1 : 1 + N1 = N
============================
N >= N'
< apply count_unique to C CT.
Subgoal 1:
Variables: H T N N'
CT : count H T N'
C : count H T N'
C1 : 1 + N' = N
============================
N >= N'
< apply count_is_integer to C.
Subgoal 1:
Variables: H T N N'
CT : count H T N'
C : count H T N'
C1 : 1 + N' = N
H1 : is_integer N'
============================
N >= N'
< L: apply lt_plus_one to C1 _.
Subgoal 1:
Variables: H T N N'
CT : count H T N'
C : count H T N'
C1 : 1 + N' = N
H1 : is_integer N'
L : N' < N
============================
N >= N'
< apply less_integer_lesseq to L.
Subgoal 1:
Variables: H T N N'
CT : count H T N'
C : count H T N'
C1 : 1 + N' = N
H1 : is_integer N'
L : N' < N
H2 : N' <= N
============================
N >= N'
< search.
Subgoal 2:
Variables: H T X N N'
CT : count X T N'
C : X = H -> false
C1 : count X T N
============================
N >= N'
< apply count_unique to CT C1.
Subgoal 2:
Variables: H T X N
CT : count X T N
C : X = H -> false
C1 : count X T N
============================
N >= N
< apply count_is_integer to CT.
Subgoal 2:
Variables: H T X N
CT : count X T N
C : X = H -> false
C1 : count X T N
H1 : is_integer N
============================
N >= N
< backchain is_integer_greatereq.
Proof completed.
< Theorem counts_subset :
forall A B,
is_list is_clause A -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B.
============================
forall A B,
is_list is_clause A -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
< induction on 1.
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
============================
forall A B,
is_list is_clause A @ -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
< intros IsA IsB Counts.
Variables: A B
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsA : is_list is_clause A @
IsB : is_list is_clause B
Counts : forall C NA NB, count C A NA -> count C B NB -> NB >= NA
============================
subset A B
< IsA: case IsA.
Subgoal 1:
Variables: B
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C [] NA -> count C B NB -> NB >= NA
============================
subset [] B
< search.
Subgoal 2:
Variables: B T H
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
============================
subset (H::T) B
< CA: apply is_count_exists_clause to IsA1 IsA.
Subgoal 2:
Variables: B T H N
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
============================
subset (H::T) B
< IsN: apply count_is_integer to CA.
Subgoal 2:
Variables: B T H N
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
============================
subset (H::T) B
< P: apply plus_integer_total to _ IsN with
N1 = 1.
Subgoal 2:
Variables: B T H N N3
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
============================
subset (H::T) B
< CB: apply is_count_exists_clause to IsB IsA.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
============================
subset (H::T) B
< CAA: assert count H (H::T) N3.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
============================
subset (H::T) B
< GEq: apply Counts to CAA CB.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
============================
subset (H::T) B
< IsN: apply count_is_integer to CA.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
============================
subset (H::T) B
< N0: apply count_geq_0 to CA.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
============================
subset (H::T) B
< NN3: apply lt_plus_one to P _.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
============================
subset (H::T) B
< G: assert N3 > 0.
Subgoal 2.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
============================
N3 > 0
< Or: apply greatereq_integer_greater_or_eq to N0.
Subgoal 2.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
Or : N > 0 \/ N = 0
============================
N3 > 0
< G: case Or.
Subgoal 2.1.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N > 0
============================
N3 > 0
< G2: apply less_integer_flip_greater to NN3.
Subgoal 2.1.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N > 0
G2 : N3 > N
============================
N3 > 0
< apply greater_integer_transitive to G2 G.
Subgoal 2.1.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N > 0
G2 : N3 > N
H1 : N3 > 0
============================
N3 > 0
< search.
Subgoal 2.1.2:
Variables: B T H N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T 0
IsN : is_integer 0
P : 1 + 0 = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer 0
N0 : 0 >= 0
NN3 : 0 < N3
============================
N3 > 0
< apply less_integer_flip_greater to NN3.
Subgoal 2.1.2:
Variables: B T H N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T 0
IsN : is_integer 0
P : 1 + 0 = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer 0
N0 : 0 >= 0
NN3 : 0 < N3
H1 : N3 > 0
============================
N3 > 0
< search.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
============================
subset (H::T) B
< N10: assert N1 > 0.
Subgoal 2.2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
============================
N1 > 0
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
Or : N1 > N3 \/ N1 = N3
============================
N1 > 0
< E: case Or.
Subgoal 2.2.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
E : N1 > N3
============================
N1 > 0
< apply greater_integer_transitive to E G.
Subgoal 2.2.1:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
E : N1 > N3
H1 : N1 > 0
============================
N1 > 0
< search.
Subgoal 2.2.2:
Variables: B T H N N3
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N3
CAA : count H (H::T) N3
GEq : N3 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
============================
N3 > 0
< search.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
============================
subset (H::T) B
< MHB: apply count_mem to CB N10.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
============================
subset (H::T) B
< assert forall C NA NB,
count C T NA -> count C B NB -> NB >= NA.
Subgoal 2.3:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
============================
forall C NA NB, count C T NA -> count C B NB -> NB >= NA
< intros CT CB'.
Subgoal 2.3:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
============================
NB >= NA
< GEqNA: apply count_geq_0 to CT.
Subgoal 2.3:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
============================
NB >= NA
< Or: apply greatereq_integer_greater_or_eq to GEqNA.
Subgoal 2.3:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
Or : NA > 0 \/ NA = 0
============================
NB >= NA
< E: case Or.
Subgoal 2.3.1:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
E : NA > 0
============================
NB >= NA
< M: apply count_mem to CT E.
Subgoal 2.3.1:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
E : NA > 0
M : mem C T
============================
NB >= NA
< IsC: apply mem_is_clause to _ M.
Subgoal 2.3.1:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
E : NA > 0
M : mem C T
IsC : is_clause C
============================
NB >= NA
< Or: apply is_clause_eq_or_not to IsC IsA.
Subgoal 2.3.1:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
E : NA > 0
M : mem C T
IsC : is_clause C
Or : C = H \/ (C = H -> false)
============================
NB >= NA
< Eq: case Or.
Subgoal 2.3.1.1:
Variables: B T H N N3 N1 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
============================
NB >= NA
< apply count_unique to CA CT.
Subgoal 2.3.1.1:
Variables: B T H N3 N1 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
============================
NB >= NA
< apply count_unique to CB CB'.
Subgoal 2.3.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
============================
NB >= NA
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.3.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
Or : NB > N3 \/ NB = N3
============================
NB >= NA
< C: case Or.
Subgoal 2.3.1.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
C : NB > N3
============================
NB >= NA
< L: apply greater_integer_flip_less to C.
Subgoal 2.3.1.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
C : NB > N3
L : N3 < NB
============================
NB >= NA
< L': apply less_integer_transitive to NN3 L.
Subgoal 2.3.1.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
C : NB > N3
L : N3 < NB
L' : NA < NB
============================
NB >= NA
< apply less_integer_lesseq to L'.
Subgoal 2.3.1.1.1:
Variables: B T H N3 NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B NB
CAA : count H (H::T) N3
GEq : NB >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : NB > 0
MHB : mem H B
CT : count H T NA
CB' : count H B NB
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
C : NB > N3
L : N3 < NB
L' : NA < NB
H1 : NA <= NB
============================
NB >= NA
< search.
Subgoal 2.3.1.1.2:
Variables: B T H N3 NA
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B N3
CAA : count H (H::T) N3
GEq : N3 >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : N3 > 0
MHB : mem H B
CT : count H T NA
CB' : count H B N3
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
============================
N3 >= NA
< apply less_integer_lesseq to NN3.
Subgoal 2.3.1.1.2:
Variables: B T H N3 NA
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T NA
IsN : is_integer NA
P : 1 + NA = N3
CB : count H B N3
CAA : count H (H::T) N3
GEq : N3 >= N3
IsN1 : is_integer NA
N0 : NA >= 0
NN3 : NA < N3
G : N3 > 0
N10 : N3 > 0
MHB : mem H B
CT : count H T NA
CB' : count H B N3
GEqNA : NA >= 0
E : NA > 0
M : mem H T
IsC : is_clause H
H1 : NA <= N3
============================
N3 >= NA
< search.
Subgoal 2.3.1.2:
Variables: B T H N N3 N1 C NA NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T NA
CB' : count C B NB
GEqNA : NA >= 0
E : NA > 0
M : mem C T
IsC : is_clause C
Eq : C = H -> false
============================
NB >= NA
< backchain Counts.
Subgoal 2.3.2:
Variables: B T H N N3 N1 C NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T 0
CB' : count C B NB
GEqNA : 0 >= 0
============================
NB >= 0
< apply count_geq_0 to CB'.
Subgoal 2.3.2:
Variables: B T H N N3 N1 C NB
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
CT : count C T 0
CB' : count C B NB
GEqNA : 0 >= 0
H1 : NB >= 0
============================
NB >= 0
< search.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
H1 : forall C NA NB, count C T NA -> count C B NB -> NB >= NA
============================
subset (H::T) B
< apply IH to IsA1 IsB _.
Subgoal 2:
Variables: B T H N N3 N1
IH : forall A B,
is_list is_clause A * -> is_list is_clause B -> (forall C NA NB,
count C A NA -> count C B NB -> NB >= NA) -> subset A B
IsB : is_list is_clause B
Counts : forall C NA NB, count C (H::T) NA -> count C B NB -> NB >= NA
IsA : is_clause H
IsA1 : is_list is_clause T *
CA : count H T N
IsN : is_integer N
P : 1 + N = N3
CB : count H B N1
CAA : count H (H::T) N3
GEq : N1 >= N3
IsN1 : is_integer N
N0 : N >= 0
NN3 : N < N3
G : N3 > 0
N10 : N1 > 0
MHB : mem H B
H1 : forall C NA NB, count C T NA -> count C B NB -> NB >= NA
H2 : subset T B
============================
subset (H::T) B
< search.
Proof completed.
< Theorem remove_all_reduce_counts :
forall K ID KRest V VR X N N',
remove_all K ID KRest -> values K V -> values KRest VR -> count X V N -> count X VR N' ->
N >= N'.
============================
forall K ID KRest V VR X N N',
remove_all K ID KRest -> values K V -> values KRest VR -> count X V N -> count X VR N' ->
N >= N'
< induction on 1.
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
============================
forall K ID KRest V VR X N N',
remove_all K ID KRest @ -> values K V -> values KRest VR -> count X V N -> count X VR N' ->
N >= N'
< intros RA VK VKR CV CVR.
Variables: K ID KRest V VR X N N'
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : remove_all K ID KRest @
VK : values K V
VKR : values KRest VR
CV : count X V N
CVR : count X VR N'
============================
N >= N'
< RA: case RA.
Subgoal 1:
Variables: ID V VR X N N'
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VK : values [] V
VKR : values [] VR
CV : count X V N
CVR : count X VR N'
============================
N >= N'
< case VK.
Subgoal 1:
Variables: ID VR X N N'
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values [] VR
CV : count X [] N
CVR : count X VR N'
============================
N >= N'
< case VKR.
Subgoal 1:
Variables: ID X N N'
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
CV : count X [] N
CVR : count X [] N'
============================
N >= N'
< case CV.
Subgoal 1:
Variables: ID X N'
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
CVR : count X [] N'
============================
0 >= N'
< case CVR.
Subgoal 1:
Variables: ID X
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
============================
0 >= 0
< search.
Subgoal 2:
Variables: ID KRest V VR X N N' IRest C
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VK : values ((ID, C)::IRest) V
VKR : values KRest VR
CV : count X V N
CVR : count X VR N'
RA : remove_all IRest ID KRest *
============================
N >= N'
< VK: case VK.
Subgoal 2:
Variables: ID KRest VR X N N' IRest C VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CV : count X (C::VRest) N
CVR : count X VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
============================
N >= N'
< CV: case CV.
Subgoal 2.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
============================
N >= N'
< GEq: apply IH to RA VK VKR CV CVR.
Subgoal 2.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
============================
N >= N'
< apply count_is_integer to CV.
Subgoal 2.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
============================
N >= N'
< L: apply lt_plus_one to CV1 _.
Subgoal 2.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
============================
N >= N'
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
Or : N1 > N' \/ N1 = N'
============================
N >= N'
< E: case Or.
Subgoal 2.1.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
E : N1 > N'
============================
N >= N'
< L': apply greater_integer_flip_less to E.
Subgoal 2.1.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
E : N1 > N'
L' : N' < N1
============================
N >= N'
< L2: apply less_integer_transitive to L' L.
Subgoal 2.1.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
E : N1 > N'
L' : N' < N1
L2 : N' < N
============================
N >= N'
< apply less_integer_lesseq to L2.
Subgoal 2.1.1:
Variables: ID KRest VR N N' IRest C VRest N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N1
CV1 : 1 + N1 = N
GEq : N1 >= N'
H1 : is_integer N1
L : N1 < N
E : N1 > N'
L' : N' < N1
L2 : N' < N
H2 : N' <= N
============================
N >= N'
< search.
Subgoal 2.1.2:
Variables: ID KRest VR N N' IRest C VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N'
CV1 : 1 + N' = N
GEq : N' >= N'
H1 : is_integer N'
L : N' < N
============================
N >= N'
< apply less_integer_lesseq to L.
Subgoal 2.1.2:
Variables: ID KRest VR N N' IRest C VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count C VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : count C VRest N'
CV1 : 1 + N' = N
GEq : N' >= N'
H1 : is_integer N'
L : N' < N
H2 : N' <= N
============================
N >= N'
< search.
Subgoal 2.2:
Variables: ID KRest VR X N N' IRest C VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count X VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : X = C -> false
CV1 : count X VRest N
============================
N >= N'
< apply IH to RA VK VKR CV1 CVR.
Subgoal 2.2:
Variables: ID KRest VR X N N' IRest C VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values KRest VR
CVR : count X VR N'
RA : remove_all IRest ID KRest *
VK : values IRest VRest
CV : X = C -> false
CV1 : count X VRest N
H1 : N >= N'
============================
N >= N'
< search.
Subgoal 3:
Variables: ID V VR X N N' Rest C A IRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VK : values ((A, C)::IRest) V
VKR : values ((A, C)::Rest) VR
CV : count X V N
CVR : count X VR N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
============================
N >= N'
< VK: case VK.
Subgoal 3:
Variables: ID VR X N N' Rest C A IRest VRest
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
VKR : values ((A, C)::Rest) VR
CV : count X (C::VRest) N
CVR : count X VR N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
============================
N >= N'
< VKR: case VKR.
Subgoal 3:
Variables: ID X N N' Rest C A IRest VRest VRest1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
CV : count X (C::VRest) N
CVR : count X (C::VRest1) N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
============================
N >= N'
< CV: case CV.
Subgoal 3.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
CVR : count C (C::VRest1) N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
============================
N >= N'
< CVR: case CVR.
Subgoal 3.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
============================
N >= N'
< GEq: apply IH to RA1 VK VKR CV CVR.
Subgoal 3.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
============================
N >= N'
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 3.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
Or : N1 > N2 \/ N1 = N2
============================
N >= N'
< E: case Or.
Subgoal 3.1.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
E : N1 > N2
============================
N >= N'
< L: apply greater_integer_flip_less to E.
Subgoal 3.1.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
E : N1 > N2
L : N2 < N1
============================
N >= N'
< L': apply less_sums to CVR1 CV1 _ _.
Subgoal 3.1.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
E : N1 > N2
L : N2 < N1
L' : N' < N
============================
N >= N'
< apply less_integer_lesseq to L'.
Subgoal 3.1.1.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N1 >= N2
E : N1 > N2
L : N2 < N1
L' : N' < N
H1 : N' <= N
============================
N >= N'
< search.
Subgoal 3.1.1.2:
Variables: ID N N' Rest C A IRest VRest VRest1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N2
CV1 : 1 + N2 = N
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N2 >= N2
============================
N >= N'
< apply plus_integer_unique to CV1 CVR1.
Subgoal 3.1.1.2:
Variables: ID N' Rest C A IRest VRest VRest1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N2
CV1 : 1 + N2 = N'
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N2 >= N2
============================
N' >= N'
< apply count_is_integer to CV.
Subgoal 3.1.1.2:
Variables: ID N' Rest C A IRest VRest VRest1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N2
CV1 : 1 + N2 = N'
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N2 >= N2
H1 : is_integer N2
============================
N' >= N'
< apply plus_integer_is_integer to _ _ CV1.
Subgoal 3.1.1.2:
Variables: ID N' Rest C A IRest VRest VRest1 N2
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N2
CV1 : 1 + N2 = N'
CVR : count C VRest1 N2
CVR1 : 1 + N2 = N'
GEq : N2 >= N2
H1 : is_integer N2
H2 : is_integer N'
============================
N' >= N'
< backchain is_integer_greatereq.
Subgoal 3.1.2:
Variables: ID N N' Rest C A IRest VRest VRest1 N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : count C VRest N1
CV1 : 1 + N1 = N
CVR : C = C -> false
CVR1 : count C VRest1 N'
============================
N >= N'
< apply CVR to _.
Subgoal 3.2:
Variables: ID X N N' Rest C A IRest VRest VRest1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
CVR : count X (C::VRest1) N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : X = C -> false
CV1 : count X VRest N
============================
N >= N'
< CVR: case CVR.
Subgoal 3.2.1:
Variables: ID N N' Rest C A IRest VRest VRest1 N1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : C = C -> false
CV1 : count C VRest N
CVR : count C VRest1 N1
CVR1 : 1 + N1 = N'
============================
N >= N'
< apply CV to _.
Subgoal 3.2.2:
Variables: ID X N N' Rest C A IRest VRest VRest1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : X = C -> false
CV1 : count X VRest N
CVR : X = C -> false
CVR1 : count X VRest1 N'
============================
N >= N'
< apply IH to RA1 VK VKR CV1 CVR1.
Subgoal 3.2.2:
Variables: ID X N N' Rest C A IRest VRest VRest1
IH : forall K ID KRest V VR X N N',
remove_all K ID KRest * -> values K V -> values KRest VR -> count X V N ->
count X VR N' -> N >= N'
RA : A = ID -> false
RA1 : remove_all IRest ID Rest *
VK : values IRest VRest
VKR : values Rest VRest1
CV : X = C -> false
CV1 : count X VRest N
CVR : X = C -> false
CVR1 : count X VRest1 N'
H1 : N >= N'
============================
N >= N'
< search.
Proof completed.
< Extensible_Theorem
toDrat_maintains_proof : forall P D KnownL KnownD V,
IsKnownL : is_list (is_pair is_integer is_clause) KnownL ->
IsKnownD : is_list is_clause KnownD ->
IsP : is_proof P ->
CP : checkProof KnownL P ->
GCL : good_clause_list KnownL ->
TD : toDrat KnownL P D ->
Vals : values KnownL V ->
Counts : (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) ->
checkDrat KnownD D
on TD.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
CP : checkProof KnownL (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
============================
checkDrat KnownD addDratEmpty
< CP: case CP.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
CP : rupProof KnownL emptyClause Prf
============================
checkDrat KnownD addDratEmpty
< IsV: apply values_is to _ Vals.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
CP : rupProof KnownL emptyClause Prf
IsV : is_list is_clause V
============================
checkDrat KnownD addDratEmpty
< S: apply counts_subset to IsV IsKnownD Counts.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
CP : rupProof KnownL emptyClause Prf
IsV : is_list is_clause V
S : subset V KnownD
============================
checkDrat KnownD addDratEmpty
< D: apply rupProof__drup to CP Vals.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
CP : rupProof KnownL emptyClause Prf
IsV : is_list is_clause V
S : subset V KnownD
D : drup V emptyClause
============================
checkDrat KnownD addDratEmpty
< D': apply drup_subset to D S.
Subgoal 1:
Variables: KnownL KnownD V Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (emptyLrat ID Prf)
GCL : good_clause_list KnownL
TD : toDrat KnownL (emptyLrat ID Prf) addDratEmpty @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
CP : rupProof KnownL emptyClause Prf
IsV : is_list is_clause V
S : subset V KnownD
D : drup V emptyClause
D' : drup KnownD emptyClause
============================
checkDrat KnownD addDratEmpty
< search.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (addLrupProof ID C Prf Rest)
CP : checkProof KnownL (addLrupProof ID C Prf Rest)
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
============================
checkDrat KnownD (addDratClause C DRest)
< CP: case CP.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (addLrupProof ID C Prf Rest)
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
============================
checkDrat KnownD (addDratClause C DRest)
< Is: case IsP.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
============================
checkDrat KnownD (addDratClause C DRest)
< IsV: apply values_is to _ Vals.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
============================
checkDrat KnownD (addDratClause C DRest)
< S: apply counts_subset to IsV IsKnownD Counts.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
============================
checkDrat KnownD (addDratClause C DRest)
< D: apply rupProof__drup to CP1 Vals.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
============================
checkDrat KnownD (addDratClause C DRest)
< D': apply drup_subset to D S.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest1
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest1) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
============================
checkDrat KnownD (addDratClause C DRest)
< apply remove_all_unique to CP TD1.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
============================
checkDrat KnownD (addDratClause C DRest)
< GCL_KR: apply good_clause_list_remove_all_add to _ TD1 with
C = C.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
============================
checkDrat KnownD (addDratClause C DRest)
< IsKR: apply remove_all_is to _ TD1.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
============================
checkDrat KnownD (addDratClause C DRest)
< VKR: apply values_exist to IsKR.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
============================
checkDrat KnownD (addDratClause C DRest)
< VKR+: assert values ((ID, C)::KRest) (C::V1).
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
============================
checkDrat KnownD (addDratClause C DRest)
< assert forall C1 NA NB,
count C1 (C::V1) NA -> count C1 (C::KnownD) NB -> NB >= NA.
Subgoal 2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
============================
forall C1 NA NB, count C1 (C::V1) NA -> count C1 (C::KnownD) NB -> NB >= NA
< intros CA CB.
Subgoal 2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C1 (C::V1) NA
CB : count C1 (C::KnownD) NB
============================
NB >= NA
< CA: case CA.
Subgoal 2.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CB : count C (C::KnownD) NB
CA : count C V1 N
CA1 : 1 + N = NA
============================
NB >= NA
< CB: case CB.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
============================
NB >= NA
< CV: apply is_count_exists_clause to IsV Is1.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
============================
NB >= NA
< GEq: apply Counts to CV CB.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
============================
NB >= NA
< GEq': apply remove_all_reduce_counts to TD1 Vals VKR CV CA.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
============================
NB >= NA
< GEq'': apply greatereq_integer_transitive to GEq GEq'.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
============================
NB >= NA
< Or: apply greatereq_integer_greater_or_eq to GEq''.
Subgoal 2.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
Or : N1 > N \/ N1 = N
============================
NB >= NA
< E: case Or.
Subgoal 2.1.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
E : N1 > N
============================
NB >= NA
< L: apply greater_integer_flip_less to E.
Subgoal 2.1.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
E : N1 > N
L : N < N1
============================
NB >= NA
< L': apply less_sums to CA1 CB1 _ _.
Subgoal 2.1.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
E : N1 > N
L : N < N1
L' : NA < NB
============================
NB >= NA
< apply less_integer_lesseq to L'.
Subgoal 2.1.1.1.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N1 N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N1
CB1 : 1 + N1 = NB
CV : count C V N2
GEq : N1 >= N2
GEq' : N2 >= N
GEq'' : N1 >= N
E : N1 > N
L : N < N1
L' : NA < NB
H1 : NA <= NB
============================
NB >= NA
< search.
Subgoal 2.1.1.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : count C KnownD N
CB1 : 1 + N = NB
CV : count C V N2
GEq : N >= N2
GEq' : N2 >= N
GEq'' : N >= N
============================
NB >= NA
< apply plus_integer_unique to CA1 CB1.
Subgoal 2.1.1.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NB N N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NB
CB : count C KnownD N
CB1 : 1 + N = NB
CV : count C V N2
GEq : N >= N2
GEq' : N2 >= N
GEq'' : N >= N
============================
NB >= NB
< apply count_is_integer to CA.
Subgoal 2.1.1.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NB N N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NB
CB : count C KnownD N
CB1 : 1 + N = NB
CV : count C V N2
GEq : N >= N2
GEq' : N2 >= N
GEq'' : N >= N
H1 : is_integer N
============================
NB >= NB
< apply plus_integer_is_integer to _ _ CB1.
Subgoal 2.1.1.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NB N N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NB
CB : count C KnownD N
CB1 : 1 + N = NB
CV : count C V N2
GEq : N >= N2
GEq' : N2 >= N
GEq'' : N >= N
H1 : is_integer N
H2 : is_integer NB
============================
NB >= NB
< backchain is_integer_greatereq.
Subgoal 2.1.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : count C V1 N
CA1 : 1 + N = NA
CB : C = C -> false
CB1 : count C KnownD NB
============================
NB >= NA
< apply CB to _.
Subgoal 2.1.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CB : count C1 (C::KnownD) NB
CA : C1 = C -> false
CA1 : count C1 V1 NA
============================
NB >= NA
< CB: case CB.
Subgoal 2.1.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C = C -> false
CA1 : count C V1 NA
CB : count C KnownD N
CB1 : 1 + N = NB
============================
NB >= NA
< apply CA to _.
Subgoal 2.1.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
============================
NB >= NA
< GEq: apply count_geq_0 to CB1.
Subgoal 2.1.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
============================
NB >= NA
< GEq': apply count_geq_0 to CA1.
Subgoal 2.1.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
============================
NB >= NA
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 2.1.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
============================
NB >= NA
< Or': apply greatereq_integer_greater_or_eq to GEq'.
Subgoal 2.1.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
Or' : NA > 0 \/ NA = 0
============================
NB >= NA
< E: case Or'.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
============================
NB >= NA
< M: apply count_mem to CA1 E.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
============================
NB >= NA
< IsV1: apply values_is to _ VKR.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
============================
NB >= NA
< IsC1: apply mem_is_clause to _ M.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
IsC1 : is_clause C1
============================
NB >= NA
< CV: apply is_count_exists_clause to IsV IsC1.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
IsC1 : is_clause C1
CV : count C1 V N
============================
NB >= NA
< GEq2: apply Counts to CV CB1.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
IsC1 : is_clause C1
CV : count C1 V N
GEq2 : NB >= N
============================
NB >= NA
< GEq3: apply remove_all_reduce_counts to TD1 Vals VKR CV CA1.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
IsC1 : is_clause C1
CV : count C1 V N
GEq2 : NB >= N
GEq3 : N >= NA
============================
NB >= NA
< apply greatereq_integer_transitive to GEq2 GEq3.
Subgoal 2.1.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NA NB N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 NA
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M : mem C1 V1
IsV1 : is_list is_clause V1
IsC1 : is_clause C1
CV : count C1 V N
GEq2 : NB >= N
GEq3 : N >= NA
H1 : NB >= NA
============================
NB >= NA
< search.
Subgoal 2.1.2.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 0
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : 0 >= 0
Or : NB > 0 \/ NB = 0
============================
NB >= 0
< E: case Or.
Subgoal 2.1.2.2.2.1:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1 NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 0
CB : C1 = C -> false
CB1 : count C1 KnownD NB
GEq : NB >= 0
GEq' : 0 >= 0
E : NB > 0
============================
NB >= 0
< search.
Subgoal 2.1.2.2.2.2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1 C1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
CA : C1 = C -> false
CA1 : count C1 V1 0
CB : C1 = C -> false
CB1 : count C1 KnownD 0
GEq : 0 >= 0
GEq' : 0 >= 0
============================
0 >= 0
< search.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
H1 : forall C1 NA NB, count C1 (C::V1) NA -> count C1 (C::KnownD) NB -> NB >= NA
============================
checkDrat KnownD (addDratClause C DRest)
< apply IH to _ _ Is3 CP2 GCL_KR TD2 VKR+ _ with
KnownD = C::KnownD.
Subgoal 2:
Variables: KnownL KnownD V KRest DRest C Rest Prf ID V1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (addLrupProof ID C Prf Rest) (addDratClause C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : remove_all KnownL ID KRest
TD2 : toDrat ((ID, C)::KRest) Rest DRest *
CP : remove_all KnownL ID KRest
CP1 : rupProof KnownL C Prf
CP2 : checkProof ((ID, C)::KRest) Rest
Is : is_integer ID
Is1 : is_clause C
Is2 : is_list is_integer Prf
Is3 : is_proof Rest
IsV : is_list is_clause V
S : subset V KnownD
D : drup V C
D' : drup KnownD C
GCL_KR : good_clause_list ((ID, C)::KRest)
IsKR : is_list (is_pair is_integer is_clause) KRest
VKR : values KRest V1
VKR+ : values ((ID, C)::KRest) (C::V1)
H1 : forall C1 NA NB, count C1 (C::V1) NA -> count C1 (C::KnownD) NB -> NB >= NA
H2 : checkDrat (C::KnownD) DRest
============================
checkDrat KnownD (addDratClause C DRest)
< search.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (deleteLratProof ID Rest)
CP : checkProof KnownL (deleteLratProof ID Rest)
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
============================
checkDrat KnownD (deleteDrat C DRest)
< CP: case CP.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1 KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof (deleteLratProof ID Rest)
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest1 KnownL
CP1 : checkProof KRest1 Rest
============================
checkDrat KnownD (deleteDrat C DRest)
< Is: case IsP.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1 KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest1 KnownL
CP1 : checkProof KRest1 Rest
Is : is_integer ID
Is1 : is_proof Rest
============================
checkDrat KnownD (deleteDrat C DRest)
< IsKR: apply select_is to _ TD1.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1 KRest1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest1 KnownL
CP1 : checkProof KRest1 Rest
Is : is_integer ID
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
============================
checkDrat KnownD (deleteDrat C DRest)
< apply good_clause_list_selects to _ CP TD1.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
============================
checkDrat KnownD (deleteDrat C DRest)
< VS: apply values_select to _ TD1.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1 VRest
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C VRest V
VS1 : values KRest VRest
============================
checkDrat KnownD (deleteDrat C DRest)
< M: apply select_mem to TD1.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest C Rest ID C1 VRest
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID Rest) (deleteDrat C DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID, C) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C VRest V
VS1 : values KRest VRest
M : mem (ID, C) KnownL
============================
checkDrat KnownD (deleteDrat C DRest)
< Is: apply mem_is to _ M.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
============================
checkDrat KnownD (deleteDrat C2 DRest)
< IsV: apply values_is to _ Vals.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
============================
checkDrat KnownD (deleteDrat C2 DRest)
< CV: apply is_count_exists_clause to IsV Is3.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
============================
checkDrat KnownD (deleteDrat C2 DRest)
< CKD: apply is_count_exists_clause to IsKnownD Is3.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
============================
checkDrat KnownD (deleteDrat C2 DRest)
< NPos: assert N > 0.
Subgoal 3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
============================
N > 0
< GEq: apply count_geq_0 to CV.
Subgoal 3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
GEq : N >= 0
============================
N > 0
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
GEq : N >= 0
Or : N > 0 \/ N = 0
============================
N > 0
< L: case Or.
Subgoal 3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
GEq : N >= 0
L : N > 0
============================
N > 0
< search.
Subgoal 3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V 0
CKD : count C2 KnownD N1
GEq : 0 >= 0
============================
0 > 0
< MV: apply select_mem to VS.
Subgoal 3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V 0
CKD : count C2 KnownD N1
GEq : 0 >= 0
MV : mem C2 V
============================
0 > 0
< apply count_not_mem to CV MV.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
============================
checkDrat KnownD (deleteDrat C2 DRest)
< N1N: apply Counts to CV CKD.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
============================
checkDrat KnownD (deleteDrat C2 DRest)
< N1Pos: assert N1 > 0.
Subgoal 3.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
============================
N1 > 0
< Or: apply greatereq_integer_greater_or_eq to N1N.
Subgoal 3.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
Or : N1 > N \/ N1 = N
============================
N1 > 0
< G: case Or.
Subgoal 3.2.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
G : N1 > N
============================
N1 > 0
< apply greater_integer_transitive to G NPos.
Subgoal 3.2.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
G : N1 > N
H1 : N1 > 0
============================
N1 > 0
< search.
Subgoal 3.2.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N
NPos : N > 0
N1N : N >= N
============================
N > 0
< search.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1N : N1 >= N
N1Pos : N1 > 0
============================
checkDrat KnownD (deleteDrat C2 DRest)
< clear N1N.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
============================
checkDrat KnownD (deleteDrat C2 DRest)
< MKD: apply count_mem to CKD N1Pos.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
============================
checkDrat KnownD (deleteDrat C2 DRest)
< SKD: apply mem_select to MKD.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
============================
checkDrat KnownD (deleteDrat C2 DRest)
< IsL': apply select_is_clause to _ SKD.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
============================
checkDrat KnownD (deleteDrat C2 DRest)
< GCL_KR: apply good_clause_list_select to _ TD1.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
============================
checkDrat KnownD (deleteDrat C2 DRest)
< assert forall C NA NB,
count C VRest NA -> count C L' NB -> NB >= NA.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
============================
forall C NA NB, count C VRest NA -> count C L' NB -> NB >= NA
< intros CA CB.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
============================
NB >= NA
< GEq: apply count_geq_0 to CB.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
============================
NB >= NA
< GEq': apply count_geq_0 to CA.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
============================
NB >= NA
< Or: apply greatereq_integer_greater_or_eq to GEq.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
============================
NB >= NA
< Or': apply greatereq_integer_greater_or_eq to GEq'.
Subgoal 3.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
Or' : NA > 0 \/ NA = 0
============================
NB >= NA
< E: case Or'.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
============================
NB >= NA
< M': apply count_mem to CA E.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
============================
NB >= NA
< IsVRest: apply values_is to _ VS1.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
============================
NB >= NA
< IsC3: apply mem_is_clause to _ M'.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
============================
NB >= NA
< CV: apply is_count_exists_clause to IsV IsC3.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
============================
NB >= NA
< IsC2: apply mem_is_clause to _ MKD.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
============================
NB >= NA
< Or'': apply is_clause_eq_or_not to IsC3 IsC2.
Subgoal 3.3.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
Or'' : C3 = C2 \/ (C3 = C2 -> false)
============================
NB >= NA
< CE: case Or''.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
============================
NB >= NA
< IsN2: apply count_is_integer to CV1.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
============================
NB >= NA
< Minus: apply minus_integer_total to IsN2 _ with
N2 = 1.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = N3
============================
NB >= NA
< P: apply minus_plus_same_integer to _ _ Minus.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = N3
P : N3 + 1 = N2
============================
NB >= NA
< IsN3: apply minus_integer_is_integer to _ _ Minus.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = N3
P : N3 + 1 = N2
IsN3 : is_integer N3
============================
NB >= NA
< P': apply plus_integer_comm to _ _ P.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = N3
P : N3 + 1 = N2
IsN3 : is_integer N3
P' : 1 + N3 = N2
============================
NB >= NA
< CVRest: apply select_count to CV1 VS _.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = N3
P : N3 + 1 = N2
IsN3 : is_integer N3
P' : 1 + N3 = N2
CVRest : count C2 VRest N3
============================
NB >= NA
< apply count_unique to CVRest CA.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
============================
NB >= NA
< IsN1: apply count_is_integer to CKD.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
============================
NB >= NA
< Minus': apply minus_integer_total to IsN1 _ with
N2 = 1.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N4
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = N4
============================
NB >= NA
< P1: apply minus_plus_same_integer to _ _ Minus'.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N4
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = N4
P1 : N4 + 1 = N1
============================
NB >= NA
< IsN4: apply minus_integer_is_integer to _ _ Minus'.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N4
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = N4
P1 : N4 + 1 = N1
IsN4 : is_integer N4
============================
NB >= NA
< P2: apply plus_integer_comm to _ _ P1.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N4
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = N4
P1 : N4 + 1 = N1
IsN4 : is_integer N4
P2 : 1 + N4 = N1
============================
NB >= NA
< CDRest: apply select_count to CKD SKD Minus'.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2 N4
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = N4
P1 : N4 + 1 = N1
IsN4 : is_integer N4
P2 : 1 + N4 = N1
CDRest : count C2 L' N4
============================
NB >= NA
< apply count_unique to CDRest CB.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
============================
NB >= NA
< GEq1: apply Counts to CV CKD.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N2
IsC2 : is_clause C2
IsN2 : is_integer N2
Minus : N2 - 1 = NA
P : NA + 1 = N2
IsN3 : is_integer NA
P' : 1 + NA = N2
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
============================
NB >= NA
< apply count_unique to CV1 CV.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
============================
NB >= NA
< Or1: apply greatereq_integer_greater_or_eq to GEq1.
Subgoal 3.3.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
Or1 : N1 > N \/ N1 = N
============================
NB >= NA
< G: case Or1.
Subgoal 3.3.1.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
============================
NB >= NA
< L: apply greater_integer_flip_less to G.
Subgoal 3.3.1.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
============================
NB >= NA
< OrRel: apply is_integer_related to IsN3 IsN4.
Subgoal 3.3.1.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
OrRel : (NA = NB \/ NA < NB) \/ NA > NB
============================
NB >= NA
< C: case OrRel.
Subgoal 3.3.1.1.1.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NB
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NB >= 0
Or : NB > 0 \/ NB = 0
E : NB > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NB
P : NB + 1 = N
IsN3 : is_integer NB
P' : 1 + NB = N
CVRest : count C2 VRest NB
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
============================
NB >= NB
< backchain is_integer_greatereq.
Subgoal 3.3.1.1.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA < NB
============================
NB >= NA
< G': apply less_integer_flip_greater to C.
Subgoal 3.3.1.1.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA < NB
G' : NB > NA
============================
NB >= NA
< backchain greater_integer_greatereq.
Subgoal 3.3.1.1.1.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA > NB
============================
NB >= NA
< apply greater_integer_flip_less to C.
Subgoal 3.3.1.1.1.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA > NB
H1 : NB < NA
============================
NB >= NA
< L': apply less_sums to P2 P' _ _.
Subgoal 3.3.1.1.1.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA > NB
H1 : NB < NA
L' : N1 < N
============================
NB >= NA
< G': assert N > N1.
Subgoal 3.3.1.1.1.3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N1
Minus' : N1 - 1 = NB
P1 : NB + 1 = N1
IsN4 : is_integer NB
P2 : 1 + NB = N1
CDRest : count C2 L' NB
GEq1 : N1 >= N
G : N1 > N
L : N < N1
C : NA > NB
H1 : NB < NA
L' : N1 < N
G' : N > N1
============================
NB >= NA
< apply greater_less_impossible to G' L.
Subgoal 3.3.1.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N L' NA NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N
NPos : N > 0
N1Pos : N > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NA
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NA
P : NA + 1 = N
IsN3 : is_integer NA
P' : 1 + NA = N
CVRest : count C2 VRest NA
IsN1 : is_integer N
Minus' : N - 1 = NB
P1 : NB + 1 = N
IsN4 : is_integer NB
P2 : 1 + NB = N
CDRest : count C2 L' NB
GEq1 : N >= N
============================
NB >= NA
< apply minus_integer_unique to Minus Minus'.
Subgoal 3.3.1.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N L' NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N
NPos : N > 0
N1Pos : N > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C2 VRest NB
CB : count C2 L' NB
GEq : NB >= 0
GEq' : NB >= 0
Or : NB > 0 \/ NB = 0
E : NB > 0
M' : mem C2 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C2
CV1 : count C2 V N
IsC2 : is_clause C2
IsN2 : is_integer N
Minus : N - 1 = NB
P : NB + 1 = N
IsN3 : is_integer NB
P' : 1 + NB = N
CVRest : count C2 VRest NB
IsN1 : is_integer N
Minus' : N - 1 = NB
P1 : NB + 1 = N
IsN4 : is_integer NB
P2 : 1 + NB = N
CDRest : count C2 L' NB
GEq1 : N >= N
============================
NB >= NB
< backchain is_integer_greatereq.
Subgoal 3.3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
CE : C3 = C2 -> false
============================
NB >= NA
< CV: apply count_select_neq to CA VS _.
Subgoal 3.3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
CE : C3 = C2 -> false
CV2 : count C3 V NA
============================
NB >= NA
< CKD': apply count_select_neq to CB SKD _.
Subgoal 3.3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
CE : C3 = C2 -> false
CV2 : count C3 V NA
CKD' : count C3 KnownD NB
============================
NB >= NA
< apply Counts to CV2 CKD'.
Subgoal 3.3.1.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NA NB N2
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest NA
CB : count C3 L' NB
GEq : NB >= 0
GEq' : NA >= 0
Or : NB > 0 \/ NB = 0
E : NA > 0
M' : mem C3 VRest
IsVRest : is_list is_clause VRest
IsC3 : is_clause C3
CV1 : count C3 V N2
IsC2 : is_clause C2
CE : C3 = C2 -> false
CV2 : count C3 V NA
CKD' : count C3 KnownD NB
H1 : NB >= NA
============================
NB >= NA
< search.
Subgoal 3.3.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest 0
CB : count C3 L' NB
GEq : NB >= 0
GEq' : 0 >= 0
Or : NB > 0 \/ NB = 0
============================
NB >= 0
< E: case Or.
Subgoal 3.3.2.1:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3 NB
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest 0
CB : count C3 L' NB
GEq : NB >= 0
GEq' : 0 >= 0
E : NB > 0
============================
NB >= 0
< search.
Subgoal 3.3.2.2:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L' C3
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
CA : count C3 VRest 0
CB : count C3 L' 0
GEq : 0 >= 0
GEq' : 0 >= 0
============================
0 >= 0
< search.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
H1 : forall C NA NB, count C VRest NA -> count C L' NB -> NB >= NA
============================
checkDrat KnownD (deleteDrat C2 DRest)
< apply IH to _ IsL' Is1 CP1 _ TD2 VS1 _.
Subgoal 3:
Variables: KnownL KnownD V KRest DRest Rest C1 VRest ID1 C2 N N1 L'
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
GCL : good_clause_list KnownL
TD : toDrat KnownL (deleteLratProof ID1 Rest) (deleteDrat C2 DRest) @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : select (ID1, C2) KRest KnownL
TD2 : toDrat KRest Rest DRest *
CP : select (ID1, C1) KRest KnownL
CP1 : checkProof KRest Rest
Is : is_integer ID1
Is1 : is_proof Rest
IsKR : is_list (is_pair is_integer is_clause) KRest
VS : select C2 VRest V
VS1 : values KRest VRest
M : mem (ID1, C2) KnownL
Is2 : is_integer ID1
Is3 : is_clause C2
IsV : is_list is_clause V
CV : count C2 V N
CKD : count C2 KnownD N1
NPos : N > 0
N1Pos : N1 > 0
MKD : mem C2 KnownD
SKD : select C2 L' KnownD
IsL' : is_list is_clause L'
GCL_KR : good_clause_list KRest
H1 : forall C NA NB, count C VRest NA -> count C L' NB -> NB >= NA
H2 : checkDrat L' DRest
============================
checkDrat KnownD (deleteDrat C2 DRest)
< search.
Subgoal 4:
Variables: D KnownL KnownD V PT
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof <unknown I proof>
CP : checkProof KnownL <unknown I proof>
GCL : good_clause_list KnownL
TD : toDrat KnownL <unknown I proof> D @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : KnownL |{proof}- <unknown I proof> ~~> PT
TD2 : toDrat KnownL PT D *
============================
checkDrat KnownD D
< CP': apply proj_checkProof to TD1 CP _ _.
Subgoal 4:
Variables: D KnownL KnownD V PT
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof <unknown I proof>
CP : checkProof KnownL <unknown I proof>
GCL : good_clause_list KnownL
TD : toDrat KnownL <unknown I proof> D @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : KnownL |{proof}- <unknown I proof> ~~> PT
TD2 : toDrat KnownL PT D *
CP' : checkProof KnownL PT
============================
checkDrat KnownD D
< apply proj_proof_is to TD1 IsP _ _.
Subgoal 4:
Variables: D KnownL KnownD V PT
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof <unknown I proof>
CP : checkProof KnownL <unknown I proof>
GCL : good_clause_list KnownL
TD : toDrat KnownL <unknown I proof> D @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : KnownL |{proof}- <unknown I proof> ~~> PT
TD2 : toDrat KnownL PT D *
CP' : checkProof KnownL PT
H1 : is_proof PT
============================
checkDrat KnownD D
< apply IH to _ _ _ CP' _ TD2 _ _.
Subgoal 4:
Variables: D KnownL KnownD V PT
IH : forall P D KnownL KnownD V,
is_list (is_pair is_integer is_clause) KnownL -> is_list is_clause KnownD ->
is_proof P -> checkProof KnownL P -> good_clause_list KnownL -> toDrat KnownL P D * ->
values KnownL V -> (forall C NA NB,
count C V NA -> count C KnownD NB -> NB >= NA) -> checkDrat KnownD D
IsKnownL : is_list (is_pair is_integer is_clause) KnownL
IsKnownD : is_list is_clause KnownD
IsP : is_proof <unknown I proof>
CP : checkProof KnownL <unknown I proof>
GCL : good_clause_list KnownL
TD : toDrat KnownL <unknown I proof> D @
Vals : values KnownL V
Counts : forall C NA NB, count C V NA -> count C KnownD NB -> NB >= NA
TD1 : KnownL |{proof}- <unknown I proof> ~~> PT
TD2 : toDrat KnownL PT D *
CP' : checkProof KnownL PT
H1 : is_proof PT
H2 : checkDrat KnownD D
============================
checkDrat KnownD D
< search.
Proof completed.
