# File reflected_presburger.ML

    (* $Id: reflected_presburger.ML,v 1.4 2005/09/15 18:38:47 chaieb Exp $ *)

        (* Caution: This file should not be modified. *)
        (* It is autmatically generated from HOL/ex/Reflected_Presburger.thy *)
    fun nat (i:IntInf.int) = if i < 0 then 0 else i : IntInf.int;
    structure Generated =
    struct

    datatype intterm = Cst of IntInf.int | Var of IntInf.int | Neg of intterm
      | Add of intterm * intterm | Sub of intterm * intterm
      | Mult of intterm * intterm;

    datatype QF = Lt of intterm * intterm | Gt of intterm * intterm
      | Le of intterm * intterm | Ge of intterm * intterm | Eq of intterm * intterm
      | Divides of intterm * intterm | T | F | NOT of QF | And of QF * QF
      | Or of QF * QF | Imp of QF * QF | Equ of QF * QF | QAll of QF | QEx of QF;

    datatype 'a option = None | Some of 'a;

    fun lift_un c None = None
      | lift_un c (Some p) = Some (c p);

    fun lift_bin (c, (Some a, Some b)) = Some (c a b)
      | lift_bin (c, (None, y)) = None
      | lift_bin (c, (Some y, None)) = None;

    fun lift_qe qe None = None
      | lift_qe qe (Some p) = qe p;

    fun qelim (qe, QAll p) = lift_un NOT (lift_qe qe (lift_un NOT (qelim (qe, p))))
      | qelim (qe, QEx p) = lift_qe qe (qelim (qe, p))
      | qelim (qe, And (p, q)) =
        lift_bin ((fn x => fn xa => And (x, xa)), (qelim (qe, p), qelim (qe, q)))
      | qelim (qe, Or (p, q)) =
        lift_bin ((fn x => fn xa => Or (x, xa)), (qelim (qe, p), qelim (qe, q)))
      | qelim (qe, Imp (p, q)) =
        lift_bin ((fn x => fn xa => Imp (x, xa)), (qelim (qe, p), qelim (qe, q)))
      | qelim (qe, Equ (p, q)) =
        lift_bin ((fn x => fn xa => Equ (x, xa)), (qelim (qe, p), qelim (qe, q)))
      | qelim (qe, NOT p) = lift_un NOT (qelim (qe, p))
      | qelim (qe, Lt (w, x)) = Some (Lt (w, x))
      | qelim (qe, Gt (y, z)) = Some (Gt (y, z))
      | qelim (qe, Le (aa, ab)) = Some (Le (aa, ab))
      | qelim (qe, Ge (ac, ad)) = Some (Ge (ac, ad))
      | qelim (qe, Eq (ae, af)) = Some (Eq (ae, af))
      | qelim (qe, Divides (ag, ah)) = Some (Divides (ag, ah))
      | qelim (qe, T) = Some T
      | qelim (qe, F) = Some F;

    fun lin_mul (c, Cst i) = Cst (c * i)
      | lin_mul (c, Add (Mult (Cst c', Var n), r)) =
        (if (c = 0) then Cst 0
          else Add (Mult (Cst (c * c'), Var n), lin_mul (c, r)));

    fun op_60_def0 m n = IntInf.< (m,n);

    fun op_60_61_def0 m n = not (op_60_def0 n m);

    fun lin_add (Add (Mult (Cst c1, Var n1), r1), Add (Mult (Cst c2, Var n2), r2)) =
        (if (n1 = n2)
          then let val c = Cst (c1 + c2)
               in (if ((c1 + c2) = 0) then lin_add (r1, r2)
                    else Add (Mult (c, Var n1), lin_add (r1, r2)))
               end
          else (if op_60_61_def0 n1 n2
                 then Add (Mult (Cst c1, Var n1),
                            lin_add (r1, Add (Mult (Cst c2, Var n2), r2)))
                 else Add (Mult (Cst c2, Var n2),
                            lin_add (Add (Mult (Cst c1, Var n1), r1), r2))))
      | lin_add (Add (Mult (Cst c1, Var n1), r1), Cst b) =
        Add (Mult (Cst c1, Var n1), lin_add (r1, Cst b))
      | lin_add (Cst x, Add (Mult (Cst c2, Var n2), r2)) =
        Add (Mult (Cst c2, Var n2), lin_add (Cst x, r2))
      | lin_add (Cst b1, Cst b2) = Cst (b1 + b2);

    fun lin_neg i = lin_mul (~1, i);

    fun linearize (Cst b) = Some (Cst b)
      | linearize (Var n) = Some (Add (Mult (Cst 1, Var n), Cst 0))
      | linearize (Neg i) = lift_un lin_neg (linearize i)
      | linearize (Add (i, j)) =
        lift_bin ((fn x => fn y => lin_add (x, y)), (linearize i, linearize j))
      | linearize (Sub (i, j)) =
        lift_bin
          ((fn x => fn y => lin_add (x, lin_neg y)), (linearize i, linearize j))
      | linearize (Mult (i, j)) =
        (case linearize i of None => None
          | Some x =>
              (case x of
                Cst xa =>
                  (case linearize j of None => None
                    | Some x => Some (lin_mul (xa, x)))
                | Var xa =>
                    (case linearize j of None => None
                      | Some xa =>
                          (case xa of Cst xa => Some (lin_mul (xa, x))
                            | Var xa => None | Neg xa => None | Add (xa, xb) => None
                            | Sub (xa, xb) => None | Mult (xa, xb) => None))
                | Neg xa =>
                    (case linearize j of None => None
                      | Some xa =>
                          (case xa of Cst xa => Some (lin_mul (xa, x))
                            | Var xa => None | Neg xa => None | Add (xa, xb) => None
                            | Sub (xa, xb) => None | Mult (xa, xb) => None))
                | Add (xa, xb) =>
                    (case linearize j of None => None
                      | Some xa =>
                          (case xa of Cst xa => Some (lin_mul (xa, x))
                            | Var xa => None | Neg xa => None | Add (xa, xb) => None
                            | Sub (xa, xb) => None | Mult (xa, xb) => None))
                | Sub (xa, xb) =>
                    (case linearize j of None => None
                      | Some xa =>
                          (case xa of Cst xa => Some (lin_mul (xa, x))
                            | Var xa => None | Neg xa => None | Add (xa, xb) => None
                            | Sub (xa, xb) => None | Mult (xa, xb) => None))
                | Mult (xa, xb) =>
                    (case linearize j of None => None
                      | Some xa =>
                          (case xa of Cst xa => Some (lin_mul (xa, x))
                            | Var xa => None | Neg xa => None | Add (xa, xb) => None
                            | Sub (xa, xb) => None | Mult (xa, xb) => None))));

    fun linform (Le (it1, it2)) =
        lift_bin
          ((fn x => fn y => Le (lin_add (x, lin_neg y), Cst 0)),
            (linearize it1, linearize it2))
      | linform (Eq (it1, it2)) =
        lift_bin
          ((fn x => fn y => Eq (lin_add (x, lin_neg y), Cst 0)),
            (linearize it1, linearize it2))
      | linform (Divides (d, t)) =
        (case linearize d of None => None
          | Some x =>
              (case x of
                Cst xa =>
                  (if (xa = 0) then None
                    else (case linearize t of None => None
                           | Some xa => Some (Divides (x, xa))))
                | Var xa => None | Neg xa => None | Add (xa, xb) => None
                | Sub (xa, xb) => None | Mult (xa, xb) => None))
      | linform T = Some T
      | linform F = Some F
      | linform (NOT p) = lift_un NOT (linform p)
      | linform (And (p, q)) =
        lift_bin ((fn f => fn g => And (f, g)), (linform p, linform q))
      | linform (Or (p, q)) =
        lift_bin ((fn f => fn g => Or (f, g)), (linform p, linform q));

    fun nnf (Lt (it1, it2)) = Le (Sub (it1, it2), Cst (~ 1))
      | nnf (Gt (it1, it2)) = Le (Sub (it2, it1), Cst (~ 1))
      | nnf (Le (it1, it2)) = Le (it1, it2)
      | nnf (Ge (it1, it2)) = Le (it2, it1)
      | nnf (Eq (it1, it2)) = Eq (it2, it1)
      | nnf (Divides (d, t)) = Divides (d, t)
      | nnf T = T
      | nnf F = F
      | nnf (And (p, q)) = And (nnf p, nnf q)
      | nnf (Or (p, q)) = Or (nnf p, nnf q)
      | nnf (Imp (p, q)) = Or (nnf (NOT p), nnf q)
      | nnf (Equ (p, q)) = Or (And (nnf p, nnf q), And (nnf (NOT p), nnf (NOT q)))
      | nnf (NOT (Lt (it1, it2))) = Le (it2, it1)
      | nnf (NOT (Gt (it1, it2))) = Le (it1, it2)
      | nnf (NOT (Le (it1, it2))) = Le (Sub (it2, it1), Cst (~ 1))
      | nnf (NOT (Ge (it1, it2))) = Le (Sub (it1, it2), Cst (~ 1))
      | nnf (NOT (Eq (it1, it2))) = NOT (Eq (it1, it2))
      | nnf (NOT (Divides (d, t))) = NOT (Divides (d, t))
      | nnf (NOT T) = F
      | nnf (NOT F) = T
      | nnf (NOT (NOT p)) = nnf p
      | nnf (NOT (And (p, q))) = Or (nnf (NOT p), nnf (NOT q))
      | nnf (NOT (Or (p, q))) = And (nnf (NOT p), nnf (NOT q))
      | nnf (NOT (Imp (p, q))) = And (nnf p, nnf (NOT q))
      | nnf (NOT (Equ (p, q))) =
        Or (And (nnf p, nnf (NOT q)), And (nnf (NOT p), nnf q));

    fun op_45_def2 z w =  IntInf.+ (z,~ w);

    fun op_45_def0 m n = nat (op_45_def2 (m) (n));

    val id_1_def0 : IntInf.int = (0 + 1);

    fun decrvarsI (Cst i) = Cst i
      | decrvarsI (Var n) = Var (op_45_def0 n id_1_def0)
      | decrvarsI (Neg a) = Neg (decrvarsI a)
      | decrvarsI (Add (a, b)) = Add (decrvarsI a, decrvarsI b)
      | decrvarsI (Sub (a, b)) = Sub (decrvarsI a, decrvarsI b)
      | decrvarsI (Mult (a, b)) = Mult (decrvarsI a, decrvarsI b);

    fun decrvars (Lt (a, b)) = Lt (decrvarsI a, decrvarsI b)
      | decrvars (Gt (a, b)) = Gt (decrvarsI a, decrvarsI b)
      | decrvars (Le (a, b)) = Le (decrvarsI a, decrvarsI b)
      | decrvars (Ge (a, b)) = Ge (decrvarsI a, decrvarsI b)
      | decrvars (Eq (a, b)) = Eq (decrvarsI a, decrvarsI b)
      | decrvars (Divides (a, b)) = Divides (decrvarsI a, decrvarsI b)
      | decrvars T = T
      | decrvars F = F
      | decrvars (NOT p) = NOT (decrvars p)
      | decrvars (And (p, q)) = And (decrvars p, decrvars q)
      | decrvars (Or (p, q)) = Or (decrvars p, decrvars q)
      | decrvars (Imp (p, q)) = Imp (decrvars p, decrvars q)
      | decrvars (Equ (p, q)) = Equ (decrvars p, decrvars q);

    fun op_64 [] ys = ys
      | op_64 (x :: xs) ys = (x :: op_64 xs ys);

    fun map f [] = []
      | map f (x :: xs) = (f x :: map f xs);

    fun iupto (i:IntInf.int, j:IntInf.int) = (if (j < i) then [] else (i :: iupto ((i + 1), j)));

    fun all_sums (j:IntInf.int, []) = []
      | all_sums (j, (i :: is)) =
        op_64 (map (fn x => lin_add (i, Cst x)) (iupto (1, j))) (all_sums (j, is));

    fun split x = (fn p => x (fst p) (snd p));

    fun negateSnd x = split (fn q => fn r => (q, IntInf.~ r)) x;

    fun adjust b =
      (fn (q:IntInf.int, r:IntInf.int) =>
        (if (0 <= op_45_def2 r b) then ((((2:IntInf.int) * q) + (1:IntInf.int)), op_45_def2 r b)
          else (((2:IntInf.int) * q), r)));

    fun negDivAlg (a:IntInf.int, b:IntInf.int) =
        (if ((0 <= (a + b)) orelse (b <= 0)) then (~1, (a + b))
          else adjust b (negDivAlg (a, (2 * b))));

    fun posDivAlg (a:IntInf.int, b:IntInf.int) =
        (if ((a < b) orelse (b <= 0)) then (0, a)
          else adjust b (posDivAlg (a, (2 * b))));

    fun divAlg x =
      split (fn a:IntInf.int => fn b:IntInf.int =>
              (if (0 <= a)
                then (if (0 <= b) then posDivAlg (a, b)
                       else (if (a = 0) then (0, 0)
                              else negateSnd (negDivAlg (~ a, ~ b))))
                else (if (0 < b) then negDivAlg (a, b)
                       else negateSnd (posDivAlg (~ a, ~ b)))))
        x;

    fun op_mod_def1 a b = snd (divAlg (a, b));

    fun op_dvd m n = (op_mod_def1 n m = 0);

    fun psimpl (Le (l, r)) =
        (case lift_bin
                ((fn x => fn y => lin_add (x, lin_neg y)),
                  (linearize l, linearize r)) of
          None => Le (l, r)
          | Some x =>
              (case x of Cst xa => (if (xa <= 0) then T else F)
                | Var xa => Le (x, Cst 0) | Neg xa => Le (x, Cst 0)
                | Add (xa, xb) => Le (x, Cst 0) | Sub (xa, xb) => Le (x, Cst 0)
                | Mult (xa, xb) => Le (x, Cst 0)))
      | psimpl (Eq (l, r)) =
        (case lift_bin
                ((fn x => fn y => lin_add (x, lin_neg y)),
                  (linearize l, linearize r)) of
          None => Eq (l, r)
          | Some x =>
              (case x of Cst xa => (if (xa = 0) then T else F)
                | Var xa => Eq (x, Cst 0) | Neg xa => Eq (x, Cst 0)
                | Add (xa, xb) => Eq (x, Cst 0) | Sub (xa, xb) => Eq (x, Cst 0)
                | Mult (xa, xb) => Eq (x, Cst 0)))
      | psimpl (Divides (Cst d, t)) =
        (case linearize t of None => Divides (Cst d, t)
          | Some x =>
              (case x of Cst xa => (if op_dvd d xa then T else F)
                | Var xa => Divides (Cst d, x) | Neg xa => Divides (Cst d, x)
                | Add (xa, xb) => Divides (Cst d, x)
                | Sub (xa, xb) => Divides (Cst d, x)
                | Mult (xa, xb) => Divides (Cst d, x)))
      | psimpl (Equ (p, q)) =
        let val p' = psimpl p; val q' = psimpl q
        in (case p' of
             Lt (x, xa) =>
               (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                 | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                 | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                 | T => p' | F => NOT p' | NOT x => Equ (p', q')
                 | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                 | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                 | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Gt (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Le (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Ge (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Eq (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Divides (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | T => q'
             | F => (case q' of Lt (x, xa) => NOT q' | Gt (x, xa) => NOT q'
                      | Le (x, xa) => NOT q' | Ge (x, xa) => NOT q'
                      | Eq (x, xa) => NOT q' | Divides (x, xa) => NOT q' | T => F
                      | F => T | NOT x => x | And (x, xa) => NOT q'
                      | Or (x, xa) => NOT q' | Imp (x, xa) => NOT q'
                      | Equ (x, xa) => NOT q' | QAll x => NOT q' | QEx x => NOT q')
             | NOT x =>
                 (case q' of Lt (xa, xb) => Equ (p', q')
                   | Gt (xa, xb) => Equ (p', q') | Le (xa, xb) => Equ (p', q')
                   | Ge (xa, xb) => Equ (p', q') | Eq (xa, xb) => Equ (p', q')
                   | Divides (xa, xb) => Equ (p', q') | T => p' | F => x
                   | NOT xa => Equ (x, xa) | And (xa, xb) => Equ (p', q')
                   | Or (xa, xb) => Equ (p', q') | Imp (xa, xb) => Equ (p', q')
                   | Equ (xa, xb) => Equ (p', q') | QAll xa => Equ (p', q')
                   | QEx xa => Equ (p', q'))
             | And (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Or (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Imp (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | Equ (x, xa) =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | QAll x =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q'))
             | QEx x =>
                 (case q' of Lt (x, xa) => Equ (p', q') | Gt (x, xa) => Equ (p', q')
                   | Le (x, xa) => Equ (p', q') | Ge (x, xa) => Equ (p', q')
                   | Eq (x, xa) => Equ (p', q') | Divides (x, xa) => Equ (p', q')
                   | T => p' | F => NOT p' | NOT x => Equ (p', q')
                   | And (x, xa) => Equ (p', q') | Or (x, xa) => Equ (p', q')
                   | Imp (x, xa) => Equ (p', q') | Equ (x, xa) => Equ (p', q')
                   | QAll x => Equ (p', q') | QEx x => Equ (p', q')))
        end
      | psimpl (NOT p) =
        let val p' = psimpl p
        in (case p' of Lt (x, xa) => NOT p' | Gt (x, xa) => NOT p'
             | Le (x, xa) => NOT p' | Ge (x, xa) => NOT p' | Eq (x, xa) => NOT p'
             | Divides (x, xa) => NOT p' | T => F | F => T | NOT x => x
             | And (x, xa) => NOT p' | Or (x, xa) => NOT p' | Imp (x, xa) => NOT p'
             | Equ (x, xa) => NOT p' | QAll x => NOT p' | QEx x => NOT p')
        end
      | psimpl (Lt (u, v)) = Lt (u, v)
      | psimpl (Gt (w, x)) = Gt (w, x)
      | psimpl (Ge (aa, ab)) = Ge (aa, ab)
      | psimpl (Divides (Var bp, af)) = Divides (Var bp, af)
      | psimpl (Divides (Neg bq, af)) = Divides (Neg bq, af)
      | psimpl (Divides (Add (br, bs), af)) = Divides (Add (br, bs), af)
      | psimpl (Divides (Sub (bt, bu), af)) = Divides (Sub (bt, bu), af)
      | psimpl (Divides (Mult (bv, bw), af)) = Divides (Mult (bv, bw), af)
      | psimpl T = T
      | psimpl F = F
      | psimpl (QAll ap) = QAll ap
      | psimpl (QEx aq) = QEx aq
      | psimpl (And (p, q)) =
        let val p' = psimpl p
        in (case p' of
             Lt (x, xa) =>
               let val q' = psimpl q
               in (case q' of Lt (x, xa) => And (p', q')
                    | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                    | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                    | Divides (x, xa) => And (p', q') | T => p' | F => F
                    | NOT x => And (p', q') | And (x, xa) => And (p', q')
                    | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                    | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                    | QEx x => And (p', q'))
               end
             | Gt (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Le (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Ge (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Eq (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Divides (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | T => psimpl q | F => F
             | NOT x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | And (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Or (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Imp (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | Equ (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | QAll x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end
             | QEx x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => And (p', q')
                      | Gt (x, xa) => And (p', q') | Le (x, xa) => And (p', q')
                      | Ge (x, xa) => And (p', q') | Eq (x, xa) => And (p', q')
                      | Divides (x, xa) => And (p', q') | T => p' | F => F
                      | NOT x => And (p', q') | And (x, xa) => And (p', q')
                      | Or (x, xa) => And (p', q') | Imp (x, xa) => And (p', q')
                      | Equ (x, xa) => And (p', q') | QAll x => And (p', q')
                      | QEx x => And (p', q'))
                 end)
        end
      | psimpl (Or (p, q)) =
        let val p' = psimpl p
        in (case p' of
             Lt (x, xa) =>
               let val q' = psimpl q
               in (case q' of Lt (x, xa) => Or (p', q') | Gt (x, xa) => Or (p', q')
                    | Le (x, xa) => Or (p', q') | Ge (x, xa) => Or (p', q')
                    | Eq (x, xa) => Or (p', q') | Divides (x, xa) => Or (p', q')
                    | T => T | F => p' | NOT x => Or (p', q')
                    | And (x, xa) => Or (p', q') | Or (x, xa) => Or (p', q')
                    | Imp (x, xa) => Or (p', q') | Equ (x, xa) => Or (p', q')
                    | QAll x => Or (p', q') | QEx x => Or (p', q'))
               end
             | Gt (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Le (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Ge (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Eq (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Divides (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | T => T | F => psimpl q
             | NOT x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | And (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Or (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Imp (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | Equ (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | QAll x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end
             | QEx x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Or (p', q')
                      | Gt (x, xa) => Or (p', q') | Le (x, xa) => Or (p', q')
                      | Ge (x, xa) => Or (p', q') | Eq (x, xa) => Or (p', q')
                      | Divides (x, xa) => Or (p', q') | T => T | F => p'
                      | NOT x => Or (p', q') | And (x, xa) => Or (p', q')
                      | Or (x, xa) => Or (p', q') | Imp (x, xa) => Or (p', q')
                      | Equ (x, xa) => Or (p', q') | QAll x => Or (p', q')
                      | QEx x => Or (p', q'))
                 end)
        end
      | psimpl (Imp (p, q)) =
        let val p' = psimpl p
        in (case p' of
             Lt (x, xa) =>
               let val q' = psimpl q
               in (case q' of Lt (x, xa) => Imp (p', q')
                    | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                    | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                    | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                    | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                    | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                    | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                    | QEx x => Imp (p', q'))
               end
             | Gt (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Le (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Ge (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Eq (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Divides (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | T => psimpl q | F => T
             | NOT x =>
                 let val q' = psimpl q
                 in (case q' of Lt (xa, xb) => Or (x, q')
                      | Gt (xa, xb) => Or (x, q') | Le (xa, xb) => Or (x, q')
                      | Ge (xa, xb) => Or (x, q') | Eq (xa, xb) => Or (x, q')
                      | Divides (xa, xb) => Or (x, q') | T => T | F => x
                      | NOT xa => Or (x, q') | And (xa, xb) => Or (x, q')
                      | Or (xa, xb) => Or (x, q') | Imp (xa, xb) => Or (x, q')
                      | Equ (xa, xb) => Or (x, q') | QAll xa => Or (x, q')
                      | QEx xa => Or (x, q'))
                 end
             | And (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Or (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Imp (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | Equ (x, xa) =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | QAll x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end
             | QEx x =>
                 let val q' = psimpl q
                 in (case q' of Lt (x, xa) => Imp (p', q')
                      | Gt (x, xa) => Imp (p', q') | Le (x, xa) => Imp (p', q')
                      | Ge (x, xa) => Imp (p', q') | Eq (x, xa) => Imp (p', q')
                      | Divides (x, xa) => Imp (p', q') | T => T | F => NOT p'
                      | NOT x => Imp (p', q') | And (x, xa) => Imp (p', q')
                      | Or (x, xa) => Imp (p', q') | Imp (x, xa) => Imp (p', q')
                      | Equ (x, xa) => Imp (p', q') | QAll x => Imp (p', q')
                      | QEx x => Imp (p', q'))
                 end)
        end;

    fun subst_it i (Cst b) = Cst b
      | subst_it i (Var n) = (if (n = 0) then i else Var n)
      | subst_it i (Neg it) = Neg (subst_it i it)
      | subst_it i (Add (it1, it2)) = Add (subst_it i it1, subst_it i it2)
      | subst_it i (Sub (it1, it2)) = Sub (subst_it i it1, subst_it i it2)
      | subst_it i (Mult (it1, it2)) = Mult (subst_it i it1, subst_it i it2);

    fun subst_p i (Le (it1, it2)) = Le (subst_it i it1, subst_it i it2)
      | subst_p i (Lt (it1, it2)) = Lt (subst_it i it1, subst_it i it2)
      | subst_p i (Ge (it1, it2)) = Ge (subst_it i it1, subst_it i it2)
      | subst_p i (Gt (it1, it2)) = Gt (subst_it i it1, subst_it i it2)
      | subst_p i (Eq (it1, it2)) = Eq (subst_it i it1, subst_it i it2)
      | subst_p i (Divides (d, t)) = Divides (subst_it i d, subst_it i t)
      | subst_p i T = T
      | subst_p i F = F
      | subst_p i (And (p, q)) = And (subst_p i p, subst_p i q)
      | subst_p i (Or (p, q)) = Or (subst_p i p, subst_p i q)
      | subst_p i (Imp (p, q)) = Imp (subst_p i p, subst_p i q)
      | subst_p i (Equ (p, q)) = Equ (subst_p i p, subst_p i q)
      | subst_p i (NOT p) = NOT (subst_p i p);

    fun explode_disj ([], p) = F
      | explode_disj ((i :: is), p) =
        let val pi = psimpl (subst_p i p)
        in (case pi of
             Lt (x, xa) =>
               let val r = explode_disj (is, p)
               in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                    | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                    | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                    | T => T | F => pi | NOT x => Or (pi, r)
                    | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                    | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                    | QAll x => Or (pi, r) | QEx x => Or (pi, r))
               end
             | Gt (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Le (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Ge (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Eq (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Divides (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | T => T | F => explode_disj (is, p)
             | NOT x =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | And (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Or (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Imp (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | Equ (x, xa) =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | QAll x =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end
             | QEx x =>
                 let val r = explode_disj (is, p)
                 in (case r of Lt (x, xa) => Or (pi, r) | Gt (x, xa) => Or (pi, r)
                      | Le (x, xa) => Or (pi, r) | Ge (x, xa) => Or (pi, r)
                      | Eq (x, xa) => Or (pi, r) | Divides (x, xa) => Or (pi, r)
                      | T => T | F => pi | NOT x => Or (pi, r)
                      | And (x, xa) => Or (pi, r) | Or (x, xa) => Or (pi, r)
                      | Imp (x, xa) => Or (pi, r) | Equ (x, xa) => Or (pi, r)
                      | QAll x => Or (pi, r) | QEx x => Or (pi, r))
                 end)
        end;

    fun minusinf (And (p, q)) = And (minusinf p, minusinf q)
      | minusinf (Or (p, q)) = Or (minusinf p, minusinf q)
      | minusinf (Lt (u, v)) = Lt (u, v)
      | minusinf (Gt (w, x)) = Gt (w, x)
      | minusinf (Le (Cst bo, z)) = Le (Cst bo, z)
      | minusinf (Le (Var bp, z)) = Le (Var bp, z)
      | minusinf (Le (Neg bq, z)) = Le (Neg bq, z)
      | minusinf (Le (Add (Cst cg, bs), z)) = Le (Add (Cst cg, bs), z)
      | minusinf (Le (Add (Var ch, bs), z)) = Le (Add (Var ch, bs), z)
      | minusinf (Le (Add (Neg ci, bs), z)) = Le (Add (Neg ci, bs), z)
      | minusinf (Le (Add (Add (cj, ck), bs), z)) = Le (Add (Add (cj, ck), bs), z)
      | minusinf (Le (Add (Sub (cl, cm), bs), z)) = Le (Add (Sub (cl, cm), bs), z)
      | minusinf (Le (Add (Mult (Cst cy, Cst dq), bs), z)) =
        Le (Add (Mult (Cst cy, Cst dq), bs), z)
      | minusinf (Le (Add (Mult (Cst cy, Var ei), bs), z)) =
        (if (ei = 0) then (if (cy < 0) then F else T)
          else Le (Add (Mult (Cst cy, Var (op_45_def0 ei id_1_def0 + 1)), bs), z))
      | minusinf (Le (Add (Mult (Cst cy, Neg ds), bs), z)) =
        Le (Add (Mult (Cst cy, Neg ds), bs), z)
      | minusinf (Le (Add (Mult (Cst cy, Add (dt, du)), bs), z)) =
        Le (Add (Mult (Cst cy, Add (dt, du)), bs), z)
      | minusinf (Le (Add (Mult (Cst cy, Sub (dv, dw)), bs), z)) =
        Le (Add (Mult (Cst cy, Sub (dv, dw)), bs), z)
      | minusinf (Le (Add (Mult (Cst cy, Mult (dx, dy)), bs), z)) =
        Le (Add (Mult (Cst cy, Mult (dx, dy)), bs), z)
      | minusinf (Le (Add (Mult (Var cz, co), bs), z)) =
        Le (Add (Mult (Var cz, co), bs), z)
      | minusinf (Le (Add (Mult (Neg da, co), bs), z)) =
        Le (Add (Mult (Neg da, co), bs), z)
      | minusinf (Le (Add (Mult (Add (db, dc), co), bs), z)) =
        Le (Add (Mult (Add (db, dc), co), bs), z)
      | minusinf (Le (Add (Mult (Sub (dd, de), co), bs), z)) =
        Le (Add (Mult (Sub (dd, de), co), bs), z)
      | minusinf (Le (Add (Mult (Mult (df, dg), co), bs), z)) =
        Le (Add (Mult (Mult (df, dg), co), bs), z)
      | minusinf (Le (Sub (bt, bu), z)) = Le (Sub (bt, bu), z)
      | minusinf (Le (Mult (bv, bw), z)) = Le (Mult (bv, bw), z)
      | minusinf (Ge (aa, ab)) = Ge (aa, ab)
      | minusinf (Eq (Cst ek, ad)) = Eq (Cst ek, ad)
      | minusinf (Eq (Var el, ad)) = Eq (Var el, ad)
      | minusinf (Eq (Neg em, ad)) = Eq (Neg em, ad)
      | minusinf (Eq (Add (Cst fc, eo), ad)) = Eq (Add (Cst fc, eo), ad)
      | minusinf (Eq (Add (Var fd, eo), ad)) = Eq (Add (Var fd, eo), ad)
      | minusinf (Eq (Add (Neg fe, eo), ad)) = Eq (Add (Neg fe, eo), ad)
      | minusinf (Eq (Add (Add (ff, fg), eo), ad)) = Eq (Add (Add (ff, fg), eo), ad)
      | minusinf (Eq (Add (Sub (fh, fi), eo), ad)) = Eq (Add (Sub (fh, fi), eo), ad)
      | minusinf (Eq (Add (Mult (Cst fu, Cst gm), eo), ad)) =
        Eq (Add (Mult (Cst fu, Cst gm), eo), ad)
      | minusinf (Eq (Add (Mult (Cst fu, Var he), eo), ad)) =
        (if (he = 0) then F
          else Eq (Add (Mult (Cst fu, Var (op_45_def0 he id_1_def0 + 1)), eo), ad))
      | minusinf (Eq (Add (Mult (Cst fu, Neg go), eo), ad)) =
        Eq (Add (Mult (Cst fu, Neg go), eo), ad)
      | minusinf (Eq (Add (Mult (Cst fu, Add (gp, gq)), eo), ad)) =
        Eq (Add (Mult (Cst fu, Add (gp, gq)), eo), ad)
      | minusinf (Eq (Add (Mult (Cst fu, Sub (gr, gs)), eo), ad)) =
        Eq (Add (Mult (Cst fu, Sub (gr, gs)), eo), ad)
      | minusinf (Eq (Add (Mult (Cst fu, Mult (gt, gu)), eo), ad)) =
        Eq (Add (Mult (Cst fu, Mult (gt, gu)), eo), ad)
      | minusinf (Eq (Add (Mult (Var fv, fk), eo), ad)) =
        Eq (Add (Mult (Var fv, fk), eo), ad)
      | minusinf (Eq (Add (Mult (Neg fw, fk), eo), ad)) =
        Eq (Add (Mult (Neg fw, fk), eo), ad)
      | minusinf (Eq (Add (Mult (Add (fx, fy), fk), eo), ad)) =
        Eq (Add (Mult (Add (fx, fy), fk), eo), ad)
      | minusinf (Eq (Add (Mult (Sub (fz, ga), fk), eo), ad)) =
        Eq (Add (Mult (Sub (fz, ga), fk), eo), ad)
      | minusinf (Eq (Add (Mult (Mult (gb, gc), fk), eo), ad)) =
        Eq (Add (Mult (Mult (gb, gc), fk), eo), ad)
      | minusinf (Eq (Sub (ep, eq), ad)) = Eq (Sub (ep, eq), ad)
      | minusinf (Eq (Mult (er, es), ad)) = Eq (Mult (er, es), ad)
      | minusinf (Divides (ae, af)) = Divides (ae, af)
      | minusinf T = T
      | minusinf F = F
      | minusinf (NOT (Lt (hg, hh))) = NOT (Lt (hg, hh))
      | minusinf (NOT (Gt (hi, hj))) = NOT (Gt (hi, hj))
      | minusinf (NOT (Le (hk, hl))) = NOT (Le (hk, hl))
      | minusinf (NOT (Ge (hm, hn))) = NOT (Ge (hm, hn))
      | minusinf (NOT (Eq (Cst ja, hp))) = NOT (Eq (Cst ja, hp))
      | minusinf (NOT (Eq (Var jb, hp))) = NOT (Eq (Var jb, hp))
      | minusinf (NOT (Eq (Neg jc, hp))) = NOT (Eq (Neg jc, hp))
      | minusinf (NOT (Eq (Add (Cst js, je), hp))) = NOT (Eq (Add (Cst js, je), hp))
      | minusinf (NOT (Eq (Add (Var jt, je), hp))) = NOT (Eq (Add (Var jt, je), hp))
      | minusinf (NOT (Eq (Add (Neg ju, je), hp))) = NOT (Eq (Add (Neg ju, je), hp))
      | minusinf (NOT (Eq (Add (Add (jv, jw), je), hp))) =
        NOT (Eq (Add (Add (jv, jw), je), hp))
      | minusinf (NOT (Eq (Add (Sub (jx, jy), je), hp))) =
        NOT (Eq (Add (Sub (jx, jy), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Cst lc), je), hp))) =
        NOT (Eq (Add (Mult (Cst kk, Cst lc), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Var lu), je), hp))) =
        (if (lu = 0) then T
          else NOT (Eq (Add (Mult (Cst kk, Var (op_45_def0 lu id_1_def0 + 1)), je),
                         hp)))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Neg le), je), hp))) =
        NOT (Eq (Add (Mult (Cst kk, Neg le), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Add (lf, lg)), je), hp))) =
        NOT (Eq (Add (Mult (Cst kk, Add (lf, lg)), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Sub (lh, li)), je), hp))) =
        NOT (Eq (Add (Mult (Cst kk, Sub (lh, li)), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Cst kk, Mult (lj, lk)), je), hp))) =
        NOT (Eq (Add (Mult (Cst kk, Mult (lj, lk)), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Var kl, ka), je), hp))) =
        NOT (Eq (Add (Mult (Var kl, ka), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Neg km, ka), je), hp))) =
        NOT (Eq (Add (Mult (Neg km, ka), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Add (kn, ko), ka), je), hp))) =
        NOT (Eq (Add (Mult (Add (kn, ko), ka), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Sub (kp, kq), ka), je), hp))) =
        NOT (Eq (Add (Mult (Sub (kp, kq), ka), je), hp))
      | minusinf (NOT (Eq (Add (Mult (Mult (kr, ks), ka), je), hp))) =
        NOT (Eq (Add (Mult (Mult (kr, ks), ka), je), hp))
      | minusinf (NOT (Eq (Sub (jf, jg), hp))) = NOT (Eq (Sub (jf, jg), hp))
      | minusinf (NOT (Eq (Mult (jh, ji), hp))) = NOT (Eq (Mult (jh, ji), hp))
      | minusinf (NOT (Divides (hq, hr))) = NOT (Divides (hq, hr))
      | minusinf (NOT T) = NOT T
      | minusinf (NOT F) = NOT F
      | minusinf (NOT (NOT hs)) = NOT (NOT hs)
      | minusinf (NOT (And (ht, hu))) = NOT (And (ht, hu))
      | minusinf (NOT (Or (hv, hw))) = NOT (Or (hv, hw))
      | minusinf (NOT (Imp (hx, hy))) = NOT (Imp (hx, hy))
      | minusinf (NOT (Equ (hz, ia))) = NOT (Equ (hz, ia))
      | minusinf (NOT (QAll ib)) = NOT (QAll ib)
      | minusinf (NOT (QEx ic)) = NOT (QEx ic)
      | minusinf (Imp (al, am)) = Imp (al, am)
      | minusinf (Equ (an, ao)) = Equ (an, ao)
      | minusinf (QAll ap) = QAll ap
      | minusinf (QEx aq) = QEx aq;

    fun abs (i:IntInf.int) = (if (i < 0) then IntInf.~ i else i);

    fun op_div_def1 a b = fst (divAlg (a, b));

    fun op_mod_def0 m n = nat (op_mod_def1 (m) (n));

    fun ngcd (m:IntInf.int, n:IntInf.int) = (if (n = 0) then m else ngcd (n, op_mod_def0 m n));

    fun igcd x = split (fn a => fn b => (ngcd (nat (abs a), nat (abs b)))) x;

    fun ilcm (a:IntInf.int) (b:IntInf.int) = op_div_def1 (a * b) (igcd (a, b));

    fun divlcm (NOT p) = divlcm p
      | divlcm (And (p, q)) = ilcm (divlcm p) (divlcm q)
      | divlcm (Or (p, q)) = ilcm (divlcm p) (divlcm q)
      | divlcm (Lt (u, v)) = 1
      | divlcm (Gt (w, x)) = 1
      | divlcm (Le (y, z)) = 1
      | divlcm (Ge (aa, ab)) = 1
      | divlcm (Eq (ac, ad)) = 1
      | divlcm (Divides (Cst bo, Cst cg)) = 1
      | divlcm (Divides (Cst bo, Var ch)) = 1
      | divlcm (Divides (Cst bo, Neg ci)) = 1
      | divlcm (Divides (Cst bo, Add (Cst cy, ck))) = 1
      | divlcm (Divides (Cst bo, Add (Var cz, ck))) = 1
      | divlcm (Divides (Cst bo, Add (Neg da, ck))) = 1
      | divlcm (Divides (Cst bo, Add (Add (db, dc), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Sub (dd, de), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Cst ei), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Var fa), ck))) =
        (if (fa = 0) then abs bo else 1)
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Neg ek), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Add (el, em)), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Sub (en, eo)), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Cst dq, Mult (ep, eq)), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Var dr, dg), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Neg ds, dg), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Add (dt, du), dg), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Sub (dv, dw), dg), ck))) = 1
      | divlcm (Divides (Cst bo, Add (Mult (Mult (dx, dy), dg), ck))) = 1
      | divlcm (Divides (Cst bo, Sub (cl, cm))) = 1
      | divlcm (Divides (Cst bo, Mult (cn, co))) = 1
      | divlcm (Divides (Var bp, af)) = 1
      | divlcm (Divides (Neg bq, af)) = 1
      | divlcm (Divides (Add (br, bs), af)) = 1
      | divlcm (Divides (Sub (bt, bu), af)) = 1
      | divlcm (Divides (Mult (bv, bw), af)) = 1
      | divlcm T = 1
      | divlcm F = 1
      | divlcm (Imp (al, am)) = 1
      | divlcm (Equ (an, ao)) = 1
      | divlcm (QAll ap) = 1
      | divlcm (QEx aq) = 1;

    fun explode_minf (q, B) =
        let val d = divlcm q; val pm = minusinf q;
            val dj1 = explode_disj (map (fn x => Cst x) (iupto (1, d)), pm)
        in (case dj1 of
             Lt (x, xa) =>
               let val dj2 = explode_disj (all_sums (d, B), q)
               in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                    | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                    | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                    | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                    | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                    | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                    | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                    | QEx x => Or (dj1, dj2))
               end
             | Gt (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Le (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Ge (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Eq (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Divides (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | T => T | F => explode_disj (all_sums (d, B), q)
             | NOT x =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | And (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Or (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Imp (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | Equ (x, xa) =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | QAll x =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end
             | QEx x =>
                 let val dj2 = explode_disj (all_sums (d, B), q)
                 in (case dj2 of Lt (x, xa) => Or (dj1, dj2)
                      | Gt (x, xa) => Or (dj1, dj2) | Le (x, xa) => Or (dj1, dj2)
                      | Ge (x, xa) => Or (dj1, dj2) | Eq (x, xa) => Or (dj1, dj2)
                      | Divides (x, xa) => Or (dj1, dj2) | T => T | F => dj1
                      | NOT x => Or (dj1, dj2) | And (x, xa) => Or (dj1, dj2)
                      | Or (x, xa) => Or (dj1, dj2) | Imp (x, xa) => Or (dj1, dj2)
                      | Equ (x, xa) => Or (dj1, dj2) | QAll x => Or (dj1, dj2)
                      | QEx x => Or (dj1, dj2))
                 end)
        end;

    fun mirror (And (p, q)) = And (mirror p, mirror q)
      | mirror (Or (p, q)) = Or (mirror p, mirror q)
      | mirror (Lt (u, v)) = Lt (u, v)
      | mirror (Gt (w, x)) = Gt (w, x)
      | mirror (Le (Cst bp, aa)) = Le (Cst bp, aa)
      | mirror (Le (Var bq, aa)) = Le (Var bq, aa)
      | mirror (Le (Neg br, aa)) = Le (Neg br, aa)
      | mirror (Le (Add (Cst ch, bt), aa)) = Le (Add (Cst ch, bt), aa)
      | mirror (Le (Add (Var ci, bt), aa)) = Le (Add (Var ci, bt), aa)
      | mirror (Le (Add (Neg cj, bt), aa)) = Le (Add (Neg cj, bt), aa)
      | mirror (Le (Add (Add (ck, cl), bt), aa)) = Le (Add (Add (ck, cl), bt), aa)
      | mirror (Le (Add (Sub (cm, cn), bt), aa)) = Le (Add (Sub (cm, cn), bt), aa)
      | mirror (Le (Add (Mult (Cst cz, Cst dr), bt), aa)) =
        Le (Add (Mult (Cst cz, Cst dr), bt), aa)
      | mirror (Le (Add (Mult (Cst cz, Var ej), bt), aa)) =
        (if (ej = 0) then Le (Add (Mult (Cst (~ cz), Var 0), bt), aa)
          else Le (Add (Mult (Cst cz, Var (op_45_def0 ej id_1_def0 + 1)), bt), aa))
      | mirror (Le (Add (Mult (Cst cz, Neg dt), bt), aa)) =
        Le (Add (Mult (Cst cz, Neg dt), bt), aa)
      | mirror (Le (Add (Mult (Cst cz, Add (du, dv)), bt), aa)) =
        Le (Add (Mult (Cst cz, Add (du, dv)), bt), aa)
      | mirror (Le (Add (Mult (Cst cz, Sub (dw, dx)), bt), aa)) =
        Le (Add (Mult (Cst cz, Sub (dw, dx)), bt), aa)
      | mirror (Le (Add (Mult (Cst cz, Mult (dy, dz)), bt), aa)) =
        Le (Add (Mult (Cst cz, Mult (dy, dz)), bt), aa)
      | mirror (Le (Add (Mult (Var da, cp), bt), aa)) =
        Le (Add (Mult (Var da, cp), bt), aa)
      | mirror (Le (Add (Mult (Neg db, cp), bt), aa)) =
        Le (Add (Mult (Neg db, cp), bt), aa)
      | mirror (Le (Add (Mult (Add (dc, dd), cp), bt), aa)) =
        Le (Add (Mult (Add (dc, dd), cp), bt), aa)
      | mirror (Le (Add (Mult (Sub (de, df), cp), bt), aa)) =
        Le (Add (Mult (Sub (de, df), cp), bt), aa)
      | mirror (Le (Add (Mult (Mult (dg, dh), cp), bt), aa)) =
        Le (Add (Mult (Mult (dg, dh), cp), bt), aa)
      | mirror (Le (Sub (bu, bv), aa)) = Le (Sub (bu, bv), aa)
      | mirror (Le (Mult (bw, bx), aa)) = Le (Mult (bw, bx), aa)
      | mirror (Ge (ab, ac)) = Ge (ab, ac)
      | mirror (Eq (Cst el, ae)) = Eq (Cst el, ae)
      | mirror (Eq (Var em, ae)) = Eq (Var em, ae)
      | mirror (Eq (Neg en, ae)) = Eq (Neg en, ae)
      | mirror (Eq (Add (Cst fd, ep), ae)) = Eq (Add (Cst fd, ep), ae)
      | mirror (Eq (Add (Var fe, ep), ae)) = Eq (Add (Var fe, ep), ae)
      | mirror (Eq (Add (Neg ff, ep), ae)) = Eq (Add (Neg ff, ep), ae)
      | mirror (Eq (Add (Add (fg, fh), ep), ae)) = Eq (Add (Add (fg, fh), ep), ae)
      | mirror (Eq (Add (Sub (fi, fj), ep), ae)) = Eq (Add (Sub (fi, fj), ep), ae)
      | mirror (Eq (Add (Mult (Cst fv, Cst gn), ep), ae)) =
        Eq (Add (Mult (Cst fv, Cst gn), ep), ae)
      | mirror (Eq (Add (Mult (Cst fv, Var hf), ep), ae)) =
        (if (hf = 0) then Eq (Add (Mult (Cst (~ fv), Var 0), ep), ae)
          else Eq (Add (Mult (Cst fv, Var (op_45_def0 hf id_1_def0 + 1)), ep), ae))
      | mirror (Eq (Add (Mult (Cst fv, Neg gp), ep), ae)) =
        Eq (Add (Mult (Cst fv, Neg gp), ep), ae)
      | mirror (Eq (Add (Mult (Cst fv, Add (gq, gr)), ep), ae)) =
        Eq (Add (Mult (Cst fv, Add (gq, gr)), ep), ae)
      | mirror (Eq (Add (Mult (Cst fv, Sub (gs, gt)), ep), ae)) =
        Eq (Add (Mult (Cst fv, Sub (gs, gt)), ep), ae)
      | mirror (Eq (Add (Mult (Cst fv, Mult (gu, gv)), ep), ae)) =
        Eq (Add (Mult (Cst fv, Mult (gu, gv)), ep), ae)
      | mirror (Eq (Add (Mult (Var fw, fl), ep), ae)) =
        Eq (Add (Mult (Var fw, fl), ep), ae)
      | mirror (Eq (Add (Mult (Neg fx, fl), ep), ae)) =
        Eq (Add (Mult (Neg fx, fl), ep), ae)
      | mirror (Eq (Add (Mult (Add (fy, fz), fl), ep), ae)) =
        Eq (Add (Mult (Add (fy, fz), fl), ep), ae)
      | mirror (Eq (Add (Mult (Sub (ga, gb), fl), ep), ae)) =
        Eq (Add (Mult (Sub (ga, gb), fl), ep), ae)
      | mirror (Eq (Add (Mult (Mult (gc, gd), fl), ep), ae)) =
        Eq (Add (Mult (Mult (gc, gd), fl), ep), ae)
      | mirror (Eq (Sub (eq, er), ae)) = Eq (Sub (eq, er), ae)
      | mirror (Eq (Mult (es, et), ae)) = Eq (Mult (es, et), ae)
      | mirror (Divides (Cst hh, Cst hz)) = Divides (Cst hh, Cst hz)
      | mirror (Divides (Cst hh, Var ia)) = Divides (Cst hh, Var ia)
      | mirror (Divides (Cst hh, Neg ib)) = Divides (Cst hh, Neg ib)
      | mirror (Divides (Cst hh, Add (Cst ir, id))) =
        Divides (Cst hh, Add (Cst ir, id))
      | mirror (Divides (Cst hh, Add (Var is, id))) =
        Divides (Cst hh, Add (Var is, id))
      | mirror (Divides (Cst hh, Add (Neg it, id))) =
        Divides (Cst hh, Add (Neg it, id))
      | mirror (Divides (Cst hh, Add (Add (iu, iv), id))) =
        Divides (Cst hh, Add (Add (iu, iv), id))
      | mirror (Divides (Cst hh, Add (Sub (iw, ix), id))) =
        Divides (Cst hh, Add (Sub (iw, ix), id))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Cst kb), id))) =
        Divides (Cst hh, Add (Mult (Cst jj, Cst kb), id))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Var kt), id))) =
        (if (kt = 0) then Divides (Cst hh, Add (Mult (Cst (~ jj), Var 0), id))
          else Divides
                 (Cst hh,
                   Add (Mult (Cst jj, Var (op_45_def0 kt id_1_def0 + 1)), id)))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Neg kd), id))) =
        Divides (Cst hh, Add (Mult (Cst jj, Neg kd), id))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Add (ke, kf)), id))) =
        Divides (Cst hh, Add (Mult (Cst jj, Add (ke, kf)), id))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Sub (kg, kh)), id))) =
        Divides (Cst hh, Add (Mult (Cst jj, Sub (kg, kh)), id))
      | mirror (Divides (Cst hh, Add (Mult (Cst jj, Mult (ki, kj)), id))) =
        Divides (Cst hh, Add (Mult (Cst jj, Mult (ki, kj)), id))
      | mirror (Divides (Cst hh, Add (Mult (Var jk, iz), id))) =
        Divides (Cst hh, Add (Mult (Var jk, iz), id))
      | mirror (Divides (Cst hh, Add (Mult (Neg jl, iz), id))) =
        Divides (Cst hh, Add (Mult (Neg jl, iz), id))
      | mirror (Divides (Cst hh, Add (Mult (Add (jm, jn), iz), id))) =
        Divides (Cst hh, Add (Mult (Add (jm, jn), iz), id))
      | mirror (Divides (Cst hh, Add (Mult (Sub (jo, jp), iz), id))) =
        Divides (Cst hh, Add (Mult (Sub (jo, jp), iz), id))
      | mirror (Divides (Cst hh, Add (Mult (Mult (jq, jr), iz), id))) =
        Divides (Cst hh, Add (Mult (Mult (jq, jr), iz), id))
      | mirror (Divides (Cst hh, Sub (ie, if'))) = Divides (Cst hh, Sub (ie, if'))
      | mirror (Divides (Cst hh, Mult (ig, ih))) = Divides (Cst hh, Mult (ig, ih))
      | mirror (Divides (Var hi, ag)) = Divides (Var hi, ag)
      | mirror (Divides (Neg hj, ag)) = Divides (Neg hj, ag)
      | mirror (Divides (Add (hk, hl), ag)) = Divides (Add (hk, hl), ag)
      | mirror (Divides (Sub (hm, hn), ag)) = Divides (Sub (hm, hn), ag)
      | mirror (Divides (Mult (ho, hp), ag)) = Divides (Mult (ho, hp), ag)
      | mirror T = T
      | mirror F = F
      | mirror (NOT (Lt (kv, kw))) = NOT (Lt (kv, kw))
      | mirror (NOT (Gt (kx, ky))) = NOT (Gt (kx, ky))
      | mirror (NOT (Le (kz, la))) = NOT (Le (kz, la))
      | mirror (NOT (Ge (lb, lc))) = NOT (Ge (lb, lc))
      | mirror (NOT (Eq (Cst mp, le))) = NOT (Eq (Cst mp, le))
      | mirror (NOT (Eq (Var mq, le))) = NOT (Eq (Var mq, le))
      | mirror (NOT (Eq (Neg mr, le))) = NOT (Eq (Neg mr, le))
      | mirror (NOT (Eq (Add (Cst nh, mt), le))) = NOT (Eq (Add (Cst nh, mt), le))
      | mirror (NOT (Eq (Add (Var ni, mt), le))) = NOT (Eq (Add (Var ni, mt), le))
      | mirror (NOT (Eq (Add (Neg nj, mt), le))) = NOT (Eq (Add (Neg nj, mt), le))
      | mirror (NOT (Eq (Add (Add (nk, nl), mt), le))) =
        NOT (Eq (Add (Add (nk, nl), mt), le))
      | mirror (NOT (Eq (Add (Sub (nm, nn), mt), le))) =
        NOT (Eq (Add (Sub (nm, nn), mt), le))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Cst or), mt), le))) =
        NOT (Eq (Add (Mult (Cst nz, Cst or), mt), le))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Var pj), mt), le))) =
        (if (pj = 0) then NOT (Eq (Add (Mult (Cst (~ nz), Var 0), mt), le))
          else NOT (Eq (Add (Mult (Cst nz, Var (op_45_def0 pj id_1_def0 + 1)), mt),
                         le)))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Neg ot), mt), le))) =
        NOT (Eq (Add (Mult (Cst nz, Neg ot), mt), le))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Add (ou, ov)), mt), le))) =
        NOT (Eq (Add (Mult (Cst nz, Add (ou, ov)), mt), le))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Sub (ow, ox)), mt), le))) =
        NOT (Eq (Add (Mult (Cst nz, Sub (ow, ox)), mt), le))
      | mirror (NOT (Eq (Add (Mult (Cst nz, Mult (oy, oz)), mt), le))) =
        NOT (Eq (Add (Mult (Cst nz, Mult (oy, oz)), mt), le))
      | mirror (NOT (Eq (Add (Mult (Var oa, np), mt), le))) =
        NOT (Eq (Add (Mult (Var oa, np), mt), le))
      | mirror (NOT (Eq (Add (Mult (Neg ob, np), mt), le))) =
        NOT (Eq (Add (Mult (Neg ob, np), mt), le))
      | mirror (NOT (Eq (Add (Mult (Add (oc, od), np), mt), le))) =
        NOT (Eq (Add (Mult (Add (oc, od), np), mt), le))
      | mirror (NOT (Eq (Add (Mult (Sub (oe, of'), np), mt), le))) =
        NOT (Eq (Add (Mult (Sub (oe, of'), np), mt), le))
      | mirror (NOT (Eq (Add (Mult (Mult (og, oh), np), mt), le))) =
        NOT (Eq (Add (Mult (Mult (og, oh), np), mt), le))
      | mirror (NOT (Eq (Sub (mu, mv), le))) = NOT (Eq (Sub (mu, mv), le))
      | mirror (NOT (Eq (Mult (mw, mx), le))) = NOT (Eq (Mult (mw, mx), le))
      | mirror (NOT (Divides (Cst pl, Cst qd))) = NOT (Divides (Cst pl, Cst qd))
      | mirror (NOT (Divides (Cst pl, Var qe))) = NOT (Divides (Cst pl, Var qe))
      | mirror (NOT (Divides (Cst pl, Neg qf))) = NOT (Divides (Cst pl, Neg qf))
      | mirror (NOT (Divides (Cst pl, Add (Cst qv, qh)))) =
        NOT (Divides (Cst pl, Add (Cst qv, qh)))
      | mirror (NOT (Divides (Cst pl, Add (Var qw, qh)))) =
        NOT (Divides (Cst pl, Add (Var qw, qh)))
      | mirror (NOT (Divides (Cst pl, Add (Neg qx, qh)))) =
        NOT (Divides (Cst pl, Add (Neg qx, qh)))
      | mirror (NOT (Divides (Cst pl, Add (Add (qy, qz), qh)))) =
        NOT (Divides (Cst pl, Add (Add (qy, qz), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Sub (ra, rb), qh)))) =
        NOT (Divides (Cst pl, Add (Sub (ra, rb), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Cst sf), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Cst rn, Cst sf), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Var sx), qh)))) =
        (if (sx = 0)
          then NOT (Divides (Cst pl, Add (Mult (Cst (~ rn), Var 0), qh)))
          else NOT (Divides
                      (Cst pl,
                        Add (Mult (Cst rn, Var (op_45_def0 sx id_1_def0 + 1)),
                              qh))))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Neg sh), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Cst rn, Neg sh), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Add (si, sj)), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Cst rn, Add (si, sj)), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Sub (sk, sl)), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Cst rn, Sub (sk, sl)), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Cst rn, Mult (sm, sn)), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Cst rn, Mult (sm, sn)), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Var ro, rd), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Var ro, rd), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Neg rp, rd), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Neg rp, rd), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Add (rq, rr), rd), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Add (rq, rr), rd), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Sub (rs, rt), rd), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Sub (rs, rt), rd), qh)))
      | mirror (NOT (Divides (Cst pl, Add (Mult (Mult (ru, rv), rd), qh)))) =
        NOT (Divides (Cst pl, Add (Mult (Mult (ru, rv), rd), qh)))
      | mirror (NOT (Divides (Cst pl, Sub (qi, qj)))) =
        NOT (Divides (Cst pl, Sub (qi, qj)))
      | mirror (NOT (Divides (Cst pl, Mult (qk, ql)))) =
        NOT (Divides (Cst pl, Mult (qk, ql)))
      | mirror (NOT (Divides (Var pm, lg))) = NOT (Divides (Var pm, lg))
      | mirror (NOT (Divides (Neg pn, lg))) = NOT (Divides (Neg pn, lg))
      | mirror (NOT (Divides (Add (po, pp), lg))) = NOT (Divides (Add (po, pp), lg))
      | mirror (NOT (Divides (Sub (pq, pr), lg))) = NOT (Divides (Sub (pq, pr), lg))
      | mirror (NOT (Divides (Mult (ps, pt), lg))) =
        NOT (Divides (Mult (ps, pt), lg))
      | mirror (NOT T) = NOT T
      | mirror (NOT F) = NOT F
      | mirror (NOT (NOT lh)) = NOT (NOT lh)
      | mirror (NOT (And (li, lj))) = NOT (And (li, lj))
      | mirror (NOT (Or (lk, ll))) = NOT (Or (lk, ll))
      | mirror (NOT (Imp (lm, ln))) = NOT (Imp (lm, ln))
      | mirror (NOT (Equ (lo, lp))) = NOT (Equ (lo, lp))
      | mirror (NOT (QAll lq)) = NOT (QAll lq)
      | mirror (NOT (QEx lr)) = NOT (QEx lr)
      | mirror (Imp (am, an)) = Imp (am, an)
      | mirror (Equ (ao, ap)) = Equ (ao, ap)
      | mirror (QAll aq) = QAll aq
      | mirror (QEx ar) = QEx ar;

    fun op_43_def0 m n = nat ((m) + (n));

    fun size_def1 [] = (0:IntInf.int)
      | size_def1 (a :: list) = op_43_def0 (size_def1 list) (0 + 1);

    fun aset (And (p, q)) = op_64 (aset p) (aset q)
      | aset (Or (p, q)) = op_64 (aset p) (aset q)
      | aset (Lt (u, v)) = []
      | aset (Gt (w, x)) = []
      | aset (Le (Cst bo, z)) = []
      | aset (Le (Var bp, z)) = []
      | aset (Le (Neg bq, z)) = []
      | aset (Le (Add (Cst cg, bs), z)) = []
      | aset (Le (Add (Var ch, bs), z)) = []
      | aset (Le (Add (Neg ci, bs), z)) = []
      | aset (Le (Add (Add (cj, ck), bs), z)) = []
      | aset (Le (Add (Sub (cl, cm), bs), z)) = []
      | aset (Le (Add (Mult (Cst cy, Cst dq), bs), z)) = []
      | aset (Le (Add (Mult (Cst cy, Var ei), bs), z)) =
        (if (ei = 0)
          then (if (cy < 0) then [lin_add (bs, Cst 1)]
                 else [lin_neg bs, lin_add (lin_neg bs, Cst 1)])
          else [])
      | aset (Le (Add (Mult (Cst cy, Neg ds), bs), z)) = []
      | aset (Le (Add (Mult (Cst cy, Add (dt, du)), bs), z)) = []
      | aset (Le (Add (Mult (Cst cy, Sub (dv, dw)), bs), z)) = []
      | aset (Le (Add (Mult (Cst cy, Mult (dx, dy)), bs), z)) = []
      | aset (Le (Add (Mult (Var cz, co), bs), z)) = []
      | aset (Le (Add (Mult (Neg da, co), bs), z)) = []
      | aset (Le (Add (Mult (Add (db, dc), co), bs), z)) = []
      | aset (Le (Add (Mult (Sub (dd, de), co), bs), z)) = []
      | aset (Le (Add (Mult (Mult (df, dg), co), bs), z)) = []
      | aset (Le (Sub (bt, bu), z)) = []
      | aset (Le (Mult (bv, bw), z)) = []
      | aset (Ge (aa, ab)) = []
      | aset (Eq (Cst ek, ad)) = []
      | aset (Eq (Var el, ad)) = []
      | aset (Eq (Neg em, ad)) = []
      | aset (Eq (Add (Cst fc, eo), ad)) = []
      | aset (Eq (Add (Var fd, eo), ad)) = []
      | aset (Eq (Add (Neg fe, eo), ad)) = []
      | aset (Eq (Add (Add (ff, fg), eo), ad)) = []
      | aset (Eq (Add (Sub (fh, fi), eo), ad)) = []
      | aset (Eq (Add (Mult (Cst fu, Cst gm), eo), ad)) = []
      | aset (Eq (Add (Mult (Cst fu, Var he), eo), ad)) =
        (if (he = 0)
          then (if (fu < 0) then [lin_add (eo, Cst 1)]
                 else [lin_add (lin_neg eo, Cst 1)])
          else [])
      | aset (Eq (Add (Mult (Cst fu, Neg go), eo), ad)) = []
      | aset (Eq (Add (Mult (Cst fu, Add (gp, gq)), eo), ad)) = []
      | aset (Eq (Add (Mult (Cst fu, Sub (gr, gs)), eo), ad)) = []
      | aset (Eq (Add (Mult (Cst fu, Mult (gt, gu)), eo), ad)) = []
      | aset (Eq (Add (Mult (Var fv, fk), eo), ad)) = []
      | aset (Eq (Add (Mult (Neg fw, fk), eo), ad)) = []
      | aset (Eq (Add (Mult (Add (fx, fy), fk), eo), ad)) = []
      | aset (Eq (Add (Mult (Sub (fz, ga), fk), eo), ad)) = []
      | aset (Eq (Add (Mult (Mult (gb, gc), fk), eo), ad)) = []
      | aset (Eq (Sub (ep, eq), ad)) = []
      | aset (Eq (Mult (er, es), ad)) = []
      | aset (Divides (ae, af)) = []
      | aset T = []
      | aset F = []
      | aset (NOT (Lt (hg, hh))) = []
      | aset (NOT (Gt (hi, hj))) = []
      | aset (NOT (Le (hk, hl))) = []
      | aset (NOT (Ge (hm, hn))) = []
      | aset (NOT (Eq (Cst ja, hp))) = []
      | aset (NOT (Eq (Var jb, hp))) = []
      | aset (NOT (Eq (Neg jc, hp))) = []
      | aset (NOT (Eq (Add (Cst js, je), hp))) = []
      | aset (NOT (Eq (Add (Var jt, je), hp))) = []
      | aset (NOT (Eq (Add (Neg ju, je), hp))) = []
      | aset (NOT (Eq (Add (Add (jv, jw), je), hp))) = []
      | aset (NOT (Eq (Add (Sub (jx, jy), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Cst kk, Cst lc), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Cst kk, Var lu), je), hp))) =
        (if (lu = 0) then (if (kk < 0) then [je] else [lin_neg je]) else [])
      | aset (NOT (Eq (Add (Mult (Cst kk, Neg le), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Cst kk, Add (lf, lg)), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Cst kk, Sub (lh, li)), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Cst kk, Mult (lj, lk)), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Var kl, ka), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Neg km, ka), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Add (kn, ko), ka), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Sub (kp, kq), ka), je), hp))) = []
      | aset (NOT (Eq (Add (Mult (Mult (kr, ks), ka), je), hp))) = []
      | aset (NOT (Eq (Sub (jf, jg), hp))) = []
      | aset (NOT (Eq (Mult (jh, ji), hp))) = []
      | aset (NOT (Divides (hq, hr))) = []
      | aset (NOT T) = []
      | aset (NOT F) = []
      | aset (NOT (NOT hs)) = []
      | aset (NOT (And (ht, hu))) = []
      | aset (NOT (Or (hv, hw))) = []
      | aset (NOT (Imp (hx, hy))) = []
      | aset (NOT (Equ (hz, ia))) = []
      | aset (NOT (QAll ib)) = []
      | aset (NOT (QEx ic)) = []
      | aset (Imp (al, am)) = []
      | aset (Equ (an, ao)) = []
      | aset (QAll ap) = []
      | aset (QEx aq) = [];

    fun op_mem x [] = false
      | op_mem x (y :: ys) = (if (y = x) then true else op_mem x ys);

    fun list_insert x xs = (if op_mem x xs then xs else (x :: xs));

    fun list_set [] = []
      | list_set (x :: xs) = list_insert x (list_set xs);

    fun bset (And (p, q)) = op_64 (bset p) (bset q)
      | bset (Or (p, q)) = op_64 (bset p) (bset q)
      | bset (Lt (u, v)) = []
      | bset (Gt (w, x)) = []
      | bset (Le (Cst bo, z)) = []
      | bset (Le (Var bp, z)) = []
      | bset (Le (Neg bq, z)) = []
      | bset (Le (Add (Cst cg, bs), z)) = []
      | bset (Le (Add (Var ch, bs), z)) = []
      | bset (Le (Add (Neg ci, bs), z)) = []
      | bset (Le (Add (Add (cj, ck), bs), z)) = []
      | bset (Le (Add (Sub (cl, cm), bs), z)) = []
      | bset (Le (Add (Mult (Cst cy, Cst dq), bs), z)) = []
      | bset (Le (Add (Mult (Cst cy, Var ei), bs), z)) =
        (if (ei = 0)
          then (if (cy < 0) then [lin_add (bs, Cst ~1), bs]
                 else [lin_add (lin_neg bs, Cst ~1)])
          else [])
      | bset (Le (Add (Mult (Cst cy, Neg ds), bs), z)) = []
      | bset (Le (Add (Mult (Cst cy, Add (dt, du)), bs), z)) = []
      | bset (Le (Add (Mult (Cst cy, Sub (dv, dw)), bs), z)) = []
      | bset (Le (Add (Mult (Cst cy, Mult (dx, dy)), bs), z)) = []
      | bset (Le (Add (Mult (Var cz, co), bs), z)) = []
      | bset (Le (Add (Mult (Neg da, co), bs), z)) = []
      | bset (Le (Add (Mult (Add (db, dc), co), bs), z)) = []
      | bset (Le (Add (Mult (Sub (dd, de), co), bs), z)) = []
      | bset (Le (Add (Mult (Mult (df, dg), co), bs), z)) = []
      | bset (Le (Sub (bt, bu), z)) = []
      | bset (Le (Mult (bv, bw), z)) = []
      | bset (Ge (aa, ab)) = []
      | bset (Eq (Cst ek, ad)) = []
      | bset (Eq (Var el, ad)) = []
      | bset (Eq (Neg em, ad)) = []
      | bset (Eq (Add (Cst fc, eo), ad)) = []
      | bset (Eq (Add (Var fd, eo), ad)) = []
      | bset (Eq (Add (Neg fe, eo), ad)) = []
      | bset (Eq (Add (Add (ff, fg), eo), ad)) = []
      | bset (Eq (Add (Sub (fh, fi), eo), ad)) = []
      | bset (Eq (Add (Mult (Cst fu, Cst gm), eo), ad)) = []
      | bset (Eq (Add (Mult (Cst fu, Var he), eo), ad)) =
        (if (he = 0)
          then (if (fu < 0) then [lin_add (eo, Cst ~1)]
                 else [lin_add (lin_neg eo, Cst ~1)])
          else [])
      | bset (Eq (Add (Mult (Cst fu, Neg go), eo), ad)) = []
      | bset (Eq (Add (Mult (Cst fu, Add (gp, gq)), eo), ad)) = []
      | bset (Eq (Add (Mult (Cst fu, Sub (gr, gs)), eo), ad)) = []
      | bset (Eq (Add (Mult (Cst fu, Mult (gt, gu)), eo), ad)) = []
      | bset (Eq (Add (Mult (Var fv, fk), eo), ad)) = []
      | bset (Eq (Add (Mult (Neg fw, fk), eo), ad)) = []
      | bset (Eq (Add (Mult (Add (fx, fy), fk), eo), ad)) = []
      | bset (Eq (Add (Mult (Sub (fz, ga), fk), eo), ad)) = []
      | bset (Eq (Add (Mult (Mult (gb, gc), fk), eo), ad)) = []
      | bset (Eq (Sub (ep, eq), ad)) = []
      | bset (Eq (Mult (er, es), ad)) = []
      | bset (Divides (ae, af)) = []
      | bset T = []
      | bset F = []
      | bset (NOT (Lt (hg, hh))) = []
      | bset (NOT (Gt (hi, hj))) = []
      | bset (NOT (Le (hk, hl))) = []
      | bset (NOT (Ge (hm, hn))) = []
      | bset (NOT (Eq (Cst ja, hp))) = []
      | bset (NOT (Eq (Var jb, hp))) = []
      | bset (NOT (Eq (Neg jc, hp))) = []
      | bset (NOT (Eq (Add (Cst js, je), hp))) = []
      | bset (NOT (Eq (Add (Var jt, je), hp))) = []
      | bset (NOT (Eq (Add (Neg ju, je), hp))) = []
      | bset (NOT (Eq (Add (Add (jv, jw), je), hp))) = []
      | bset (NOT (Eq (Add (Sub (jx, jy), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Cst kk, Cst lc), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Cst kk, Var lu), je), hp))) =
        (if (lu = 0) then (if (kk < 0) then [je] else [lin_neg je]) else [])
      | bset (NOT (Eq (Add (Mult (Cst kk, Neg le), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Cst kk, Add (lf, lg)), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Cst kk, Sub (lh, li)), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Cst kk, Mult (lj, lk)), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Var kl, ka), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Neg km, ka), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Add (kn, ko), ka), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Sub (kp, kq), ka), je), hp))) = []
      | bset (NOT (Eq (Add (Mult (Mult (kr, ks), ka), je), hp))) = []
      | bset (NOT (Eq (Sub (jf, jg), hp))) = []
      | bset (NOT (Eq (Mult (jh, ji), hp))) = []
      | bset (NOT (Divides (hq, hr))) = []
      | bset (NOT T) = []
      | bset (NOT F) = []
      | bset (NOT (NOT hs)) = []
      | bset (NOT (And (ht, hu))) = []
      | bset (NOT (Or (hv, hw))) = []
      | bset (NOT (Imp (hx, hy))) = []
      | bset (NOT (Equ (hz, ia))) = []
      | bset (NOT (QAll ib)) = []
      | bset (NOT (QEx ic)) = []
      | bset (Imp (al, am)) = []
      | bset (Equ (an, ao)) = []
      | bset (QAll ap) = []
      | bset (QEx aq) = [];

    fun adjustcoeff (l:IntInf.int, Le (Add (Mult (Cst c, Var 0), r), Cst i)) =
        (if (c <= 0)
          then Le (Add (Mult (Cst ~1, Var 0), lin_mul (~ (op_div_def1 l c), r)),
                    Cst 0)
          else Le (Add (Mult (Cst 1, Var 0), lin_mul (op_div_def1 l c, r)), Cst 0))
      | adjustcoeff (l, Eq (Add (Mult (Cst c, Var 0), r), Cst i)) =
        Eq (Add (Mult (Cst 1, Var 0), lin_mul (op_div_def1 l c, r)), Cst 0)
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst c, Var 0), r), Cst i))) =
        NOT (Eq (Add (Mult (Cst 1, Var 0), lin_mul (op_div_def1 l c, r)), Cst 0))
      | adjustcoeff (l, And (p, q)) = And (adjustcoeff (l, p), adjustcoeff (l, q))
      | adjustcoeff (l, Or (p, q)) = Or (adjustcoeff (l, p), adjustcoeff (l, q))
      | adjustcoeff (l, Lt (w, x)) = Lt (w, x)
      | adjustcoeff (l, Gt (y, z)) = Gt (y, z)
      | adjustcoeff (l, Le (Cst bq, ab)) = Le (Cst bq, ab)
      | adjustcoeff (l, Le (Var br, ab)) = Le (Var br, ab)
      | adjustcoeff (l, Le (Neg bs, ab)) = Le (Neg bs, ab)
      | adjustcoeff (l, Le (Add (Cst ci, bu), ab)) = Le (Add (Cst ci, bu), ab)
      | adjustcoeff (l, Le (Add (Var cj, bu), ab)) = Le (Add (Var cj, bu), ab)
      | adjustcoeff (l, Le (Add (Neg ck, bu), ab)) = Le (Add (Neg ck, bu), ab)
      | adjustcoeff (l, Le (Add (Add (cl, cm), bu), ab)) =
        Le (Add (Add (cl, cm), bu), ab)
      | adjustcoeff (l, Le (Add (Sub (cn, co), bu), ab)) =
        Le (Add (Sub (cn, co), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Cst ds), bu), ab)) =
        Le (Add (Mult (Cst da, Cst ds), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var 0), bu), Var en)) =
        Le (Add (Mult (Cst da, Var 0), bu), Var en)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var 0), bu), Neg eo)) =
        Le (Add (Mult (Cst da, Var 0), bu), Neg eo)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var 0), bu), Add (ep, eq))) =
        Le (Add (Mult (Cst da, Var 0), bu), Add (ep, eq))
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var 0), bu), Sub (er, es))) =
        Le (Add (Mult (Cst da, Var 0), bu), Sub (er, es))
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var 0), bu), Mult (et, eu))) =
        Le (Add (Mult (Cst da, Var 0), bu), Mult (et, eu))
      | adjustcoeff (l, Le (Add (Mult (Cst da, Var ek), bu), ab)) =
        Le (Add (Mult (Cst da, Var ek), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Neg du), bu), ab)) =
        Le (Add (Mult (Cst da, Neg du), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Add (dv, dw)), bu), ab)) =
        Le (Add (Mult (Cst da, Add (dv, dw)), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Sub (dx, dy)), bu), ab)) =
        Le (Add (Mult (Cst da, Sub (dx, dy)), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Cst da, Mult (dz, ea)), bu), ab)) =
        Le (Add (Mult (Cst da, Mult (dz, ea)), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Var db, cq), bu), ab)) =
        Le (Add (Mult (Var db, cq), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Neg dc, cq), bu), ab)) =
        Le (Add (Mult (Neg dc, cq), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Add (dd, de), cq), bu), ab)) =
        Le (Add (Mult (Add (dd, de), cq), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Sub (df, dg), cq), bu), ab)) =
        Le (Add (Mult (Sub (df, dg), cq), bu), ab)
      | adjustcoeff (l, Le (Add (Mult (Mult (dh, di), cq), bu), ab)) =
        Le (Add (Mult (Mult (dh, di), cq), bu), ab)
      | adjustcoeff (l, Le (Sub (bv, bw), ab)) = Le (Sub (bv, bw), ab)
      | adjustcoeff (l, Le (Mult (bx, by), ab)) = Le (Mult (bx, by), ab)
      | adjustcoeff (l, Ge (ac, ad)) = Ge (ac, ad)
      | adjustcoeff (l, Eq (Cst fe, af)) = Eq (Cst fe, af)
      | adjustcoeff (l, Eq (Var ff, af)) = Eq (Var ff, af)
      | adjustcoeff (l, Eq (Neg fg, af)) = Eq (Neg fg, af)
      | adjustcoeff (l, Eq (Add (Cst fw, fi), af)) = Eq (Add (Cst fw, fi), af)
      | adjustcoeff (l, Eq (Add (Var fx, fi), af)) = Eq (Add (Var fx, fi), af)
      | adjustcoeff (l, Eq (Add (Neg fy, fi), af)) = Eq (Add (Neg fy, fi), af)
      | adjustcoeff (l, Eq (Add (Add (fz, ga), fi), af)) =
        Eq (Add (Add (fz, ga), fi), af)
      | adjustcoeff (l, Eq (Add (Sub (gb, gc), fi), af)) =
        Eq (Add (Sub (gb, gc), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Cst hg), fi), af)) =
        Eq (Add (Mult (Cst go, Cst hg), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var 0), fi), Var ib)) =
        Eq (Add (Mult (Cst go, Var 0), fi), Var ib)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var 0), fi), Neg ic)) =
        Eq (Add (Mult (Cst go, Var 0), fi), Neg ic)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var 0), fi), Add (id, ie))) =
        Eq (Add (Mult (Cst go, Var 0), fi), Add (id, ie))
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var 0), fi), Sub (if', ig))) =
        Eq (Add (Mult (Cst go, Var 0), fi), Sub (if', ig))
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var 0), fi), Mult (ih, ii))) =
        Eq (Add (Mult (Cst go, Var 0), fi), Mult (ih, ii))
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Var hy), fi), af)) =
        Eq (Add (Mult (Cst go, Var hy), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Neg hi), fi), af)) =
        Eq (Add (Mult (Cst go, Neg hi), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Add (hj, hk)), fi), af)) =
        Eq (Add (Mult (Cst go, Add (hj, hk)), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Sub (hl, hm)), fi), af)) =
        Eq (Add (Mult (Cst go, Sub (hl, hm)), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Cst go, Mult (hn, ho)), fi), af)) =
        Eq (Add (Mult (Cst go, Mult (hn, ho)), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Var gp, ge), fi), af)) =
        Eq (Add (Mult (Var gp, ge), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Neg gq, ge), fi), af)) =
        Eq (Add (Mult (Neg gq, ge), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Add (gr, gs), ge), fi), af)) =
        Eq (Add (Mult (Add (gr, gs), ge), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Sub (gt, gu), ge), fi), af)) =
        Eq (Add (Mult (Sub (gt, gu), ge), fi), af)
      | adjustcoeff (l, Eq (Add (Mult (Mult (gv, gw), ge), fi), af)) =
        Eq (Add (Mult (Mult (gv, gw), ge), fi), af)
      | adjustcoeff (l, Eq (Sub (fj, fk), af)) = Eq (Sub (fj, fk), af)
      | adjustcoeff (l, Eq (Mult (fl, fm), af)) = Eq (Mult (fl, fm), af)
      | adjustcoeff (l, Divides (Cst is, Cst jk)) = Divides (Cst is, Cst jk)
      | adjustcoeff (l, Divides (Cst is, Var jl)) = Divides (Cst is, Var jl)
      | adjustcoeff (l, Divides (Cst is, Neg jm)) = Divides (Cst is, Neg jm)
      | adjustcoeff (l, Divides (Cst is, Add (Cst kc, jo))) =
        Divides (Cst is, Add (Cst kc, jo))
      | adjustcoeff (l, Divides (Cst is, Add (Var kd, jo))) =
        Divides (Cst is, Add (Var kd, jo))
      | adjustcoeff (l, Divides (Cst is, Add (Neg ke, jo))) =
        Divides (Cst is, Add (Neg ke, jo))
      | adjustcoeff (l, Divides (Cst is, Add (Add (kf, kg), jo))) =
        Divides (Cst is, Add (Add (kf, kg), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Sub (kh, ki), jo))) =
        Divides (Cst is, Add (Sub (kh, ki), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Cst lm), jo))) =
        Divides (Cst is, Add (Mult (Cst ku, Cst lm), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Var me), jo))) =
        (if (me = 0)
          then Divides
                 (Cst (op_div_def1 l ku * is),
                   Add (Mult (Cst 1, Var 0), lin_mul (op_div_def1 l ku, jo)))
          else Divides
                 (Cst is,
                   Add (Mult (Cst ku, Var (op_45_def0 me id_1_def0 + 1)), jo)))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Neg lo), jo))) =
        Divides (Cst is, Add (Mult (Cst ku, Neg lo), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Add (lp, lq)), jo))) =
        Divides (Cst is, Add (Mult (Cst ku, Add (lp, lq)), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Sub (lr, ls)), jo))) =
        Divides (Cst is, Add (Mult (Cst ku, Sub (lr, ls)), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Cst ku, Mult (lt, lu)), jo))) =
        Divides (Cst is, Add (Mult (Cst ku, Mult (lt, lu)), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Var kv, kk), jo))) =
        Divides (Cst is, Add (Mult (Var kv, kk), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Neg kw, kk), jo))) =
        Divides (Cst is, Add (Mult (Neg kw, kk), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Add (kx, ky), kk), jo))) =
        Divides (Cst is, Add (Mult (Add (kx, ky), kk), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Sub (kz, la), kk), jo))) =
        Divides (Cst is, Add (Mult (Sub (kz, la), kk), jo))
      | adjustcoeff (l, Divides (Cst is, Add (Mult (Mult (lb, lc), kk), jo))) =
        Divides (Cst is, Add (Mult (Mult (lb, lc), kk), jo))
      | adjustcoeff (l, Divides (Cst is, Sub (jp, jq))) =
        Divides (Cst is, Sub (jp, jq))
      | adjustcoeff (l, Divides (Cst is, Mult (jr, js))) =
        Divides (Cst is, Mult (jr, js))
      | adjustcoeff (l, Divides (Var it, ah)) = Divides (Var it, ah)
      | adjustcoeff (l, Divides (Neg iu, ah)) = Divides (Neg iu, ah)
      | adjustcoeff (l, Divides (Add (iv, iw), ah)) = Divides (Add (iv, iw), ah)
      | adjustcoeff (l, Divides (Sub (ix, iy), ah)) = Divides (Sub (ix, iy), ah)
      | adjustcoeff (l, Divides (Mult (iz, ja), ah)) = Divides (Mult (iz, ja), ah)
      | adjustcoeff (l, T) = T
      | adjustcoeff (l, F) = F
      | adjustcoeff (l, NOT (Lt (mg, mh))) = NOT (Lt (mg, mh))
      | adjustcoeff (l, NOT (Gt (mi, mj))) = NOT (Gt (mi, mj))
      | adjustcoeff (l, NOT (Le (mk, ml))) = NOT (Le (mk, ml))
      | adjustcoeff (l, NOT (Ge (mm, mn))) = NOT (Ge (mm, mn))
      | adjustcoeff (l, NOT (Eq (Cst oa, mp))) = NOT (Eq (Cst oa, mp))
      | adjustcoeff (l, NOT (Eq (Var ob, mp))) = NOT (Eq (Var ob, mp))
      | adjustcoeff (l, NOT (Eq (Neg oc, mp))) = NOT (Eq (Neg oc, mp))
      | adjustcoeff (l, NOT (Eq (Add (Cst os, oe), mp))) =
        NOT (Eq (Add (Cst os, oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Var ot, oe), mp))) =
        NOT (Eq (Add (Var ot, oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Neg ou, oe), mp))) =
        NOT (Eq (Add (Neg ou, oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Add (ov, ow), oe), mp))) =
        NOT (Eq (Add (Add (ov, ow), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Sub (ox, oy), oe), mp))) =
        NOT (Eq (Add (Sub (ox, oy), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Cst qc), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Cst qc), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Var qx))) =
        NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Var qx))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Neg qy))) =
        NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Neg qy))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Add (qz, ra)))) =
        NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Add (qz, ra)))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Sub (rb, rc)))) =
        NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Sub (rb, rc)))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Mult (rd, re)))) =
        NOT (Eq (Add (Mult (Cst pk, Var 0), oe), Mult (rd, re)))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Var qu), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Var qu), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Neg qe), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Neg qe), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Add (qf, qg)), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Add (qf, qg)), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Sub (qh, qi)), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Sub (qh, qi)), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Cst pk, Mult (qj, qk)), oe), mp))) =
        NOT (Eq (Add (Mult (Cst pk, Mult (qj, qk)), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Var pl, pa), oe), mp))) =
        NOT (Eq (Add (Mult (Var pl, pa), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Neg pm, pa), oe), mp))) =
        NOT (Eq (Add (Mult (Neg pm, pa), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Add (pn, po), pa), oe), mp))) =
        NOT (Eq (Add (Mult (Add (pn, po), pa), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Sub (pp, pq), pa), oe), mp))) =
        NOT (Eq (Add (Mult (Sub (pp, pq), pa), oe), mp))
      | adjustcoeff (l, NOT (Eq (Add (Mult (Mult (pr, ps), pa), oe), mp))) =
        NOT (Eq (Add (Mult (Mult (pr, ps), pa), oe), mp))
      | adjustcoeff (l, NOT (Eq (Sub (of', og), mp))) = NOT (Eq (Sub (of', og), mp))
      | adjustcoeff (l, NOT (Eq (Mult (oh, oi), mp))) = NOT (Eq (Mult (oh, oi), mp))
      | adjustcoeff (l, NOT (Divides (Cst ro, Cst sg))) =
        NOT (Divides (Cst ro, Cst sg))
      | adjustcoeff (l, NOT (Divides (Cst ro, Var sh))) =
        NOT (Divides (Cst ro, Var sh))
      | adjustcoeff (l, NOT (Divides (Cst ro, Neg si))) =
        NOT (Divides (Cst ro, Neg si))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Cst sy, sk)))) =
        NOT (Divides (Cst ro, Add (Cst sy, sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Var sz, sk)))) =
        NOT (Divides (Cst ro, Add (Var sz, sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Neg ta, sk)))) =
        NOT (Divides (Cst ro, Add (Neg ta, sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Add (tb, tc), sk)))) =
        NOT (Divides (Cst ro, Add (Add (tb, tc), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Sub (td, te), sk)))) =
        NOT (Divides (Cst ro, Add (Sub (td, te), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Cst ui), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Cst tq, Cst ui), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Var va), sk)))) =
        (if (va = 0)
          then NOT (Divides
                      (Cst (op_div_def1 l tq * ro),
                        Add (Mult (Cst 1, Var 0), lin_mul (op_div_def1 l tq, sk))))
          else NOT (Divides
                      (Cst ro,
                        Add (Mult (Cst tq, Var (op_45_def0 va id_1_def0 + 1)),
                              sk))))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Neg uk), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Cst tq, Neg uk), sk)))
      | adjustcoeff
          (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Add (ul, um)), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Cst tq, Add (ul, um)), sk)))
      | adjustcoeff
          (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Sub (un, uo)), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Cst tq, Sub (un, uo)), sk)))
      | adjustcoeff
          (l, NOT (Divides (Cst ro, Add (Mult (Cst tq, Mult (up, uq)), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Cst tq, Mult (up, uq)), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Var tr, tg), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Var tr, tg), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Neg ts, tg), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Neg ts, tg), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Add (tt, tu), tg), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Add (tt, tu), tg), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Add (Mult (Sub (tv, tw), tg), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Sub (tv, tw), tg), sk)))
      | adjustcoeff
          (l, NOT (Divides (Cst ro, Add (Mult (Mult (tx, ty), tg), sk)))) =
        NOT (Divides (Cst ro, Add (Mult (Mult (tx, ty), tg), sk)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Sub (sl, sm)))) =
        NOT (Divides (Cst ro, Sub (sl, sm)))
      | adjustcoeff (l, NOT (Divides (Cst ro, Mult (sn, so)))) =
        NOT (Divides (Cst ro, Mult (sn, so)))
      | adjustcoeff (l, NOT (Divides (Var rp, mr))) = NOT (Divides (Var rp, mr))
      | adjustcoeff (l, NOT (Divides (Neg rq, mr))) = NOT (Divides (Neg rq, mr))
      | adjustcoeff (l, NOT (Divides (Add (rr, rs), mr))) =
        NOT (Divides (Add (rr, rs), mr))
      | adjustcoeff (l, NOT (Divides (Sub (rt, ru), mr))) =
        NOT (Divides (Sub (rt, ru), mr))
      | adjustcoeff (l, NOT (Divides (Mult (rv, rw), mr))) =
        NOT (Divides (Mult (rv, rw), mr))
      | adjustcoeff (l, NOT T) = NOT T
      | adjustcoeff (l, NOT F) = NOT F
      | adjustcoeff (l, NOT (NOT ms)) = NOT (NOT ms)
      | adjustcoeff (l, NOT (And (mt, mu))) = NOT (And (mt, mu))
      | adjustcoeff (l, NOT (Or (mv, mw))) = NOT (Or (mv, mw))
      | adjustcoeff (l, NOT (Imp (mx, my))) = NOT (Imp (mx, my))
      | adjustcoeff (l, NOT (Equ (mz, na))) = NOT (Equ (mz, na))
      | adjustcoeff (l, NOT (QAll nb)) = NOT (QAll nb)
      | adjustcoeff (l, NOT (QEx nc)) = NOT (QEx nc)
      | adjustcoeff (l, Imp (an, ao)) = Imp (an, ao)
      | adjustcoeff (l, Equ (ap, aq)) = Equ (ap, aq)
      | adjustcoeff (l, QAll ar) = QAll ar
      | adjustcoeff (l, QEx as') = QEx as';

    fun formlcm (Le (Add (Mult (Cst c, Var 0), r), Cst i)) = abs c
      | formlcm (Eq (Add (Mult (Cst c, Var 0), r), Cst i)) = abs c
      | formlcm (NOT p) = formlcm p
      | formlcm (And (p, q)) = ilcm (formlcm p) (formlcm q)
      | formlcm (Or (p, q)) = ilcm (formlcm p) (formlcm q)
      | formlcm (Lt (u, v)) = 1
      | formlcm (Gt (w, x)) = 1
      | formlcm (Le (Cst bo, z)) = 1
      | formlcm (Le (Var bp, z)) = 1
      | formlcm (Le (Neg bq, z)) = 1
      | formlcm (Le (Add (Cst cg, bs), z)) = 1
      | formlcm (Le (Add (Var ch, bs), z)) = 1
      | formlcm (Le (Add (Neg ci, bs), z)) = 1
      | formlcm (Le (Add (Add (cj, ck), bs), z)) = 1
      | formlcm (Le (Add (Sub (cl, cm), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Cst dq), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var 0), bs), Var el)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var 0), bs), Neg em)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var 0), bs), Add (en, eo))) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var 0), bs), Sub (ep, eq))) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var 0), bs), Mult (er, es))) = 1
      | formlcm (Le (Add (Mult (Cst cy, Var ei ), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Neg ds), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Add (dt, du)), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Sub (dv, dw)), bs), z)) = 1
      | formlcm (Le (Add (Mult (Cst cy, Mult (dx, dy)), bs), z)) = 1
      | formlcm (Le (Add (Mult (Var cz, co), bs), z)) = 1
      | formlcm (Le (Add (Mult (Neg da, co), bs), z)) = 1
      | formlcm (Le (Add (Mult (Add (db, dc), co), bs), z)) = 1
      | formlcm (Le (Add (Mult (Sub (dd, de), co), bs), z)) = 1
      | formlcm (Le (Add (Mult (Mult (df, dg), co), bs), z)) = 1
      | formlcm (Le (Sub (bt, bu), z)) = 1
      | formlcm (Le (Mult (bv, bw), z)) = 1
      | formlcm (Ge (aa, ab)) = 1
      | formlcm (Eq (Cst fc, ad)) = 1
      | formlcm (Eq (Var fd, ad)) = 1
      | formlcm (Eq (Neg fe, ad)) = 1
      | formlcm (Eq (Add (Cst fu, fg), ad)) = 1
      | formlcm (Eq (Add (Var fv, fg), ad)) = 1
      | formlcm (Eq (Add (Neg fw, fg), ad)) = 1
      | formlcm (Eq (Add (Add (fx, fy), fg), ad)) = 1
      | formlcm (Eq (Add (Sub (fz, ga), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Cst he), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var 0), fg), Var hz)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var 0), fg), Neg ia)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var 0), fg), Add (ib, ic))) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var 0), fg), Sub (id, ie))) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var 0), fg), Mult (if', ig))) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Var hw), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Neg hg), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Add (hh, hi)), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Sub (hj, hk)), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Cst gm, Mult (hl, hm)), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Var gn, gc), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Neg go, gc), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Add (gp, gq), gc), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Sub (gr, gs), gc), fg), ad)) = 1
      | formlcm (Eq (Add (Mult (Mult (gt, gu), gc), fg), ad)) = 1
      | formlcm (Eq (Sub (fh, fi), ad)) = 1
      | formlcm (Eq (Mult (fj, fk), ad)) = 1
      | formlcm (Divides (Cst iq, Cst ji)) = 1
      | formlcm (Divides (Cst iq, Var jj)) = 1
      | formlcm (Divides (Cst iq, Neg jk)) = 1
      | formlcm (Divides (Cst iq, Add (Cst ka, jm))) = 1
      | formlcm (Divides (Cst iq, Add (Var kb, jm))) = 1
      | formlcm (Divides (Cst iq, Add (Neg kc, jm))) = 1
      | formlcm (Divides (Cst iq, Add (Add (kd, ke), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Sub (kf, kg), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Cst lk), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Var mc), jm))) =
        (if (mc = 0) then abs ks else 1)
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Neg lm), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Add (ln, lo)), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Sub (lp, lq)), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Cst ks, Mult (lr, ls)), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Var kt, ki), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Neg ku, ki), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Add (kv, kw), ki), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Sub (kx, ky), ki), jm))) = 1
      | formlcm (Divides (Cst iq, Add (Mult (Mult (kz, la), ki), jm))) = 1
      | formlcm (Divides (Cst iq, Sub (jn, jo))) = 1
      | formlcm (Divides (Cst iq, Mult (jp, jq))) = 1
      | formlcm (Divides (Var ir, af)) = 1
      | formlcm (Divides (Neg is, af)) = 1
      | formlcm (Divides (Add (it, iu), af)) = 1
      | formlcm (Divides (Sub (iv, iw), af)) = 1
      | formlcm (Divides (Mult (ix, iy), af)) = 1
      | formlcm T = 1
      | formlcm F = 1
      | formlcm (Imp (al, am)) = 1
      | formlcm (Equ (an, ao)) = 1
      | formlcm (QAll ap) = 1
      | formlcm (QEx aq) = 1;

    fun unitycoeff p =
      let val l = formlcm p; val p' = adjustcoeff (l, p)
      in (if (l = 1) then p'
           else And (Divides (Cst l, Add (Mult (Cst 1, Var 0), Cst 0)), p'))
      end;

    fun unify p =
      let val q = unitycoeff p; val B = list_set (bset q); val A = list_set (aset q)
      in (if op_60_61_def0 (size_def1 B) (size_def1 A) then (q, B)
           else (mirror q, map lin_neg A))
      end;

    fun cooper p =
      lift_un (fn q => decrvars (explode_minf (unify q))) (linform (nnf p));

    fun pa p = lift_un psimpl (qelim (cooper, p));

    val test = pa;

    end;