src/HOL/Integ/cooper_proof.ML
author chaieb
Fri Aug 06 17:19:50 2004 +0200 (2004-08-06)
changeset 15122 4b52eeb62807
parent 15107 f233706d9fce
child 15123 4c49281dc9a8
permissions -rw-r--r--
proof_of_evalc corrected;
berghofe@13876
     1
(*  Title:      HOL/Integ/cooper_proof.ML
berghofe@13876
     2
    ID:         $Id$
berghofe@13876
     3
    Author:     Amine Chaieb and Tobias Nipkow, TU Muenchen
berghofe@13876
     4
berghofe@13876
     5
File containing the implementation of the proof
berghofe@13876
     6
generation for Cooper Algorithm
berghofe@13876
     7
*)
berghofe@13876
     8
chaieb@14920
     9
berghofe@13876
    10
signature COOPER_PROOF =
berghofe@13876
    11
sig
berghofe@13876
    12
  val qe_Not : thm
berghofe@13876
    13
  val qe_conjI : thm
berghofe@13876
    14
  val qe_disjI : thm
berghofe@13876
    15
  val qe_impI : thm
berghofe@13876
    16
  val qe_eqI : thm
berghofe@13876
    17
  val qe_exI : thm
chaieb@14877
    18
  val list_to_set : typ -> term list -> term
berghofe@13876
    19
  val qe_get_terms : thm -> term * term
chaieb@15122
    20
  val cooper_prv  : Sign.sg -> term -> term -> thm
chaieb@15122
    21
  val cooper_prv2 : Sign.sg -> term -> term -> thm
berghofe@13876
    22
  val proof_of_evalc : Sign.sg -> term -> thm
berghofe@13876
    23
  val proof_of_cnnf : Sign.sg -> term -> (term -> thm) -> thm
berghofe@13876
    24
  val proof_of_linform : Sign.sg -> string list -> term -> thm
chaieb@14877
    25
  val proof_of_adjustcoeffeq : Sign.sg -> term -> int -> term -> thm
chaieb@14758
    26
  val prove_elementar : Sign.sg -> string -> term -> thm
chaieb@14758
    27
  val thm_of : Sign.sg -> (term -> (term list * (thm list -> thm))) -> term -> thm
berghofe@13876
    28
end;
berghofe@13876
    29
berghofe@13876
    30
structure CooperProof : COOPER_PROOF =
berghofe@13876
    31
struct
berghofe@13876
    32
open CooperDec;
berghofe@13876
    33
chaieb@14758
    34
(*
chaieb@14758
    35
val presburger_ss = simpset_of (theory "Presburger")
chaieb@14758
    36
  addsimps [zdiff_def] delsimps [symmetric zdiff_def];
chaieb@14758
    37
*)
berghofe@13876
    38
berghofe@13876
    39
val presburger_ss = simpset_of (theory "Presburger")
chaieb@14758
    40
  addsimps[diff_int_def] delsimps [thm"diff_int_def_symmetric"];
berghofe@13876
    41
val cboolT = ctyp_of (sign_of HOL.thy) HOLogic.boolT;
berghofe@13876
    42
berghofe@13876
    43
(*Theorems that will be used later for the proofgeneration*)
berghofe@13876
    44
berghofe@13876
    45
val zdvd_iff_zmod_eq_0 = thm "zdvd_iff_zmod_eq_0";
berghofe@13876
    46
val unity_coeff_ex = thm "unity_coeff_ex";
berghofe@13876
    47
chaieb@14758
    48
(* Thorems for proving the adjustment of the coeffitients*)
berghofe@13876
    49
berghofe@13876
    50
val ac_lt_eq =  thm "ac_lt_eq";
berghofe@13876
    51
val ac_eq_eq = thm "ac_eq_eq";
berghofe@13876
    52
val ac_dvd_eq = thm "ac_dvd_eq";
berghofe@13876
    53
val ac_pi_eq = thm "ac_pi_eq";
berghofe@13876
    54
berghofe@13876
    55
(* The logical compination of the sythetised properties*)
berghofe@13876
    56
val qe_Not = thm "qe_Not";
berghofe@13876
    57
val qe_conjI = thm "qe_conjI";
berghofe@13876
    58
val qe_disjI = thm "qe_disjI";
berghofe@13876
    59
val qe_impI = thm "qe_impI";
berghofe@13876
    60
val qe_eqI = thm "qe_eqI";
berghofe@13876
    61
val qe_exI = thm "qe_exI";
berghofe@13876
    62
val qe_ALLI = thm "qe_ALLI";
berghofe@13876
    63
chaieb@14758
    64
(*Modulo D property for Pminusinf an Plusinf *)
berghofe@13876
    65
val fm_modd_minf = thm "fm_modd_minf";
berghofe@13876
    66
val not_dvd_modd_minf = thm "not_dvd_modd_minf";
berghofe@13876
    67
val dvd_modd_minf = thm "dvd_modd_minf";
berghofe@13876
    68
berghofe@13876
    69
val fm_modd_pinf = thm "fm_modd_pinf";
berghofe@13876
    70
val not_dvd_modd_pinf = thm "not_dvd_modd_pinf";
berghofe@13876
    71
val dvd_modd_pinf = thm "dvd_modd_pinf";
berghofe@13876
    72
chaieb@14758
    73
(* the minusinfinity proprty*)
berghofe@13876
    74
berghofe@13876
    75
val fm_eq_minf = thm "fm_eq_minf";
berghofe@13876
    76
val neq_eq_minf = thm "neq_eq_minf";
berghofe@13876
    77
val eq_eq_minf = thm "eq_eq_minf";
berghofe@13876
    78
val le_eq_minf = thm "le_eq_minf";
berghofe@13876
    79
val len_eq_minf = thm "len_eq_minf";
berghofe@13876
    80
val not_dvd_eq_minf = thm "not_dvd_eq_minf";
berghofe@13876
    81
val dvd_eq_minf = thm "dvd_eq_minf";
berghofe@13876
    82
chaieb@14758
    83
(* the Plusinfinity proprty*)
berghofe@13876
    84
berghofe@13876
    85
val fm_eq_pinf = thm "fm_eq_pinf";
berghofe@13876
    86
val neq_eq_pinf = thm "neq_eq_pinf";
berghofe@13876
    87
val eq_eq_pinf = thm "eq_eq_pinf";
berghofe@13876
    88
val le_eq_pinf = thm "le_eq_pinf";
berghofe@13876
    89
val len_eq_pinf = thm "len_eq_pinf";
berghofe@13876
    90
val not_dvd_eq_pinf = thm "not_dvd_eq_pinf";
berghofe@13876
    91
val dvd_eq_pinf = thm "dvd_eq_pinf";
berghofe@13876
    92
berghofe@13876
    93
(*Logical construction of the Property*)
berghofe@13876
    94
val eq_minf_conjI = thm "eq_minf_conjI";
berghofe@13876
    95
val eq_minf_disjI = thm "eq_minf_disjI";
berghofe@13876
    96
val modd_minf_disjI = thm "modd_minf_disjI";
berghofe@13876
    97
val modd_minf_conjI = thm "modd_minf_conjI";
berghofe@13876
    98
berghofe@13876
    99
val eq_pinf_conjI = thm "eq_pinf_conjI";
berghofe@13876
   100
val eq_pinf_disjI = thm "eq_pinf_disjI";
berghofe@13876
   101
val modd_pinf_disjI = thm "modd_pinf_disjI";
berghofe@13876
   102
val modd_pinf_conjI = thm "modd_pinf_conjI";
berghofe@13876
   103
berghofe@13876
   104
(*Cooper Backwards...*)
berghofe@13876
   105
(*Bset*)
berghofe@13876
   106
val not_bst_p_fm = thm "not_bst_p_fm";
berghofe@13876
   107
val not_bst_p_ne = thm "not_bst_p_ne";
berghofe@13876
   108
val not_bst_p_eq = thm "not_bst_p_eq";
berghofe@13876
   109
val not_bst_p_gt = thm "not_bst_p_gt";
berghofe@13876
   110
val not_bst_p_lt = thm "not_bst_p_lt";
berghofe@13876
   111
val not_bst_p_ndvd = thm "not_bst_p_ndvd";
berghofe@13876
   112
val not_bst_p_dvd = thm "not_bst_p_dvd";
berghofe@13876
   113
berghofe@13876
   114
(*Aset*)
berghofe@13876
   115
val not_ast_p_fm = thm "not_ast_p_fm";
berghofe@13876
   116
val not_ast_p_ne = thm "not_ast_p_ne";
berghofe@13876
   117
val not_ast_p_eq = thm "not_ast_p_eq";
berghofe@13876
   118
val not_ast_p_gt = thm "not_ast_p_gt";
berghofe@13876
   119
val not_ast_p_lt = thm "not_ast_p_lt";
berghofe@13876
   120
val not_ast_p_ndvd = thm "not_ast_p_ndvd";
berghofe@13876
   121
val not_ast_p_dvd = thm "not_ast_p_dvd";
berghofe@13876
   122
berghofe@13876
   123
(*Logical construction of the prop*)
berghofe@13876
   124
(*Bset*)
berghofe@13876
   125
val not_bst_p_conjI = thm "not_bst_p_conjI";
berghofe@13876
   126
val not_bst_p_disjI = thm "not_bst_p_disjI";
berghofe@13876
   127
val not_bst_p_Q_elim = thm "not_bst_p_Q_elim";
berghofe@13876
   128
berghofe@13876
   129
(*Aset*)
berghofe@13876
   130
val not_ast_p_conjI = thm "not_ast_p_conjI";
berghofe@13876
   131
val not_ast_p_disjI = thm "not_ast_p_disjI";
berghofe@13876
   132
val not_ast_p_Q_elim = thm "not_ast_p_Q_elim";
berghofe@13876
   133
berghofe@13876
   134
(*Cooper*)
berghofe@13876
   135
val cppi_eq = thm "cppi_eq";
berghofe@13876
   136
val cpmi_eq = thm "cpmi_eq";
berghofe@13876
   137
berghofe@13876
   138
(*Others*)
berghofe@13876
   139
val simp_from_to = thm "simp_from_to";
berghofe@13876
   140
val P_eqtrue = thm "P_eqtrue";
berghofe@13876
   141
val P_eqfalse = thm "P_eqfalse";
berghofe@13876
   142
berghofe@13876
   143
(*For Proving NNF*)
berghofe@13876
   144
berghofe@13876
   145
val nnf_nn = thm "nnf_nn";
berghofe@13876
   146
val nnf_im = thm "nnf_im";
berghofe@13876
   147
val nnf_eq = thm "nnf_eq";
berghofe@13876
   148
val nnf_sdj = thm "nnf_sdj";
berghofe@13876
   149
val nnf_ncj = thm "nnf_ncj";
berghofe@13876
   150
val nnf_nim = thm "nnf_nim";
berghofe@13876
   151
val nnf_neq = thm "nnf_neq";
berghofe@13876
   152
val nnf_ndj = thm "nnf_ndj";
berghofe@13876
   153
berghofe@13876
   154
(*For Proving term linearizition*)
berghofe@13876
   155
val linearize_dvd = thm "linearize_dvd";
berghofe@13876
   156
val lf_lt = thm "lf_lt";
berghofe@13876
   157
val lf_eq = thm "lf_eq";
berghofe@13876
   158
val lf_dvd = thm "lf_dvd";
berghofe@13876
   159
berghofe@13876
   160
berghofe@13876
   161
(* ------------------------------------------------------------------------- *)
berghofe@13876
   162
(*This function norm_zero_one  replaces the occurences of Numeral1 and Numeral0*)
berghofe@13876
   163
(*Respectively by their abstract representation Const("1",..) and COnst("0",..)*)
berghofe@13876
   164
(*this is necessary because the theorems use this representation.*)
berghofe@13876
   165
(* This function should be elminated in next versions...*)
berghofe@13876
   166
(* ------------------------------------------------------------------------- *)
berghofe@13876
   167
berghofe@13876
   168
fun norm_zero_one fm = case fm of
berghofe@13876
   169
  (Const ("op *",_) $ c $ t) => 
berghofe@13876
   170
    if c = one then (norm_zero_one t)
berghofe@13876
   171
    else if (dest_numeral c = ~1) 
berghofe@13876
   172
         then (Const("uminus",HOLogic.intT --> HOLogic.intT) $ (norm_zero_one t))
berghofe@13876
   173
         else (HOLogic.mk_binop "op *" (norm_zero_one c,norm_zero_one t))
berghofe@13876
   174
  |(node $ rest) => ((norm_zero_one node)$(norm_zero_one rest))
berghofe@13876
   175
  |(Abs(x,T,p)) => (Abs(x,T,(norm_zero_one p)))
berghofe@13876
   176
  |_ => fm;
berghofe@13876
   177
berghofe@13876
   178
(* ------------------------------------------------------------------------- *)
berghofe@13876
   179
(*function list to Set, constructs a set containing all elements of a given list.*)
berghofe@13876
   180
(* ------------------------------------------------------------------------- *)
berghofe@13876
   181
fun list_to_set T1 l = let val T = (HOLogic.mk_setT T1) in 
berghofe@13876
   182
	case l of 
berghofe@13876
   183
		[] => Const ("{}",T)
berghofe@13876
   184
		|(h::t) => Const("insert", T1 --> (T --> T)) $ h $(list_to_set T1 t)
berghofe@13876
   185
		end;
berghofe@13876
   186
		
berghofe@13876
   187
(* ------------------------------------------------------------------------- *)
berghofe@13876
   188
(* Returns both sides of an equvalence in the theorem*)
berghofe@13876
   189
(* ------------------------------------------------------------------------- *)
berghofe@13876
   190
fun qe_get_terms th = let val (_$(Const("op =",Type ("fun",[Type ("bool", []),_])) $ A $ B )) = prop_of th in (A,B) end;
berghofe@13876
   191
berghofe@13876
   192
(* ------------------------------------------------------------------------- *)
berghofe@13876
   193
(* Modified version of the simple version with minimal amount of checking and postprocessing*)
berghofe@13876
   194
(* ------------------------------------------------------------------------- *)
berghofe@13876
   195
berghofe@13876
   196
fun simple_prove_goal_cterm2 G tacs =
berghofe@13876
   197
  let
berghofe@13876
   198
    fun check None = error "prove_goal: tactic failed"
berghofe@13876
   199
      | check (Some (thm, _)) = (case nprems_of thm of
berghofe@13876
   200
            0 => thm
berghofe@13876
   201
          | i => !result_error_fn thm (string_of_int i ^ " unsolved goals!"))
berghofe@13876
   202
  in check (Seq.pull (EVERY tacs (trivial G))) end;
berghofe@13876
   203
berghofe@13876
   204
(*-------------------------------------------------------------*)
berghofe@13876
   205
(*-------------------------------------------------------------*)
berghofe@13876
   206
berghofe@13876
   207
fun cert_Trueprop sg t = cterm_of sg (HOLogic.mk_Trueprop t);
berghofe@13876
   208
berghofe@13876
   209
(* ------------------------------------------------------------------------- *)
berghofe@13876
   210
(*This function proove elementar will be used to generate proofs at runtime*)
berghofe@13876
   211
(*It is is based on the isabelle function proove_goalw_cterm and is thought to *)
berghofe@13876
   212
(*prove properties such as a dvd b (essentially) that are only to make at
berghofe@13876
   213
runtime.*)
berghofe@13876
   214
(* ------------------------------------------------------------------------- *)
berghofe@13876
   215
fun prove_elementar sg s fm2 = case s of 
berghofe@13876
   216
  (*"ss" like simplification with simpset*)
berghofe@13876
   217
  "ss" =>
berghofe@13876
   218
    let
chaieb@14758
   219
      val ss = presburger_ss addsimps
chaieb@14758
   220
        [zdvd_iff_zmod_eq_0,unity_coeff_ex]
berghofe@13876
   221
      val ct =  cert_Trueprop sg fm2
berghofe@13876
   222
    in 
chaieb@15107
   223
      simple_prove_goal_cterm2 ct [simp_tac ss 1, TRY (simple_arith_tac 1)] 
chaieb@15107
   224
berghofe@13876
   225
    end
berghofe@13876
   226
berghofe@13876
   227
  (*"bl" like blast tactic*)
berghofe@13876
   228
  (* Is only used in the harrisons like proof procedure *)
berghofe@13876
   229
  | "bl" =>
berghofe@13876
   230
     let val ct = cert_Trueprop sg fm2
berghofe@13876
   231
     in
berghofe@13876
   232
       simple_prove_goal_cterm2 ct [blast_tac HOL_cs 1]
berghofe@13876
   233
     end
berghofe@13876
   234
berghofe@13876
   235
  (*"ed" like Existence disjunctions ...*)
berghofe@13876
   236
  (* Is only used in the harrisons like proof procedure *)
berghofe@13876
   237
  | "ed" =>
berghofe@13876
   238
    let
berghofe@13876
   239
      val ex_disj_tacs =
berghofe@13876
   240
        let
berghofe@13876
   241
          val tac1 = EVERY[REPEAT(resolve_tac [disjI1,disjI2] 1), etac exI 1]
berghofe@13876
   242
          val tac2 = EVERY[etac exE 1, rtac exI 1,
berghofe@13876
   243
            REPEAT(resolve_tac [disjI1,disjI2] 1), assumption 1]
berghofe@13876
   244
	in [rtac iffI 1,
berghofe@13876
   245
          etac exE 1, REPEAT(EVERY[etac disjE 1, tac1]), tac1,
berghofe@13876
   246
          REPEAT(EVERY[etac disjE 1, tac2]), tac2]
berghofe@13876
   247
        end
berghofe@13876
   248
berghofe@13876
   249
      val ct = cert_Trueprop sg fm2
berghofe@13876
   250
    in 
berghofe@13876
   251
      simple_prove_goal_cterm2 ct ex_disj_tacs
berghofe@13876
   252
    end
berghofe@13876
   253
berghofe@13876
   254
  | "fa" =>
berghofe@13876
   255
    let val ct = cert_Trueprop sg fm2
chaieb@15107
   256
    in simple_prove_goal_cterm2 ct [simple_arith_tac 1]  
chaieb@15107
   257
berghofe@13876
   258
    end
berghofe@13876
   259
berghofe@13876
   260
  | "sa" =>
berghofe@13876
   261
    let
berghofe@13876
   262
      val ss = presburger_ss addsimps zadd_ac
berghofe@13876
   263
      val ct = cert_Trueprop sg fm2
berghofe@13876
   264
    in 
chaieb@15107
   265
      simple_prove_goal_cterm2 ct [simp_tac ss 1, TRY (simple_arith_tac 1)]  
chaieb@15107
   266
berghofe@13876
   267
    end
chaieb@14758
   268
  (* like Existance Conjunction *)
chaieb@14758
   269
  | "ec" =>
chaieb@14758
   270
    let
chaieb@14758
   271
      val ss = presburger_ss addsimps zadd_ac
chaieb@14758
   272
      val ct = cert_Trueprop sg fm2
chaieb@14758
   273
    in 
chaieb@14758
   274
      simple_prove_goal_cterm2 ct [simp_tac ss 1, TRY (blast_tac HOL_cs 1)]
chaieb@14758
   275
    end
berghofe@13876
   276
berghofe@13876
   277
  | "ac" =>
berghofe@13876
   278
    let
berghofe@13876
   279
      val ss = HOL_basic_ss addsimps zadd_ac
berghofe@13876
   280
      val ct = cert_Trueprop sg fm2
berghofe@13876
   281
    in 
berghofe@13876
   282
      simple_prove_goal_cterm2 ct [simp_tac ss 1]
berghofe@13876
   283
    end
berghofe@13876
   284
berghofe@13876
   285
  | "lf" =>
berghofe@13876
   286
    let
berghofe@13876
   287
      val ss = presburger_ss addsimps zadd_ac
berghofe@13876
   288
      val ct = cert_Trueprop sg fm2
berghofe@13876
   289
    in 
chaieb@15107
   290
      simple_prove_goal_cterm2 ct [simp_tac ss 1, TRY (simple_arith_tac 1)]  
chaieb@15107
   291
berghofe@13876
   292
    end;
berghofe@13876
   293
chaieb@14758
   294
(*=============================================================*)
chaieb@14758
   295
(*-------------------------------------------------------------*)
chaieb@14758
   296
(*              The new compact model                          *)
chaieb@14758
   297
(*-------------------------------------------------------------*)
chaieb@14758
   298
(*=============================================================*)
berghofe@13876
   299
chaieb@14758
   300
fun thm_of sg decomp t = 
chaieb@14758
   301
    let val (ts,recomb) = decomp t 
chaieb@14758
   302
    in recomb (map (thm_of sg decomp) ts) 
chaieb@14758
   303
    end;
chaieb@14758
   304
chaieb@14758
   305
(*==================================================*)
chaieb@14758
   306
(*     Compact Version for adjustcoeffeq            *)
chaieb@14758
   307
(*==================================================*)
chaieb@14758
   308
chaieb@14758
   309
fun decomp_adjustcoeffeq sg x l fm = case fm of
chaieb@14758
   310
    (Const("Not",_)$(Const("op <",_) $(Const("0",_)) $(rt as (Const ("op +", _)$(Const ("op *",_) $    c $ y ) $z )))) => 
chaieb@14758
   311
     let  
chaieb@14758
   312
        val m = l div (dest_numeral c) 
chaieb@14758
   313
        val n = if (x = y) then abs (m) else 1
chaieb@14758
   314
        val xtm = (HOLogic.mk_binop "op *" ((mk_numeral ((m div n)*l) ), x)) 
chaieb@14758
   315
        val rs = if (x = y) 
chaieb@14758
   316
                 then (HOLogic.mk_binrel "op <" (zero,linear_sub [] (mk_numeral n) (HOLogic.mk_binop "op +" ( xtm ,( linear_cmul n z) )))) 
chaieb@14758
   317
                 else HOLogic.mk_binrel "op <" (zero,linear_sub [] one rt )
chaieb@14758
   318
        val ck = cterm_of sg (mk_numeral n)
chaieb@14758
   319
        val cc = cterm_of sg c
chaieb@14758
   320
        val ct = cterm_of sg z
chaieb@14758
   321
        val cx = cterm_of sg y
chaieb@14758
   322
        val pre = prove_elementar sg "lf" 
chaieb@14758
   323
            (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),(mk_numeral n)))
chaieb@14758
   324
        val th1 = (pre RS (instantiate' [] [Some ck,Some cc, Some cx, Some ct] (ac_pi_eq)))
chaieb@14758
   325
        in ([], fn [] => [th1,(prove_elementar sg "sa" (HOLogic.mk_eq (snd (qe_get_terms th1) ,rs)))] MRS trans)
chaieb@14758
   326
        end
berghofe@13876
   327
chaieb@14758
   328
  |(Const(p,_) $a $( Const ("op +", _)$(Const ("op *",_) $ 
chaieb@14758
   329
      c $ y ) $t )) => 
chaieb@14758
   330
   if (is_arith_rel fm) andalso (x = y) 
chaieb@14758
   331
   then  
chaieb@14758
   332
        let val m = l div (dest_numeral c) 
chaieb@14758
   333
           val k = (if p = "op <" then abs(m) else m)  
chaieb@14758
   334
           val xtm = (HOLogic.mk_binop "op *" ((mk_numeral ((m div k)*l) ), x))
chaieb@14758
   335
           val rs = (HOLogic.mk_binrel p ((linear_cmul k a),(HOLogic.mk_binop "op +" ( xtm ,( linear_cmul k t) )))) 
chaieb@14758
   336
chaieb@14758
   337
           val ck = cterm_of sg (mk_numeral k)
chaieb@14758
   338
           val cc = cterm_of sg c
chaieb@14758
   339
           val ct = cterm_of sg t
chaieb@14758
   340
           val cx = cterm_of sg x
chaieb@14758
   341
           val ca = cterm_of sg a
chaieb@14758
   342
chaieb@14758
   343
	   in 
chaieb@14758
   344
	case p of
chaieb@14758
   345
	  "op <" => 
chaieb@14758
   346
	let val pre = prove_elementar sg "lf" 
chaieb@14758
   347
	    (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),(mk_numeral k)))
chaieb@14758
   348
            val th1 = (pre RS (instantiate' [] [Some ck,Some ca,Some cc, Some cx, Some ct] (ac_lt_eq)))
chaieb@14758
   349
	in ([], fn [] => [th1,(prove_elementar sg "lf" (HOLogic.mk_eq (snd (qe_get_terms th1) ,rs)))] MRS trans)
chaieb@14758
   350
         end
chaieb@14758
   351
chaieb@14758
   352
           |"op =" =>
chaieb@14758
   353
	     let val pre = prove_elementar sg "lf" 
berghofe@13876
   354
	    (HOLogic.Not $ (HOLogic.mk_binrel "op =" (Const("0",HOLogic.intT),(mk_numeral k))))
chaieb@14758
   355
	         val th1 = (pre RS(instantiate' [] [Some ck,Some ca,Some cc, Some cx, Some ct] (ac_eq_eq)))
chaieb@14758
   356
	     in ([], fn [] => [th1,(prove_elementar sg "lf" (HOLogic.mk_eq (snd (qe_get_terms th1) ,rs)))] MRS trans)
chaieb@14758
   357
             end
chaieb@14758
   358
chaieb@14758
   359
             |"Divides.op dvd" =>
chaieb@14758
   360
	       let val pre = prove_elementar sg "lf" 
berghofe@13876
   361
	   (HOLogic.Not $ (HOLogic.mk_binrel "op =" (Const("0",HOLogic.intT),(mk_numeral k))))
chaieb@14758
   362
                   val th1 = (pre RS (instantiate' [] [Some ck,Some ca,Some cc, Some cx, Some ct]) (ac_dvd_eq))
chaieb@14758
   363
               in ([], fn [] => [th1,(prove_elementar sg "lf" (HOLogic.mk_eq (snd (qe_get_terms th1) ,rs)))] MRS trans)
berghofe@13876
   364
                        
chaieb@14758
   365
               end
chaieb@14758
   366
              end
chaieb@14758
   367
  else ([], fn [] => instantiate' [Some cboolT] [Some (cterm_of sg fm)] refl)
chaieb@14758
   368
chaieb@14758
   369
 |( Const ("Not", _) $ p) => ([p], fn [th] => th RS qe_Not)
chaieb@14758
   370
  |( Const ("op &",_) $ p $ q) => ([p,q], fn [th1,th2] => [th1,th2] MRS qe_conjI)
chaieb@14758
   371
  |( Const ("op |",_) $ p $ q) =>([p,q], fn [th1,th2] => [th1,th2] MRS qe_disjI)
berghofe@13876
   372
chaieb@14758
   373
  |_ => ([], fn [] => instantiate' [Some cboolT] [Some (cterm_of sg fm)] refl);
berghofe@13876
   374
chaieb@14877
   375
fun proof_of_adjustcoeffeq sg x l = thm_of sg (decomp_adjustcoeffeq sg x l);
chaieb@14877
   376
chaieb@14877
   377
chaieb@14877
   378
chaieb@14758
   379
(*==================================================*)
chaieb@14758
   380
(*   Finding rho for modd_minusinfinity             *)
chaieb@14758
   381
(*==================================================*)
chaieb@14758
   382
fun rho_for_modd_minf x dlcm sg fm1 =
chaieb@14758
   383
let
berghofe@13876
   384
    (*Some certified Terms*)
berghofe@13876
   385
    
berghofe@13876
   386
   val ctrue = cterm_of sg HOLogic.true_const
berghofe@13876
   387
   val cfalse = cterm_of sg HOLogic.false_const
berghofe@13876
   388
   val fm = norm_zero_one fm1
berghofe@13876
   389
  in  case fm1 of 
berghofe@13876
   390
      (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   391
         if (x=y) andalso (c1= zero) andalso (c2= one) then (instantiate' [Some cboolT] [Some ctrue] (fm_modd_minf))
berghofe@13876
   392
           else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf))
berghofe@13876
   393
berghofe@13876
   394
      |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   395
  	   if (is_arith_rel fm) andalso (x=y) andalso (c1= zero) andalso (c2= one) 
berghofe@13876
   396
	   then (instantiate' [Some cboolT] [Some cfalse] (fm_modd_minf))
berghofe@13876
   397
	 	 else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf)) 
berghofe@13876
   398
berghofe@13876
   399
      |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   400
           if (y=x) andalso (c1 = zero) then 
berghofe@13876
   401
            if (pm1 = one) then (instantiate' [Some cboolT] [Some cfalse] (fm_modd_minf)) else
berghofe@13876
   402
	     (instantiate' [Some cboolT] [Some ctrue] (fm_modd_minf))
berghofe@13876
   403
	    else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf))
berghofe@13876
   404
  
berghofe@13876
   405
      |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   406
         if y=x then  let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   407
			  val fm2 = HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero)
berghofe@13876
   408
	 	      in(instantiate' [] [Some cz ] ((((prove_elementar sg "ss" fm2)) RS(((zdvd_iff_zmod_eq_0)RS sym) RS iffD1) ) RS (not_dvd_modd_minf)))
berghofe@13876
   409
		      end
berghofe@13876
   410
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf))
berghofe@13876
   411
      |(Const("Divides.op dvd",_)$ d $ (db as (Const ("op +",_) $ (Const ("op *",_) $
berghofe@13876
   412
      c $ y ) $ z))) => 
berghofe@13876
   413
         if y=x then  let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   414
			  val fm2 = HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero)
berghofe@13876
   415
	 	      in(instantiate' [] [Some cz ] ((((prove_elementar sg "ss" fm2)) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1) ) RS (dvd_modd_minf)))
berghofe@13876
   416
		      end
berghofe@13876
   417
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf))
berghofe@13876
   418
		
berghofe@13876
   419
    
berghofe@13876
   420
   |_ => instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_minf)
chaieb@14758
   421
   end;	 
chaieb@14758
   422
(*=========================================================================*)
chaieb@14758
   423
(*=========================================================================*)
chaieb@14758
   424
fun rho_for_eq_minf x dlcm  sg fm1 =  
chaieb@14758
   425
   let
berghofe@13876
   426
   val fm = norm_zero_one fm1
berghofe@13876
   427
    in  case fm1 of 
berghofe@13876
   428
      (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   429
         if  (x=y) andalso (c1=zero) andalso (c2=one) 
berghofe@13876
   430
	   then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (neq_eq_minf))
berghofe@13876
   431
           else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf))
berghofe@13876
   432
berghofe@13876
   433
      |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   434
  	   if (is_arith_rel fm) andalso (x=y) andalso ((c1=zero) orelse (c1 = norm_zero_one zero)) andalso ((c2=one) orelse (c1 = norm_zero_one one))
berghofe@13876
   435
	     then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (eq_eq_minf))
berghofe@13876
   436
	     else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf)) 
berghofe@13876
   437
berghofe@13876
   438
      |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   439
           if (y=x) andalso (c1 =zero) then 
berghofe@13876
   440
            if pm1 = one then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (le_eq_minf)) else
berghofe@13876
   441
	     (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (len_eq_minf))
berghofe@13876
   442
	    else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf))
berghofe@13876
   443
      |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   444
         if y=x then  let val cd = cterm_of sg (norm_zero_one d)
berghofe@13876
   445
	 		  val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   446
	 	      in(instantiate' [] [Some cd,  Some cz] (not_dvd_eq_minf)) 
berghofe@13876
   447
		      end
berghofe@13876
   448
berghofe@13876
   449
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf))
berghofe@13876
   450
		
berghofe@13876
   451
      |(Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   452
         if y=x then  let val cd = cterm_of sg (norm_zero_one d)
berghofe@13876
   453
	 		  val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   454
	 	      in(instantiate' [] [Some cd, Some cz ] (dvd_eq_minf))
berghofe@13876
   455
		      end
berghofe@13876
   456
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf))
berghofe@13876
   457
berghofe@13876
   458
      		
berghofe@13876
   459
    |_ => (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_minf))
berghofe@13876
   460
 end;
berghofe@13876
   461
chaieb@14758
   462
(*=====================================================*)
chaieb@14758
   463
(*=====================================================*)
chaieb@14758
   464
(*=========== minf proofs with the compact version==========*)
chaieb@14758
   465
fun decomp_minf_eq x dlcm sg t =  case t of
chaieb@14758
   466
   Const ("op &",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS eq_minf_conjI)
chaieb@14758
   467
   |Const ("op |",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS eq_minf_disjI)
chaieb@14758
   468
   |_ => ([],fn [] => rho_for_eq_minf x dlcm sg t);
berghofe@13876
   469
chaieb@14758
   470
fun decomp_minf_modd x dlcm sg t = case t of
chaieb@14758
   471
   Const ("op &",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS modd_minf_conjI)
chaieb@14758
   472
   |Const ("op |",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS modd_minf_disjI)
chaieb@14758
   473
   |_ => ([],fn [] => rho_for_modd_minf x dlcm sg t);
berghofe@13876
   474
chaieb@14758
   475
(* -------------------------------------------------------------*)
chaieb@14758
   476
(*                    Finding rho for pinf_modd                 *)
chaieb@14758
   477
(* -------------------------------------------------------------*)
chaieb@14758
   478
fun rho_for_modd_pinf x dlcm sg fm1 = 
chaieb@14758
   479
let
berghofe@13876
   480
    (*Some certified Terms*)
berghofe@13876
   481
    
berghofe@13876
   482
  val ctrue = cterm_of sg HOLogic.true_const
berghofe@13876
   483
  val cfalse = cterm_of sg HOLogic.false_const
berghofe@13876
   484
  val fm = norm_zero_one fm1
berghofe@13876
   485
 in  case fm1 of 
berghofe@13876
   486
      (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   487
         if ((x=y) andalso (c1= zero) andalso (c2= one))
berghofe@13876
   488
	 then (instantiate' [Some cboolT] [Some ctrue] (fm_modd_pinf))
berghofe@13876
   489
         else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf))
berghofe@13876
   490
berghofe@13876
   491
      |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   492
  	if ((is_arith_rel fm) andalso (x = y) andalso (c1 = zero)  andalso (c2 = one)) 
berghofe@13876
   493
	then (instantiate' [Some cboolT] [Some cfalse] (fm_modd_pinf))
berghofe@13876
   494
	else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf))
berghofe@13876
   495
berghofe@13876
   496
      |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   497
        if ((y=x) andalso (c1 = zero)) then 
berghofe@13876
   498
          if (pm1 = one) 
berghofe@13876
   499
	  then (instantiate' [Some cboolT] [Some ctrue] (fm_modd_pinf)) 
berghofe@13876
   500
	  else (instantiate' [Some cboolT] [Some cfalse] (fm_modd_pinf))
berghofe@13876
   501
	else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf))
berghofe@13876
   502
  
berghofe@13876
   503
      |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   504
         if y=x then  let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   505
			  val fm2 = HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero)
berghofe@13876
   506
	 	      in(instantiate' [] [Some cz ] ((((prove_elementar sg "ss" fm2)) RS(((zdvd_iff_zmod_eq_0)RS sym) RS iffD1) ) RS (not_dvd_modd_pinf)))
berghofe@13876
   507
		      end
berghofe@13876
   508
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf))
berghofe@13876
   509
      |(Const("Divides.op dvd",_)$ d $ (db as (Const ("op +",_) $ (Const ("op *",_) $
berghofe@13876
   510
      c $ y ) $ z))) => 
berghofe@13876
   511
         if y=x then  let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   512
			  val fm2 = HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero)
berghofe@13876
   513
	 	      in(instantiate' [] [Some cz ] ((((prove_elementar sg "ss" fm2)) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1) ) RS (dvd_modd_pinf)))
berghofe@13876
   514
		      end
berghofe@13876
   515
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf))
berghofe@13876
   516
		
berghofe@13876
   517
    
berghofe@13876
   518
   |_ => instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_modd_pinf)
chaieb@14758
   519
   end;	
chaieb@14758
   520
(* -------------------------------------------------------------*)
chaieb@14758
   521
(*                    Finding rho for pinf_eq                 *)
chaieb@14758
   522
(* -------------------------------------------------------------*)
chaieb@14758
   523
fun rho_for_eq_pinf x dlcm sg fm1 = 
chaieb@14758
   524
  let
berghofe@13876
   525
					val fm = norm_zero_one fm1
berghofe@13876
   526
    in  case fm1 of 
berghofe@13876
   527
      (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   528
         if  (x=y) andalso (c1=zero) andalso (c2=one) 
berghofe@13876
   529
	   then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (neq_eq_pinf))
berghofe@13876
   530
           else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf))
berghofe@13876
   531
berghofe@13876
   532
      |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   533
  	   if (is_arith_rel fm) andalso (x=y) andalso ((c1=zero) orelse (c1 = norm_zero_one zero)) andalso ((c2=one) orelse (c1 = norm_zero_one one))
berghofe@13876
   534
	     then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (eq_eq_pinf))
berghofe@13876
   535
	     else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf)) 
berghofe@13876
   536
berghofe@13876
   537
      |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   538
           if (y=x) andalso (c1 =zero) then 
berghofe@13876
   539
            if pm1 = one then (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (le_eq_pinf)) else
berghofe@13876
   540
	     (instantiate' [] [Some (cterm_of sg (norm_zero_one z))] (len_eq_pinf))
berghofe@13876
   541
	    else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf))
berghofe@13876
   542
      |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   543
         if y=x then  let val cd = cterm_of sg (norm_zero_one d)
berghofe@13876
   544
	 		  val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   545
	 	      in(instantiate' [] [Some cd,  Some cz] (not_dvd_eq_pinf)) 
berghofe@13876
   546
		      end
berghofe@13876
   547
berghofe@13876
   548
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf))
berghofe@13876
   549
		
berghofe@13876
   550
      |(Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   551
         if y=x then  let val cd = cterm_of sg (norm_zero_one d)
berghofe@13876
   552
	 		  val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   553
	 	      in(instantiate' [] [Some cd, Some cz ] (dvd_eq_pinf))
berghofe@13876
   554
		      end
berghofe@13876
   555
		else (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf))
berghofe@13876
   556
berghofe@13876
   557
      		
berghofe@13876
   558
    |_ => (instantiate' [Some cboolT] [Some (cterm_of sg fm)] (fm_eq_pinf))
berghofe@13876
   559
 end;
berghofe@13876
   560
berghofe@13876
   561
chaieb@14758
   562
chaieb@14758
   563
fun  minf_proof_of_c sg x dlcm t =
chaieb@14758
   564
  let val minf_eqth   = thm_of sg (decomp_minf_eq x dlcm sg) t
chaieb@14758
   565
      val minf_moddth = thm_of sg (decomp_minf_modd x dlcm sg) t
chaieb@14758
   566
  in (minf_eqth, minf_moddth)
chaieb@14758
   567
end;
berghofe@13876
   568
chaieb@14758
   569
(*=========== pinf proofs with the compact version==========*)
chaieb@14758
   570
fun decomp_pinf_eq x dlcm sg t = case t of
chaieb@14758
   571
   Const ("op &",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS eq_pinf_conjI)
chaieb@14758
   572
   |Const ("op |",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS eq_pinf_disjI)
chaieb@14758
   573
   |_ =>([],fn [] => rho_for_eq_pinf x dlcm sg t) ;
berghofe@13876
   574
chaieb@14758
   575
fun decomp_pinf_modd x dlcm sg t =  case t of
chaieb@14758
   576
   Const ("op &",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS modd_pinf_conjI)
chaieb@14758
   577
   |Const ("op |",_) $ p $q => ([p,q],fn [th1,th2] => [th1,th2] MRS modd_pinf_disjI)
chaieb@14758
   578
   |_ => ([],fn [] => rho_for_modd_pinf x dlcm sg t);
chaieb@14758
   579
chaieb@14758
   580
fun  pinf_proof_of_c sg x dlcm t =
chaieb@14758
   581
  let val pinf_eqth   = thm_of sg (decomp_pinf_eq x dlcm sg) t
chaieb@14758
   582
      val pinf_moddth = thm_of sg (decomp_pinf_modd x dlcm sg) t
chaieb@14758
   583
  in (pinf_eqth,pinf_moddth)
chaieb@14758
   584
end;
chaieb@14758
   585
berghofe@13876
   586
berghofe@13876
   587
(* ------------------------------------------------------------------------- *)
chaieb@14758
   588
(* Here we generate the theorem for the Bset Property in the simple direction*)
chaieb@14758
   589
(* It is just an instantiation*)
berghofe@13876
   590
(* ------------------------------------------------------------------------- *)
chaieb@14758
   591
(*
chaieb@14758
   592
fun bsetproof_of sg (x as Free(xn,xT)) fm bs dlcm   = 
chaieb@14758
   593
  let
chaieb@14758
   594
    val cp = cterm_of sg (absfree (xn,xT,(norm_zero_one fm)))
chaieb@14758
   595
    val cdlcm = cterm_of sg dlcm
chaieb@14758
   596
    val cB = cterm_of sg (list_to_set HOLogic.intT (map norm_zero_one bs))
chaieb@14758
   597
  in instantiate' [] [Some cdlcm,Some cB, Some cp] (bst_thm)
chaieb@14758
   598
end;
berghofe@13876
   599
chaieb@14758
   600
fun asetproof_of sg (x as Free(xn,xT)) fm ast dlcm = 
chaieb@14758
   601
  let
chaieb@14758
   602
    val cp = cterm_of sg (absfree (xn,xT,(norm_zero_one fm)))
chaieb@14758
   603
    val cdlcm = cterm_of sg dlcm
chaieb@14758
   604
    val cA = cterm_of sg (list_to_set HOLogic.intT (map norm_zero_one ast))
chaieb@14758
   605
  in instantiate' [] [Some cdlcm,Some cA, Some cp] (ast_thm)
berghofe@13876
   606
end;
chaieb@14758
   607
*)
berghofe@13876
   608
berghofe@13876
   609
(* For the generation of atomic Theorems*)
berghofe@13876
   610
(* Prove the premisses on runtime and then make RS*)
berghofe@13876
   611
(* ------------------------------------------------------------------------- *)
chaieb@14758
   612
chaieb@14758
   613
(*========= this is rho ============*)
berghofe@13876
   614
fun generate_atomic_not_bst_p sg (x as Free(xn,xT)) fm dlcm B at = 
berghofe@13876
   615
  let
berghofe@13876
   616
    val cdlcm = cterm_of sg dlcm
berghofe@13876
   617
    val cB = cterm_of sg B
berghofe@13876
   618
    val cfma = cterm_of sg (absfree (xn,xT,(norm_zero_one fm)))
berghofe@13876
   619
    val cat = cterm_of sg (norm_zero_one at)
berghofe@13876
   620
  in
berghofe@13876
   621
  case at of 
berghofe@13876
   622
   (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   623
      if  (x=y) andalso (c1=zero) andalso (c2=one) 
berghofe@13876
   624
	 then let val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ (norm_zero_one (linear_cmul ~1 z)) $ B)
berghofe@13876
   625
	          val th2 =  prove_elementar sg "ss" (HOLogic.mk_eq ((norm_zero_one (linear_cmul ~1 z)),Const("uminus",HOLogic.intT --> HOLogic.intT) $(norm_zero_one  z)))
berghofe@13876
   626
		  val th3 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   627
	 in  (instantiate' [] [Some cfma]([th3,th1,th2] MRS (not_bst_p_ne)))
berghofe@13876
   628
	 end
berghofe@13876
   629
         else (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   630
berghofe@13876
   631
   |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", T) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   632
     if (is_arith_rel at) andalso (x=y)
berghofe@13876
   633
	then let val bst_z = norm_zero_one (linear_neg (linear_add [] z (mk_numeral 1)))
berghofe@13876
   634
	         in let val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ bst_z $ B)
berghofe@13876
   635
	          val th2 =  prove_elementar sg "ss" (HOLogic.mk_eq (bst_z,Const("op -",T) $ (Const("uminus",HOLogic.intT --> HOLogic.intT) $(norm_zero_one z)) $ (Const("1",HOLogic.intT))))
berghofe@13876
   636
		  val th3 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   637
	 in  (instantiate' [] [Some cfma] ([th3,th1,th2] MRS (not_bst_p_eq)))
berghofe@13876
   638
	 end
berghofe@13876
   639
       end
berghofe@13876
   640
         else (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   641
berghofe@13876
   642
   |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   643
        if (y=x) andalso (c1 =zero) then 
berghofe@13876
   644
        if pm1 = one then 
berghofe@13876
   645
	  let val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ (norm_zero_one (linear_cmul ~1 z)) $ B)
berghofe@13876
   646
              val th2 =  prove_elementar sg "ss" (HOLogic.mk_eq ((norm_zero_one (linear_cmul ~1 z)),Const("uminus",HOLogic.intT --> HOLogic.intT) $(norm_zero_one z)))
berghofe@13876
   647
	  in  (instantiate' [] [Some cfma,  Some cdlcm]([th1,th2] MRS (not_bst_p_gt)))
berghofe@13876
   648
	    end
berghofe@13876
   649
	 else let val th1 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   650
	      in (instantiate' [] [Some cfma, Some cB,Some (cterm_of sg (norm_zero_one z))] (th1 RS (not_bst_p_lt)))
berghofe@13876
   651
	      end
berghofe@13876
   652
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   653
berghofe@13876
   654
   |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   655
      if y=x then  
berghofe@13876
   656
           let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   657
	       val th1 = (prove_elementar sg "ss"  (HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero))) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1)
berghofe@13876
   658
 	     in (instantiate' []  [Some cfma, Some cB,Some cz] (th1 RS (not_bst_p_ndvd)))
berghofe@13876
   659
	     end
berghofe@13876
   660
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   661
berghofe@13876
   662
   |(Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   663
       if y=x then  
berghofe@13876
   664
	 let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   665
	     val th1 = (prove_elementar sg "ss"  (HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero))) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1)
berghofe@13876
   666
 	    in (instantiate' []  [Some cfma,Some cB,Some cz] (th1 RS (not_bst_p_dvd)))
berghofe@13876
   667
	  end
berghofe@13876
   668
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   669
      		
berghofe@13876
   670
   |_ => (instantiate' [] [Some cfma,  Some cdlcm, Some cB,Some cat] (not_bst_p_fm))
berghofe@13876
   671
      		
berghofe@13876
   672
    end;
berghofe@13876
   673
    
chaieb@14758
   674
berghofe@13876
   675
(* ------------------------------------------------------------------------- *)    
berghofe@13876
   676
(* Main interpretation function for this backwards dirction*)
berghofe@13876
   677
(* if atomic do generate atomis formulae else Construct theorems and then make RS with the construction theorems*)
berghofe@13876
   678
(*Help Function*)
berghofe@13876
   679
(* ------------------------------------------------------------------------- *)
chaieb@14758
   680
chaieb@14758
   681
(*==================== Proof with the compact version   *)
berghofe@13876
   682
chaieb@14758
   683
fun decomp_nbstp sg x dlcm B fm t = case t of 
chaieb@14758
   684
   Const("op &",_) $ ls $ rs => ([ls,rs],fn [th1,th2] => [th1,th2] MRS not_bst_p_conjI )
chaieb@14758
   685
  |Const("op |",_) $ ls $ rs => ([ls,rs],fn [th1,th2] => [th1,th2] MRS not_bst_p_disjI)
chaieb@14758
   686
  |_ => ([], fn [] => generate_atomic_not_bst_p sg x fm dlcm B t);
chaieb@14758
   687
chaieb@14758
   688
fun not_bst_p_proof_of_c sg (x as Free(xn,xT)) fm dlcm B t =
chaieb@14758
   689
  let 
chaieb@14758
   690
       val th =  thm_of sg (decomp_nbstp sg x dlcm (list_to_set xT (map norm_zero_one B)) fm) t
berghofe@13876
   691
      val fma = absfree (xn,xT, norm_zero_one fm)
berghofe@13876
   692
  in let val th1 =  prove_elementar sg "ss"  (HOLogic.mk_eq (fma,fma))
berghofe@13876
   693
     in [th,th1] MRS (not_bst_p_Q_elim)
berghofe@13876
   694
     end
berghofe@13876
   695
  end;
berghofe@13876
   696
berghofe@13876
   697
berghofe@13876
   698
(* ------------------------------------------------------------------------- *)    
berghofe@13876
   699
(* Protokol interpretation function for the backwards direction for cooper's Theorem*)
berghofe@13876
   700
berghofe@13876
   701
(* For the generation of atomic Theorems*)
berghofe@13876
   702
(* Prove the premisses on runtime and then make RS*)
berghofe@13876
   703
(* ------------------------------------------------------------------------- *)
chaieb@14758
   704
(*========= this is rho ============*)
berghofe@13876
   705
fun generate_atomic_not_ast_p sg (x as Free(xn,xT)) fm dlcm A at = 
berghofe@13876
   706
  let
berghofe@13876
   707
    val cdlcm = cterm_of sg dlcm
berghofe@13876
   708
    val cA = cterm_of sg A
berghofe@13876
   709
    val cfma = cterm_of sg (absfree (xn,xT,(norm_zero_one fm)))
berghofe@13876
   710
    val cat = cterm_of sg (norm_zero_one at)
berghofe@13876
   711
  in
berghofe@13876
   712
  case at of 
berghofe@13876
   713
   (Const ("Not", _) $ (Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $ (Const ("op +", _) $(Const ("op *",_) $ c2 $ y) $z))) => 
berghofe@13876
   714
      if  (x=y) andalso (c1=zero) andalso (c2=one) 
berghofe@13876
   715
	 then let val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ (norm_zero_one (linear_cmul ~1 z)) $ A)
berghofe@13876
   716
	          val th2 =  prove_elementar sg "ss" (HOLogic.mk_eq ((norm_zero_one (linear_cmul ~1 z)),Const("uminus",HOLogic.intT --> HOLogic.intT) $(norm_zero_one  z)))
berghofe@13876
   717
		  val th3 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   718
	 in  (instantiate' [] [Some cfma]([th3,th1,th2] MRS (not_ast_p_ne)))
berghofe@13876
   719
	 end
berghofe@13876
   720
         else (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   721
berghofe@13876
   722
   |(Const("op =",Type ("fun",[Type ("IntDef.int", []),_])) $ c1 $(Const ("op +", T) $(Const ("op *",_) $ c2 $ y) $z)) =>
berghofe@13876
   723
     if (is_arith_rel at) andalso (x=y)
berghofe@13876
   724
	then let val ast_z = norm_zero_one (linear_sub [] one z )
berghofe@13876
   725
	         val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ ast_z $ A)
berghofe@13876
   726
	         val th2 =  prove_elementar sg "ss" (HOLogic.mk_eq (ast_z,Const("op +",T) $ (Const("uminus",HOLogic.intT --> HOLogic.intT) $(norm_zero_one z)) $ (Const("1",HOLogic.intT))))
berghofe@13876
   727
		 val th3 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   728
	 in  (instantiate' [] [Some cfma] ([th3,th1,th2] MRS (not_ast_p_eq)))
berghofe@13876
   729
       end
berghofe@13876
   730
         else (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   731
berghofe@13876
   732
   |(Const("op <",_) $ c1 $(Const ("op +", _) $(Const ("op *",_) $ pm1 $ y ) $ z )) =>
berghofe@13876
   733
        if (y=x) andalso (c1 =zero) then 
berghofe@13876
   734
        if pm1 = (mk_numeral ~1) then 
berghofe@13876
   735
	  let val th1 = prove_elementar sg "ss" (Const ("op :",HOLogic.intT --> (HOLogic.mk_setT HOLogic.intT) --> HOLogic.boolT) $ (norm_zero_one z) $ A)
berghofe@13876
   736
              val th2 =  prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (zero,dlcm))
berghofe@13876
   737
	  in  (instantiate' [] [Some cfma]([th2,th1] MRS (not_ast_p_lt)))
berghofe@13876
   738
	    end
berghofe@13876
   739
	 else let val th1 = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (Const("0",HOLogic.intT),dlcm))
berghofe@13876
   740
	      in (instantiate' [] [Some cfma, Some cA,Some (cterm_of sg (norm_zero_one z))] (th1 RS (not_ast_p_gt)))
berghofe@13876
   741
	      end
berghofe@13876
   742
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   743
berghofe@13876
   744
   |Const ("Not",_) $ (Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   745
      if y=x then  
berghofe@13876
   746
           let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   747
	       val th1 = (prove_elementar sg "ss"  (HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero))) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1)
berghofe@13876
   748
 	     in (instantiate' []  [Some cfma, Some cA,Some cz] (th1 RS (not_ast_p_ndvd)))
berghofe@13876
   749
	     end
berghofe@13876
   750
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   751
berghofe@13876
   752
   |(Const("Divides.op dvd",_)$ d $ (Const ("op +",_) $ (Const ("op *",_) $ c $ y ) $ z)) => 
berghofe@13876
   753
       if y=x then  
berghofe@13876
   754
	 let val cz = cterm_of sg (norm_zero_one z)
berghofe@13876
   755
	     val th1 = (prove_elementar sg "ss"  (HOLogic.mk_binrel "op =" (HOLogic.mk_binop "Divides.op mod" (dlcm,d),norm_zero_one zero))) RS (((zdvd_iff_zmod_eq_0)RS sym) RS iffD1)
berghofe@13876
   756
 	    in (instantiate' []  [Some cfma,Some cA,Some cz] (th1 RS (not_ast_p_dvd)))
berghofe@13876
   757
	  end
berghofe@13876
   758
      else (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   759
      		
berghofe@13876
   760
   |_ => (instantiate' [] [Some cfma,  Some cdlcm, Some cA,Some cat] (not_ast_p_fm))
berghofe@13876
   761
      		
berghofe@13876
   762
    end;
chaieb@14758
   763
chaieb@14758
   764
(* ------------------------------------------------------------------------ *)
berghofe@13876
   765
(* Main interpretation function for this backwards dirction*)
berghofe@13876
   766
(* if atomic do generate atomis formulae else Construct theorems and then make RS with the construction theorems*)
berghofe@13876
   767
(*Help Function*)
berghofe@13876
   768
(* ------------------------------------------------------------------------- *)
chaieb@14758
   769
chaieb@14758
   770
fun decomp_nastp sg x dlcm A fm t = case t of 
chaieb@14758
   771
   Const("op &",_) $ ls $ rs => ([ls,rs],fn [th1,th2] => [th1,th2] MRS not_ast_p_conjI )
chaieb@14758
   772
  |Const("op |",_) $ ls $ rs => ([ls,rs],fn [th1,th2] => [th1,th2] MRS not_ast_p_disjI)
chaieb@14758
   773
  |_ => ([], fn [] => generate_atomic_not_ast_p sg x fm dlcm A t);
berghofe@13876
   774
chaieb@14758
   775
fun not_ast_p_proof_of_c sg (x as Free(xn,xT)) fm dlcm A t =
chaieb@14758
   776
  let 
chaieb@14758
   777
       val th =  thm_of sg (decomp_nastp sg x dlcm (list_to_set xT (map norm_zero_one A)) fm) t
berghofe@13876
   778
      val fma = absfree (xn,xT, norm_zero_one fm)
chaieb@14758
   779
  in let val th1 =  prove_elementar sg "ss"  (HOLogic.mk_eq (fma,fma))
chaieb@14758
   780
     in [th,th1] MRS (not_ast_p_Q_elim)
chaieb@14758
   781
     end
chaieb@14758
   782
  end;
berghofe@13876
   783
berghofe@13876
   784
chaieb@14758
   785
(* -------------------------------*)
chaieb@14758
   786
(* Finding rho and beta for evalc *)
chaieb@14758
   787
(* -------------------------------*)
berghofe@13876
   788
chaieb@14758
   789
fun rho_for_evalc sg at = case at of  
chaieb@14758
   790
    (Const (p,_) $ s $ t) =>(  
chaieb@14758
   791
    case assoc (operations,p) of 
chaieb@14758
   792
        Some f => 
chaieb@14758
   793
           ((if (f ((dest_numeral s),(dest_numeral t))) 
chaieb@14758
   794
             then prove_elementar sg "ss" (HOLogic.mk_eq(at,HOLogic.true_const)) 
chaieb@14758
   795
             else prove_elementar sg "ss" (HOLogic.mk_eq(at, HOLogic.false_const)))  
chaieb@15122
   796
		   handle _ => instantiate' [Some cboolT] [Some (cterm_of sg at)] refl)
chaieb@15122
   797
        | _ => instantiate' [Some cboolT] [Some (cterm_of sg at)] refl )
chaieb@14758
   798
     |Const("Not",_)$(Const (p,_) $ s $ t) =>(  
chaieb@14758
   799
       case assoc (operations,p) of 
chaieb@14758
   800
         Some f => 
chaieb@14758
   801
           ((if (f ((dest_numeral s),(dest_numeral t))) 
chaieb@14758
   802
             then prove_elementar sg "ss" (HOLogic.mk_eq(at, HOLogic.false_const))  
chaieb@14758
   803
             else prove_elementar sg "ss" (HOLogic.mk_eq(at,HOLogic.true_const)))  
chaieb@14758
   804
		      handle _ => instantiate' [Some cboolT] [Some (cterm_of sg at)] refl) 
chaieb@14758
   805
         | _ => instantiate' [Some cboolT] [Some (cterm_of sg at)] refl ) 
chaieb@14758
   806
     | _ =>   instantiate' [Some cboolT] [Some (cterm_of sg at)] refl;
chaieb@14758
   807
chaieb@14758
   808
chaieb@14758
   809
(*=========================================================*)
chaieb@14758
   810
fun decomp_evalc sg t = case t of
chaieb@14758
   811
   (Const("op &",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_conjI)
chaieb@14758
   812
   |(Const("op |",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_disjI)
chaieb@14758
   813
   |(Const("op -->",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_impI)
chaieb@14758
   814
   |(Const("op =", Type ("fun",[Type ("bool", []),_]))$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_eqI)
chaieb@14758
   815
   |_ => ([], fn [] => rho_for_evalc sg t);
chaieb@14758
   816
chaieb@14758
   817
chaieb@14758
   818
fun proof_of_evalc sg fm = thm_of sg (decomp_evalc sg) fm;
chaieb@14758
   819
chaieb@14758
   820
(*==================================================*)
chaieb@14758
   821
(*     Proof of linform with the compact model      *)
chaieb@14758
   822
(*==================================================*)
chaieb@14758
   823
chaieb@14758
   824
chaieb@14758
   825
fun decomp_linform sg vars t = case t of
chaieb@14758
   826
   (Const("op &",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_conjI)
chaieb@14758
   827
   |(Const("op |",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_disjI)
chaieb@14758
   828
   |(Const("op -->",_)$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_impI)
chaieb@14758
   829
   |(Const("op =", Type ("fun",[Type ("bool", []),_]))$A$B) => ([A,B], fn [th1,th2] => [th1,th2] MRS qe_eqI)
chaieb@14758
   830
   |(Const("Not",_)$p) => ([p],fn [th] => th RS qe_Not)
chaieb@14758
   831
   |(Const("Divides.op dvd",_)$d$r) => ([], fn [] => (prove_elementar sg "lf" (HOLogic.mk_eq (r, lint vars r))) RS (instantiate' [] [None , None, Some (cterm_of sg d)](linearize_dvd)))
chaieb@14758
   832
   |_ => ([], fn [] => prove_elementar sg "lf" (HOLogic.mk_eq (t, linform vars t)));
chaieb@14758
   833
chaieb@14758
   834
fun proof_of_linform sg vars f = thm_of sg (decomp_linform sg vars) f;
berghofe@13876
   835
berghofe@13876
   836
(* ------------------------------------------------------------------------- *)
berghofe@13876
   837
(* Interpretaion of Protocols of the cooper procedure : minusinfinity version*)
berghofe@13876
   838
(* ------------------------------------------------------------------------- *)
chaieb@14758
   839
fun coopermi_proof_of sg (x as Free(xn,xT)) fm B dlcm =
berghofe@13876
   840
  (* Get the Bset thm*)
chaieb@14758
   841
  let val (minf_eqth, minf_moddth) = minf_proof_of_c sg x dlcm fm 
berghofe@13876
   842
      val dpos = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (zero,dlcm));
chaieb@14758
   843
      val nbstpthm = not_bst_p_proof_of_c sg x fm dlcm B fm
chaieb@14758
   844
  in (dpos,minf_eqth,nbstpthm,minf_moddth)
berghofe@13876
   845
end;
berghofe@13876
   846
berghofe@13876
   847
(* ------------------------------------------------------------------------- *)
berghofe@13876
   848
(* Interpretaion of Protocols of the cooper procedure : plusinfinity version *)
berghofe@13876
   849
(* ------------------------------------------------------------------------- *)
chaieb@14758
   850
fun cooperpi_proof_of sg (x as Free(xn,xT)) fm A dlcm =
chaieb@14758
   851
  let val (pinf_eqth,pinf_moddth) = pinf_proof_of_c sg x dlcm fm
berghofe@13876
   852
      val dpos = prove_elementar sg "ss" (HOLogic.mk_binrel "op <" (zero,dlcm));
chaieb@14758
   853
      val nastpthm = not_ast_p_proof_of_c sg x fm dlcm A fm
chaieb@14758
   854
  in (dpos,pinf_eqth,nastpthm,pinf_moddth)
berghofe@13876
   855
end;
berghofe@13876
   856
berghofe@13876
   857
(* ------------------------------------------------------------------------- *)
berghofe@13876
   858
(* Interpretaion of Protocols of the cooper procedure : full version*)
berghofe@13876
   859
(* ------------------------------------------------------------------------- *)
chaieb@14758
   860
fun cooper_thm sg s (x as Free(xn,xT)) cfm dlcm ast bst= case s of
chaieb@14758
   861
  "pi" => let val (dpsthm,pinf_eqth,nbpth,pinf_moddth) = cooperpi_proof_of sg x cfm ast dlcm 
chaieb@14758
   862
	      in [dpsthm,pinf_eqth,nbpth,pinf_moddth] MRS (cppi_eq)
berghofe@13876
   863
           end
chaieb@14758
   864
  |"mi" => let val (dpsthm,minf_eqth,nbpth,minf_moddth) = coopermi_proof_of sg x cfm bst dlcm
chaieb@14758
   865
	       in [dpsthm,minf_eqth,nbpth,minf_moddth] MRS (cpmi_eq)
berghofe@13876
   866
                end
berghofe@13876
   867
 |_ => error "parameter error";
berghofe@13876
   868
berghofe@13876
   869
(* ------------------------------------------------------------------------- *)
berghofe@13876
   870
(* This function should evoluate to the end prove Procedure for one quantifier elimination for Presburger arithmetic*)
berghofe@13876
   871
(* It shoud be plugged in the qfnp argument of the quantifier elimination proof function*)
berghofe@13876
   872
(* ------------------------------------------------------------------------- *)
berghofe@13876
   873
chaieb@14758
   874
fun cooper_prv sg (x as Free(xn,xT)) efm = let 
chaieb@14877
   875
   (* lfm_thm : efm = linearized form of efm*)
chaieb@14758
   876
   val lfm_thm = proof_of_linform sg [xn] efm
chaieb@14877
   877
   (*efm2 is the linearized form of efm *) 
chaieb@14758
   878
   val efm2 = snd(qe_get_terms lfm_thm)
chaieb@14877
   879
   (* l is the lcm of all coefficients of x *)
chaieb@14758
   880
   val l = formlcm x efm2
chaieb@14877
   881
   (*ac_thm: efm = efm2 with adjusted coefficients of x *)
chaieb@14877
   882
   val ac_thm = [lfm_thm , (proof_of_adjustcoeffeq sg x l efm2)] MRS trans
chaieb@14877
   883
   (* fm is efm2 with adjusted coefficients of x *)
berghofe@13876
   884
   val fm = snd (qe_get_terms ac_thm)
chaieb@14877
   885
  (* cfm is l dvd x & fm' where fm' is fm where l*x is replaced by x*)
berghofe@13876
   886
   val  cfm = unitycoeff x fm
chaieb@14877
   887
   (*afm is fm where c*x is replaced by 1*x or -1*x *)
berghofe@13876
   888
   val afm = adjustcoeff x l fm
chaieb@14877
   889
   (* P = %x.afm*)
berghofe@13876
   890
   val P = absfree(xn,xT,afm)
chaieb@14877
   891
   (* This simpset allows the elimination of the sets in bex {1..d} *)
berghofe@13876
   892
   val ss = presburger_ss addsimps
berghofe@13876
   893
     [simp_from_to] delsimps [P_eqtrue, P_eqfalse, bex_triv, insert_iff]
chaieb@14877
   894
   (* uth : EX x.P(l*x) = EX x. l dvd x & P x*)
berghofe@13876
   895
   val uth = instantiate' [] [Some (cterm_of sg P) , Some (cterm_of sg (mk_numeral l))] (unity_coeff_ex)
chaieb@14877
   896
   (* e_ac_thm : Ex x. efm = EX x. fm*)
berghofe@13876
   897
   val e_ac_thm = (forall_intr (cterm_of sg x) ac_thm) COMP (qe_exI)
chaieb@14877
   898
   (* A and B set of the formula*)
chaieb@14758
   899
   val A = aset x cfm
chaieb@14758
   900
   val B = bset x cfm
chaieb@14877
   901
   (* the divlcm (delta) of the formula*)
chaieb@14758
   902
   val dlcm = mk_numeral (divlcm x cfm)
chaieb@14877
   903
   (* Which set is smaller to generate the (hoepfully) shorter proof*)
chaieb@14758
   904
   val cms = if ((length A) < (length B )) then "pi" else "mi"
chaieb@14877
   905
   (* synthesize the proof of cooper's theorem*)
chaieb@14877
   906
    (* cp_thm: EX x. cfm = Q*)
chaieb@14758
   907
   val cp_thm = cooper_thm sg cms x cfm dlcm A B
chaieb@14877
   908
   (* Exxpand the right hand side to get rid of EX j : {1..d} to get a huge disjunction*)
chaieb@14877
   909
   (* exp_cp_thm: EX x.cfm = Q' , where Q' is a simplified version of Q*)
berghofe@13876
   910
   val exp_cp_thm = refl RS (simplify ss (cp_thm RSN (2,trans)))
chaieb@14877
   911
   (* lsuth = EX.P(l*x) ; rsuth = EX x. l dvd x & P x*)
berghofe@13876
   912
   val (lsuth,rsuth) = qe_get_terms (uth)
chaieb@14877
   913
   (* lseacth = EX x. efm; rseacth = EX x. fm*)
berghofe@13876
   914
   val (lseacth,rseacth) = qe_get_terms(e_ac_thm)
chaieb@14877
   915
   (* lscth = EX x. cfm; rscth = Q' *)
berghofe@13876
   916
   val (lscth,rscth) = qe_get_terms (exp_cp_thm)
chaieb@14877
   917
   (* u_c_thm: EX x. P(l*x) = Q'*)
berghofe@13876
   918
   val  u_c_thm = [([uth,prove_elementar sg "ss" (HOLogic.mk_eq (rsuth,lscth))] MRS trans),exp_cp_thm] MRS trans
chaieb@14877
   919
   (* result: EX x. efm = Q'*)
berghofe@13876
   920
 in  ([e_ac_thm,[(prove_elementar sg "ss" (HOLogic.mk_eq (rseacth,lsuth))),u_c_thm] MRS trans] MRS trans)
berghofe@13876
   921
   end
chaieb@14758
   922
|cooper_prv _ _ _ =  error "Parameters format";
chaieb@14758
   923
chaieb@15122
   924
(* ********************************** *)
chaieb@15122
   925
(* cooper_prv2 is just copy and paste *)
chaieb@15122
   926
(* And only generates proof with      *)
chaieb@15122
   927
(* bset and minusinfity               *)
chaieb@15122
   928
(* ********************************** *)
chaieb@15122
   929
chaieb@15122
   930
chaieb@15122
   931
chaieb@15122
   932
fun cooper_prv2 sg (x as Free(xn,xT)) efm = let 
chaieb@15122
   933
   (* lfm_thm : efm = linearized form of efm*)
chaieb@15122
   934
   val lfm_thm = proof_of_linform sg [xn] efm
chaieb@15122
   935
   (*efm2 is the linearized form of efm *) 
chaieb@15122
   936
   val efm2 = snd(qe_get_terms lfm_thm)
chaieb@15122
   937
   (* l is the lcm of all coefficients of x *)
chaieb@15122
   938
   val l = formlcm x efm2
chaieb@15122
   939
   (*ac_thm: efm = efm2 with adjusted coefficients of x *)
chaieb@15122
   940
   val ac_thm = [lfm_thm , (proof_of_adjustcoeffeq sg x l efm2)] MRS trans
chaieb@15122
   941
   (* fm is efm2 with adjusted coefficients of x *)
chaieb@15122
   942
   val fm = snd (qe_get_terms ac_thm)
chaieb@15122
   943
  (* cfm is l dvd x & fm' where fm' is fm where l*x is replaced by x*)
chaieb@15122
   944
   val  cfm = unitycoeff x fm
chaieb@15122
   945
   (*afm is fm where c*x is replaced by 1*x or -1*x *)
chaieb@15122
   946
   val afm = adjustcoeff x l fm
chaieb@15122
   947
   (* P = %x.afm*)
chaieb@15122
   948
   val P = absfree(xn,xT,afm)
chaieb@15122
   949
   (* This simpset allows the elimination of the sets in bex {1..d} *)
chaieb@15122
   950
   val ss = presburger_ss addsimps
chaieb@15122
   951
     [simp_from_to] delsimps [P_eqtrue, P_eqfalse, bex_triv, insert_iff]
chaieb@15122
   952
   (* uth : EX x.P(l*x) = EX x. l dvd x & P x*)
chaieb@15122
   953
   val uth = instantiate' [] [Some (cterm_of sg P) , Some (cterm_of sg (mk_numeral l))] (unity_coeff_ex)
chaieb@15122
   954
   (* e_ac_thm : Ex x. efm = EX x. fm*)
chaieb@15122
   955
   val e_ac_thm = (forall_intr (cterm_of sg x) ac_thm) COMP (qe_exI)
chaieb@15122
   956
   (* A and B set of the formula*)
chaieb@15122
   957
   val B = bset x cfm
chaieb@15122
   958
   val A = []
chaieb@15122
   959
   (* the divlcm (delta) of the formula*)
chaieb@15122
   960
   val dlcm = mk_numeral (divlcm x cfm)
chaieb@15122
   961
   (* Which set is smaller to generate the (hoepfully) shorter proof*)
chaieb@15122
   962
   val cms = "mi" 
chaieb@15122
   963
   (* synthesize the proof of cooper's theorem*)
chaieb@15122
   964
    (* cp_thm: EX x. cfm = Q*)
chaieb@15122
   965
   val cp_thm = cooper_thm sg cms x cfm dlcm A B
chaieb@15122
   966
   (* Exxpand the right hand side to get rid of EX j : {1..d} to get a huge disjunction*)
chaieb@15122
   967
   (* exp_cp_thm: EX x.cfm = Q' , where Q' is a simplified version of Q*)
chaieb@15122
   968
   val exp_cp_thm = refl RS (simplify ss (cp_thm RSN (2,trans)))
chaieb@15122
   969
   (* lsuth = EX.P(l*x) ; rsuth = EX x. l dvd x & P x*)
chaieb@15122
   970
   val (lsuth,rsuth) = qe_get_terms (uth)
chaieb@15122
   971
   (* lseacth = EX x. efm; rseacth = EX x. fm*)
chaieb@15122
   972
   val (lseacth,rseacth) = qe_get_terms(e_ac_thm)
chaieb@15122
   973
   (* lscth = EX x. cfm; rscth = Q' *)
chaieb@15122
   974
   val (lscth,rscth) = qe_get_terms (exp_cp_thm)
chaieb@15122
   975
   (* u_c_thm: EX x. P(l*x) = Q'*)
chaieb@15122
   976
   val  u_c_thm = [([uth,prove_elementar sg "ss" (HOLogic.mk_eq (rsuth,lscth))] MRS trans),exp_cp_thm] MRS trans
chaieb@15122
   977
   (* result: EX x. efm = Q'*)
chaieb@15122
   978
 in  ([e_ac_thm,[(prove_elementar sg "ss" (HOLogic.mk_eq (rseacth,lsuth))),u_c_thm] MRS trans] MRS trans)
chaieb@15122
   979
   end
chaieb@15122
   980
|cooper_prv2 _ _ _ =  error "Parameters format";
chaieb@15122
   981
berghofe@13876
   982
chaieb@15107
   983
(* **************************************** *)
chaieb@15107
   984
(*    An Other Version of cooper proving    *)
chaieb@15107
   985
(*     by giving a withness for EX          *)
chaieb@15107
   986
(* **************************************** *)
chaieb@15107
   987
chaieb@15107
   988
chaieb@15107
   989
chaieb@15107
   990
fun cooper_prv_w sg (x as Free(xn,xT)) efm = let 
chaieb@15107
   991
   (* lfm_thm : efm = linearized form of efm*)
chaieb@15107
   992
   val lfm_thm = proof_of_linform sg [xn] efm
chaieb@15107
   993
   (*efm2 is the linearized form of efm *) 
chaieb@15107
   994
   val efm2 = snd(qe_get_terms lfm_thm)
chaieb@15107
   995
   (* l is the lcm of all coefficients of x *)
chaieb@15107
   996
   val l = formlcm x efm2
chaieb@15107
   997
   (*ac_thm: efm = efm2 with adjusted coefficients of x *)
chaieb@15107
   998
   val ac_thm = [lfm_thm , (proof_of_adjustcoeffeq sg x l efm2)] MRS trans
chaieb@15107
   999
   (* fm is efm2 with adjusted coefficients of x *)
chaieb@15107
  1000
   val fm = snd (qe_get_terms ac_thm)
chaieb@15107
  1001
  (* cfm is l dvd x & fm' where fm' is fm where l*x is replaced by x*)
chaieb@15107
  1002
   val  cfm = unitycoeff x fm
chaieb@15107
  1003
   (*afm is fm where c*x is replaced by 1*x or -1*x *)
chaieb@15107
  1004
   val afm = adjustcoeff x l fm
chaieb@15107
  1005
   (* P = %x.afm*)
chaieb@15107
  1006
   val P = absfree(xn,xT,afm)
chaieb@15107
  1007
   (* This simpset allows the elimination of the sets in bex {1..d} *)
chaieb@15107
  1008
   val ss = presburger_ss addsimps
chaieb@15107
  1009
     [simp_from_to] delsimps [P_eqtrue, P_eqfalse, bex_triv, insert_iff]
chaieb@15107
  1010
   (* uth : EX x.P(l*x) = EX x. l dvd x & P x*)
chaieb@15107
  1011
   val uth = instantiate' [] [Some (cterm_of sg P) , Some (cterm_of sg (mk_numeral l))] (unity_coeff_ex)
chaieb@15107
  1012
   (* e_ac_thm : Ex x. efm = EX x. fm*)
chaieb@15107
  1013
   val e_ac_thm = (forall_intr (cterm_of sg x) ac_thm) COMP (qe_exI)
chaieb@15107
  1014
   (* lsuth = EX.P(l*x) ; rsuth = EX x. l dvd x & P x*)
chaieb@15107
  1015
   val (lsuth,rsuth) = qe_get_terms (uth)
chaieb@15107
  1016
   (* lseacth = EX x. efm; rseacth = EX x. fm*)
chaieb@15107
  1017
   val (lseacth,rseacth) = qe_get_terms(e_ac_thm)
chaieb@15107
  1018
chaieb@15107
  1019
   val (w,rs) = cooper_w [] cfm
chaieb@15107
  1020
   val exp_cp_thm =  case w of 
chaieb@15107
  1021
     (* FIXME - e_ac_thm just tipped to test syntactical correctness of the program!!!!*)
chaieb@15107
  1022
    Some n =>  e_ac_thm (* Prove cfm (n) and use exI and then Eq_TrueI*)
chaieb@15107
  1023
   |_ => let 
chaieb@15107
  1024
    (* A and B set of the formula*)
chaieb@15107
  1025
    val A = aset x cfm
chaieb@15107
  1026
    val B = bset x cfm
chaieb@15107
  1027
    (* the divlcm (delta) of the formula*)
chaieb@15107
  1028
    val dlcm = mk_numeral (divlcm x cfm)
chaieb@15107
  1029
    (* Which set is smaller to generate the (hoepfully) shorter proof*)
chaieb@15107
  1030
    val cms = if ((length A) < (length B )) then "pi" else "mi"
chaieb@15107
  1031
    (* synthesize the proof of cooper's theorem*)
chaieb@15107
  1032
     (* cp_thm: EX x. cfm = Q*)
chaieb@15107
  1033
    val cp_thm = cooper_thm sg cms x cfm dlcm A B
chaieb@15107
  1034
     (* Exxpand the right hand side to get rid of EX j : {1..d} to get a huge disjunction*)
chaieb@15107
  1035
    (* exp_cp_thm: EX x.cfm = Q' , where Q' is a simplified version of Q*)
chaieb@15107
  1036
    in refl RS (simplify ss (cp_thm RSN (2,trans)))
chaieb@15107
  1037
    end
chaieb@15107
  1038
   (* lscth = EX x. cfm; rscth = Q' *)
chaieb@15107
  1039
   val (lscth,rscth) = qe_get_terms (exp_cp_thm)
chaieb@15107
  1040
   (* u_c_thm: EX x. P(l*x) = Q'*)
chaieb@15107
  1041
   val  u_c_thm = [([uth,prove_elementar sg "ss" (HOLogic.mk_eq (rsuth,lscth))] MRS trans),exp_cp_thm] MRS trans
chaieb@15107
  1042
   (* result: EX x. efm = Q'*)
chaieb@15107
  1043
 in  ([e_ac_thm,[(prove_elementar sg "ss" (HOLogic.mk_eq (rseacth,lsuth))),u_c_thm] MRS trans] MRS trans)
chaieb@15107
  1044
   end
chaieb@15107
  1045
|cooper_prv_w _ _ _ =  error "Parameters format";
chaieb@15107
  1046
chaieb@15107
  1047
berghofe@13876
  1048
chaieb@14758
  1049
fun decomp_cnnf sg lfnp P = case P of 
chaieb@14758
  1050
     Const ("op &",_) $ p $q => ([p,q] , fn [th1,th2] => [th1,th2] MRS qe_conjI )
chaieb@14758
  1051
   |Const ("op |",_) $ p $q => ([p,q] , fn [th1,th2] => [th1,th2] MRS  qe_disjI)
chaieb@14758
  1052
   |Const ("Not",_) $ (Const("Not",_) $ p) => ([p], fn [th] => th RS nnf_nn)
chaieb@14758
  1053
   |Const("Not",_) $ (Const(opn,T) $ p $ q) => 
chaieb@14758
  1054
     if opn = "op |" 
chaieb@14758
  1055
      then case (p,q) of 
chaieb@14758
  1056
         (A as (Const ("op &",_) $ r $ s),B as (Const ("op &",_) $ r1 $ t)) =>
chaieb@14758
  1057
          if r1 = negate r 
chaieb@14758
  1058
          then  ([r,HOLogic.Not$s,r1,HOLogic.Not$t],fn [th1_1,th1_2,th2_1,th2_2] => [[th1_1,th1_1] MRS qe_conjI,[th2_1,th2_2] MRS qe_conjI] MRS nnf_sdj)
berghofe@13876
  1059
chaieb@14758
  1060
          else ([HOLogic.Not $ p,HOLogic.Not $ q ], fn [th1,th2] => [th1,th2] MRS nnf_ndj)
chaieb@14758
  1061
        |(_,_) => ([HOLogic.Not $ p,HOLogic.Not $ q ], fn [th1,th2] => [th1,th2] MRS nnf_ndj)
chaieb@14758
  1062
      else (
chaieb@14758
  1063
         case (opn,T) of 
chaieb@14758
  1064
           ("op &",_) => ([HOLogic.Not $ p,HOLogic.Not $ q ], fn [th1,th2] =>[th1,th2] MRS nnf_ncj )
chaieb@14758
  1065
           |("op -->",_) => ([p,HOLogic.Not $ q ], fn [th1,th2] =>[th1,th2] MRS nnf_nim )
chaieb@14758
  1066
           |("op =",Type ("fun",[Type ("bool", []),_])) => 
chaieb@14758
  1067
           ([HOLogic.conj $ p $ (HOLogic.Not $ q),HOLogic.conj $ (HOLogic.Not $ p) $ q], fn [th1,th2] => [th1,th2] MRS nnf_neq)
chaieb@14758
  1068
            |(_,_) => ([], fn [] => lfnp P)
chaieb@14758
  1069
)
chaieb@14758
  1070
chaieb@14758
  1071
   |(Const ("op -->",_) $ p $ q) => ([HOLogic.Not$p,q], fn [th1,th2] => [th1,th2] MRS nnf_im)
chaieb@14758
  1072
chaieb@14758
  1073
   |(Const ("op =", Type ("fun",[Type ("bool", []),_])) $ p $ q) =>
chaieb@14758
  1074
     ([HOLogic.conj $ p $ q,HOLogic.conj $ (HOLogic.Not $ p) $ (HOLogic.Not $ q) ], fn [th1,th2] =>[th1,th2] MRS nnf_eq )
chaieb@14758
  1075
   |_ => ([], fn [] => lfnp P);
berghofe@13876
  1076
berghofe@13876
  1077
berghofe@13876
  1078
berghofe@13876
  1079
chaieb@14758
  1080
fun proof_of_cnnf sg p lfnp = 
chaieb@14758
  1081
 let val th1 = thm_of sg (decomp_cnnf sg lfnp) p
chaieb@14758
  1082
     val rs = snd(qe_get_terms th1)
chaieb@14758
  1083
     val th2 = prove_elementar sg "ss" (HOLogic.mk_eq(rs,simpl rs))
chaieb@14758
  1084
  in [th1,th2] MRS trans
chaieb@14758
  1085
  end;
berghofe@13876
  1086
berghofe@13876
  1087
end;
chaieb@14920
  1088