Termination of the given JBC could be proven:

0 JBC
↳1 JBC2FIG (⇐)
↳2 FIGraph
↳3 FIGtoITRSProof (⇐)
↳4 AND
    ↳5 ITRS
        ↳6 ITRStoIDPProof (⇔)
        ↳7 IDP
        ↳8 UsableRulesProof (⇔)
        ↳9 IDP
        ↳10 IDPNonInfProof (⇐)
        ↳11 AND
            ↳12 IDP
                ↳13 IDependencyGraphProof (⇔)
                ↳14 IDP
                ↳15 IDPNonInfProof (⇐)
                ↳16 AND
                    ↳17 IDP
                        ↳18 IDependencyGraphProof (⇔)
                        ↳19 TRUE
                    ↳20 IDP
                        ↳21 IDependencyGraphProof (⇔)
                        ↳22 TRUE
            ↳23 IDP
                ↳24 IDependencyGraphProof (⇔)
                ↳25 TRUE
    ↳26 ITRS
        ↳27 ITRStoIDPProof (⇔)
        ↳28 IDP
        ↳29 UsableRulesProof (⇔)
        ↳30 IDP
        ↳31 IDPNonInfProof (⇐)
        ↳32 AND
            ↳33 IDP
                ↳34 IDependencyGraphProof (⇔)
                ↳35 TRUE
            ↳36 IDP
                ↳37 IDependencyGraphProof (⇔)
                ↳38 TRUE
    ↳39 ITRS
        ↳40 ITRStoIDPProof (⇔)
        ↳41 IDP
        ↳42 UsableRulesProof (⇔)
        ↳43 IDP
        ↳44 IDPNonInfProof (⇐)
        ↳45 AND
            ↳46 IDP
                ↳47 IDependencyGraphProof (⇔)
                ↳48 TRUE
            ↳49 IDP
                ↳50 IDependencyGraphProof (⇔)
                ↳51 TRUE
    ↳52 ITRS
        ↳53 ITRStoIDPProof (⇔)
        ↳54 IDP
        ↳55 UsableRulesProof (⇔)
        ↳56 IDP
        ↳57 IDPNonInfProof (⇐)
        ↳58 IDP
        ↳59 IDependencyGraphProof (⇔)
        ↳60 TRUE
    ↳61 ITRS
        ↳62 ITRStoIDPProof (⇔)
        ↳63 IDP
        ↳64 UsableRulesProof (⇔)
        ↳65 IDP
        ↳66 IDPNonInfProof (⇐)
        ↳67 AND
            ↳68 IDP
                ↳69 IDependencyGraphProof (⇔)
                ↳70 TRUE
            ↳71 IDP
                ↳72 IDependencyGraphProof (⇔)
                ↳73 TRUE
    ↳74 ITRS
        ↳75 ITRStoIDPProof (⇔)
        ↳76 IDP
        ↳77 UsableRulesProof (⇔)
        ↳78 IDP
        ↳79 IDPNonInfProof (⇐)
        ↳80 IDP
        ↳81 IDependencyGraphProof (⇔)
        ↳82 TRUE
    ↳83 ITRS
        ↳84 ITRStoIDPProof (⇔)
        ↳85 IDP
        ↳86 UsableRulesProof (⇔)
        ↳87 IDP
        ↳88 IDPNonInfProof (⇐)
        ↳89 AND
            ↳90 IDP
                ↳91 IDependencyGraphProof (⇔)
                ↳92 TRUE
            ↳93 IDP
                ↳94 IDependencyGraphProof (⇔)
                ↳95 TRUE
    ↳96 ITRS
        ↳97 ITRStoIDPProof (⇔)
        ↳98 IDP
        ↳99 UsableRulesProof (⇔)
        ↳100 IDP
        ↳101 IDPNonInfProof (⇐)
        ↳102 IDP
        ↳103 IDependencyGraphProof (⇔)
        ↳104 TRUE
    ↳105 ITRS
        ↳106 ITRStoIDPProof (⇔)
        ↳107 IDP
        ↳108 UsableRulesProof (⇔)
        ↳109 IDP
        ↳110 IDPNonInfProof (⇐)
        ↳111 IDP
        ↳112 IDependencyGraphProof (⇔)
        ↳113 TRUE

(0) Obligation:

JBC Problem based on JBC Program:
Manifest-Version: 1.0 Created-By: 1.6.0_16 (Sun Microsystems Inc.) Main-Class: GCD 
public class GCD {
  public static int mod(int a, int b) {
    if(a <= 0 || b <= 0)
      return 0;
    if (a == b) {
      return 0;
    }
    while(a>b) {
      a -= b;
    }
    return a;
  }

  public static int gcd(int a, int b) {
    int tmp;
    while(b != 0) {
      tmp = b;
      b = mod(a, b);
      a = tmp;
    }
    return a;
  }

  public static void main(String[] args) {
    Random.args = args;
    int x = Random.random();
    int y = Random.random();
    gcd(x, y);
  }
}


public class Random {
  static String[] args;
  static int index = 0;

  public static int random() {
    String string = args[index];
    index++;
    return string.length();
  }
}


(1) JBC2FIG (SOUND transformation)

Constructed FIGraph.

(2) Obligation:

FIGraph based on JBC Program:
Graph of 572 nodes with 9 SCCs.

(3) FIGtoITRSProof (SOUND transformation)

Transformed FIGraph to ITRS rules

(4) Complex Obligation (AND)

(5) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP2522(i322, i1739) → Cond_JMP2522(i322 > 0 && i322 < i1739 && !(i1739 = 0), i322, i1739)
Cond_JMP2522(TRUE, i322, i1739) → JMP2522(i1739, i322)
JMP4637(i1739, i1739, i1739, i2851, i1739) → Cond_JMP4637(i1739 > 0 && i2851 <= i1739, i1739, i1739, i1739, i2851, i1739)
Cond_JMP4637(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP2522(i1739, i2851)
JMP2522(i322, i1739) → Cond_JMP25221(i1739 > 0 && i322 - i1739 <= i1739 && i322 > i1739, i322, i1739)
Cond_JMP25221(TRUE, i322, i1739) → JMP2522(i1739, i322 - i1739)
JMP2522(i1739, i1739) → Cond_JMP25222(i1739 > 0, i1739, i1739)
Cond_JMP25222(TRUE, i1739, i1739) → JMP2522(i1739, 0)
JMP4637(i1739, i1739, i1739, i2851, i1739) → Cond_JMP46371(i1739 > 0 && i2851 > i1739, i1739, i1739, i1739, i2851, i1739)
Cond_JMP46371(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP4637(i1739, i1739, i1739, i2851 - i1739, i1739)
JMP2522(i322, i1739) → Cond_JMP25223(i1739 > 0 && i322 - i1739 > i1739 && i322 > i1739, i322, i1739)
Cond_JMP25223(TRUE, i322, i1739) → JMP4637(i1739, i1739, i1739, i322 - i1739 - i1739, i1739)
The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(6) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(7) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP2522(i322, i1739) → Cond_JMP2522(i322 > 0 && i322 < i1739 && !(i1739 = 0), i322, i1739)
Cond_JMP2522(TRUE, i322, i1739) → JMP2522(i1739, i322)
JMP4637(i1739, i1739, i1739, i2851, i1739) → Cond_JMP4637(i1739 > 0 && i2851 <= i1739, i1739, i1739, i1739, i2851, i1739)
Cond_JMP4637(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP2522(i1739, i2851)
JMP2522(i322, i1739) → Cond_JMP25221(i1739 > 0 && i322 - i1739 <= i1739 && i322 > i1739, i322, i1739)
Cond_JMP25221(TRUE, i322, i1739) → JMP2522(i1739, i322 - i1739)
JMP2522(i1739, i1739) → Cond_JMP25222(i1739 > 0, i1739, i1739)
Cond_JMP25222(TRUE, i1739, i1739) → JMP2522(i1739, 0)
JMP4637(i1739, i1739, i1739, i2851, i1739) → Cond_JMP46371(i1739 > 0 && i2851 > i1739, i1739, i1739, i1739, i2851, i1739)
Cond_JMP46371(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP4637(i1739, i1739, i1739, i2851 - i1739, i1739)
JMP2522(i322, i1739) → Cond_JMP25223(i1739 > 0 && i322 - i1739 > i1739 && i322 > i1739, i322, i1739)
Cond_JMP25223(TRUE, i322, i1739) → JMP4637(i1739, i1739, i1739, i322 - i1739 - i1739, i1739)

The integer pair graph contains the following rules and edges:
(0): JMP2522'(i322[0], i1739[0]) → COND_JMP2522(i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0), i322[0], i1739[0])
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
(2): JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(i1739[2] > 0 && i2851[2] <= i1739[2], i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])
(3): COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3])
(4): JMP2522'(i322[4], i1739[4]) → COND_JMP25221(i1739[4] > 0 && i322[4] - i1739[4] <= i1739[4] && i322[4] > i1739[4], i322[4], i1739[4])
(5): COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], i322[5] - i1739[5])
(6): JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(i1739[6] > 0, i1739[6], i1739[6])
(7): COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0)
(8): JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(i1739[8] > 0 && i2851[8] > i1739[8], i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])
(9): COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], i2851[9] - i1739[9], i1739[9])
(10): JMP2522'(i322[10], i1739[10]) → COND_JMP25223(i1739[10] > 0 && i322[10] - i1739[10] > i1739[10] && i322[10] > i1739[10], i322[10], i1739[10])
(11): COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], i322[11] - i1739[11] - i1739[11], i1739[11])

(0) -> (1), if ((i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0) →* TRUE)∧(i1739[0] →* i1739[1])∧(i322[0] →* i322[1]))


(1) -> (0), if ((i322[1] →* i1739[0])∧(i1739[1] →* i322[0]))


(1) -> (4), if ((i322[1] →* i1739[4])∧(i1739[1] →* i322[4]))


(1) -> (6), if ((i322[1] →* i1739[6])∧(i1739[1] →* i1739[6]))


(1) -> (10), if ((i322[1] →* i1739[10])∧(i1739[1] →* i322[10]))


(2) -> (3), if ((i1739[2] > 0 && i2851[2] <= i1739[2] →* TRUE)∧(i1739[2] →* i1739[3])∧(i2851[2] →* i2851[3]))


(3) -> (0), if ((i2851[3] →* i1739[0])∧(i1739[3] →* i322[0]))


(3) -> (4), if ((i2851[3] →* i1739[4])∧(i1739[3] →* i322[4]))


(3) -> (6), if ((i2851[3] →* i1739[6])∧(i1739[3] →* i1739[6]))


(3) -> (10), if ((i2851[3] →* i1739[10])∧(i1739[3] →* i322[10]))


(4) -> (5), if ((i1739[4] →* i1739[5])∧(i322[4] →* i322[5])∧(i1739[4] > 0 && i322[4] - i1739[4] <= i1739[4] && i322[4] > i1739[4] →* TRUE))


(5) -> (0), if ((i322[5] - i1739[5] →* i1739[0])∧(i1739[5] →* i322[0]))


(5) -> (4), if ((i1739[5] →* i322[4])∧(i322[5] - i1739[5] →* i1739[4]))


(5) -> (6), if ((i1739[5] →* i1739[6])∧(i322[5] - i1739[5] →* i1739[6]))


(5) -> (10), if ((i1739[5] →* i322[10])∧(i322[5] - i1739[5] →* i1739[10]))


(6) -> (7), if ((i1739[6] →* i1739[7])∧(i1739[6] > 0 →* TRUE))


(7) -> (0), if ((i1739[7] →* i322[0])∧(0 →* i1739[0]))


(7) -> (4), if ((0 →* i1739[4])∧(i1739[7] →* i322[4]))


(7) -> (6), if ((0 →* i1739[6])∧(i1739[7] →* i1739[6]))


(7) -> (10), if ((i1739[7] →* i322[10])∧(0 →* i1739[10]))


(8) -> (9), if ((i1739[8] > 0 && i2851[8] > i1739[8] →* TRUE)∧(i2851[8] →* i2851[9])∧(i1739[8] →* i1739[9]))


(9) -> (2), if ((i2851[9] - i1739[9] →* i2851[2])∧(i1739[9] →* i1739[2]))


(9) -> (8), if ((i2851[9] - i1739[9] →* i2851[8])∧(i1739[9] →* i1739[8]))


(10) -> (11), if ((i322[10] →* i322[11])∧(i1739[10] →* i1739[11])∧(i1739[10] > 0 && i322[10] - i1739[10] > i1739[10] && i322[10] > i1739[10] →* TRUE))


(11) -> (2), if ((i322[11] - i1739[11] - i1739[11] →* i2851[2])∧(i1739[11] →* i1739[2]))


(11) -> (8), if ((i1739[11] →* i1739[8])∧(i322[11] - i1739[11] - i1739[11] →* i2851[8]))



The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(8) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(9) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP2522'(i322[0], i1739[0]) → COND_JMP2522(i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0), i322[0], i1739[0])
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
(2): JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(i1739[2] > 0 && i2851[2] <= i1739[2], i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])
(3): COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3])
(4): JMP2522'(i322[4], i1739[4]) → COND_JMP25221(i1739[4] > 0 && i322[4] - i1739[4] <= i1739[4] && i322[4] > i1739[4], i322[4], i1739[4])
(5): COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], i322[5] - i1739[5])
(6): JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(i1739[6] > 0, i1739[6], i1739[6])
(7): COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0)
(8): JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(i1739[8] > 0 && i2851[8] > i1739[8], i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])
(9): COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], i2851[9] - i1739[9], i1739[9])
(10): JMP2522'(i322[10], i1739[10]) → COND_JMP25223(i1739[10] > 0 && i322[10] - i1739[10] > i1739[10] && i322[10] > i1739[10], i322[10], i1739[10])
(11): COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], i322[11] - i1739[11] - i1739[11], i1739[11])

(0) -> (1), if ((i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0) →* TRUE)∧(i1739[0] →* i1739[1])∧(i322[0] →* i322[1]))


(1) -> (0), if ((i322[1] →* i1739[0])∧(i1739[1] →* i322[0]))


(1) -> (4), if ((i322[1] →* i1739[4])∧(i1739[1] →* i322[4]))


(1) -> (6), if ((i322[1] →* i1739[6])∧(i1739[1] →* i1739[6]))


(1) -> (10), if ((i322[1] →* i1739[10])∧(i1739[1] →* i322[10]))


(2) -> (3), if ((i1739[2] > 0 && i2851[2] <= i1739[2] →* TRUE)∧(i1739[2] →* i1739[3])∧(i2851[2] →* i2851[3]))


(3) -> (0), if ((i2851[3] →* i1739[0])∧(i1739[3] →* i322[0]))


(3) -> (4), if ((i2851[3] →* i1739[4])∧(i1739[3] →* i322[4]))


(3) -> (6), if ((i2851[3] →* i1739[6])∧(i1739[3] →* i1739[6]))


(3) -> (10), if ((i2851[3] →* i1739[10])∧(i1739[3] →* i322[10]))


(4) -> (5), if ((i1739[4] →* i1739[5])∧(i322[4] →* i322[5])∧(i1739[4] > 0 && i322[4] - i1739[4] <= i1739[4] && i322[4] > i1739[4] →* TRUE))


(5) -> (0), if ((i322[5] - i1739[5] →* i1739[0])∧(i1739[5] →* i322[0]))


(5) -> (4), if ((i1739[5] →* i322[4])∧(i322[5] - i1739[5] →* i1739[4]))


(5) -> (6), if ((i1739[5] →* i1739[6])∧(i322[5] - i1739[5] →* i1739[6]))


(5) -> (10), if ((i1739[5] →* i322[10])∧(i322[5] - i1739[5] →* i1739[10]))


(6) -> (7), if ((i1739[6] →* i1739[7])∧(i1739[6] > 0 →* TRUE))


(7) -> (0), if ((i1739[7] →* i322[0])∧(0 →* i1739[0]))


(7) -> (4), if ((0 →* i1739[4])∧(i1739[7] →* i322[4]))


(7) -> (6), if ((0 →* i1739[6])∧(i1739[7] →* i1739[6]))


(7) -> (10), if ((i1739[7] →* i322[10])∧(0 →* i1739[10]))


(8) -> (9), if ((i1739[8] > 0 && i2851[8] > i1739[8] →* TRUE)∧(i2851[8] →* i2851[9])∧(i1739[8] →* i1739[9]))


(9) -> (2), if ((i2851[9] - i1739[9] →* i2851[2])∧(i1739[9] →* i1739[2]))


(9) -> (8), if ((i2851[9] - i1739[9] →* i2851[8])∧(i1739[9] →* i1739[8]))


(10) -> (11), if ((i322[10] →* i322[11])∧(i1739[10] →* i1739[11])∧(i1739[10] > 0 && i322[10] - i1739[10] > i1739[10] && i322[10] > i1739[10] →* TRUE))


(11) -> (2), if ((i322[11] - i1739[11] - i1739[11] →* i2851[2])∧(i1739[11] →* i1739[2]))


(11) -> (8), if ((i1739[11] →* i1739[8])∧(i322[11] - i1739[11] - i1739[11] →* i2851[8]))



The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(10) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP2522'(i322, i1739) → COND_JMP2522(&&(&&(>(i322, 0), <(i322, i1739)), !(=(i1739, 0))), i322, i1739) the following chains were created:
  • We consider the chain JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]), COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]) which results in the following constraint:

    (1)    (&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0)))=TRUE∧i1739[0]=i1739[1]∧i322[0]=i322[1] ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (2)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧<(i1739[0], 0)=TRUE ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))


    (3)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧>(i1739[0], 0)=TRUE ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (4)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (3) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (5)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (4) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (6)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (5) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (7)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (6) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (8)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (7) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (9)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We solved constraint (8) using rule (IDP_SMT_SPLIT).We simplified constraint (9) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (10)    (i322[0] ≥ 0∧i1739[0] + [-2] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48 + bni_48] + [bni_48]i1739[0] + [bni_48]i322[0] ≥ 0∧[(-1)bso_49] ≥ 0)



    We simplified constraint (10) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (11)    (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48 + (3)bni_48] + [(2)bni_48]i322[0] + [bni_48]i1739[0] ≥ 0∧[(-1)bso_49] ≥ 0)







For Pair COND_JMP2522(TRUE, i322, i1739) → JMP2522'(i1739, i322) the following chains were created:
  • We consider the chain COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]) which results in the following constraint:

    (12)    (i322[1]=i1739[0]∧i1739[1]=i322[0] ⇒ COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (12) using rule (IV) which results in the following new constraint:

    (13)    (COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (13) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (14)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (14) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (15)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (15) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (16)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (16) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (17)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)



  • We consider the chain COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4]) which results in the following constraint:

    (18)    (i322[1]=i1739[4]∧i1739[1]=i322[4] ⇒ COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (18) using rule (IV) which results in the following new constraint:

    (19)    (COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (19) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (20)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (20) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (21)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (21) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (22)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (22) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (23)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)



  • We consider the chain COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6]) which results in the following constraint:

    (24)    (i322[1]=i1739[6]∧i1739[1]=i1739[6] ⇒ COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (24) using rule (III) which results in the following new constraint:

    (25)    (COND_JMP2522(TRUE, i1739[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i1739[1], i1739[1])≥JMP2522'(i1739[1], i1739[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (25) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (26)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (26) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (27)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (27) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (28)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (28) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (29)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧[(-1)bso_51] ≥ 0)



  • We consider the chain COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10]) which results in the following constraint:

    (30)    (i322[1]=i1739[10]∧i1739[1]=i322[10] ⇒ COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (30) using rule (IV) which results in the following new constraint:

    (31)    (COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (31) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (32)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (32) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (33)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (33) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (34)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bso_51] ≥ 0)



    We simplified constraint (34) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (35)    ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)







For Pair JMP4637'(i1739, i1739, i1739, i2851, i1739) → COND_JMP4637(&&(>(i1739, 0), <=(i2851, i1739)), i1739, i1739, i1739, i2851, i1739) the following chains were created:
  • We consider the chain JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]), COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3]) which results in the following constraint:

    (36)    (&&(>(i1739[2], 0), <=(i2851[2], i1739[2]))=TRUE∧i1739[2]=i1739[3]∧i2851[2]=i2851[3] ⇒ JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])≥NonInfC∧JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])≥COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])∧(UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥))



    We simplified constraint (36) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (37)    (>(i1739[2], 0)=TRUE∧<=(i2851[2], i1739[2])=TRUE ⇒ JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])≥NonInfC∧JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])≥COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])∧(UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥))



    We simplified constraint (37) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (38)    (i1739[2] + [-1] ≥ 0∧i1739[2] + [-1]i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)



    We simplified constraint (38) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (39)    (i1739[2] + [-1] ≥ 0∧i1739[2] + [-1]i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)



    We simplified constraint (39) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (40)    (i1739[2] + [-1] ≥ 0∧i1739[2] + [-1]i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)



    We simplified constraint (40) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (41)    (i1739[2] ≥ 0∧[1] + i1739[2] + [-1]i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52 + bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)



    We simplified constraint (41) using rule (IDP_SMT_SPLIT) which results in the following new constraints:

    (42)    (i1739[2] ≥ 0∧[1] + i1739[2] + [-1]i2851[2] ≥ 0∧i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52 + bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)


    (43)    (i1739[2] ≥ 0∧[1] + i1739[2] + i2851[2] ≥ 0∧i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52 + bni_52] + [bni_52]i1739[2] + [(-1)bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)







For Pair COND_JMP4637(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP2522'(i1739, i2851) the following chains were created:
  • We consider the chain COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3]), JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]) which results in the following constraint:

    (44)    (i2851[3]=i1739[0]∧i1739[3]=i322[0] ⇒ COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (44) using rule (IV) which results in the following new constraint:

    (45)    (COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (45) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (46)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (46) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (47)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (47) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (48)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (48) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (49)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)



  • We consider the chain COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3]), JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4]) which results in the following constraint:

    (50)    (i2851[3]=i1739[4]∧i1739[3]=i322[4] ⇒ COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (50) using rule (IV) which results in the following new constraint:

    (51)    (COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (51) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (52)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (52) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (53)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (53) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (54)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (54) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (55)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)



  • We consider the chain COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3]), JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6]) which results in the following constraint:

    (56)    (i2851[3]=i1739[6]∧i1739[3]=i1739[6] ⇒ COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (56) using rule (III) which results in the following new constraint:

    (57)    (COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i1739[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i1739[3], i1739[3])≥JMP2522'(i1739[3], i1739[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (57) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (58)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (58) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (59)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (59) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (60)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (60) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (61)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧[(-1)bso_55] ≥ 0)



  • We consider the chain COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3]), JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10]) which results in the following constraint:

    (62)    (i2851[3]=i1739[10]∧i1739[3]=i322[10] ⇒ COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (62) using rule (IV) which results in the following new constraint:

    (63)    (COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥NonInfC∧COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3])≥JMP2522'(i1739[3], i2851[3])∧(UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥))



    We simplified constraint (63) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (64)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (64) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (65)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (65) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (66)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧[(-1)bso_55] ≥ 0)



    We simplified constraint (66) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (67)    ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)







For Pair JMP2522'(i322, i1739) → COND_JMP25221(&&(&&(>(i1739, 0), <=(-(i322, i1739), i1739)), >(i322, i1739)), i322, i1739) the following chains were created:
  • We consider the chain JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4]), COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], -(i322[5], i1739[5])) which results in the following constraint:

    (68)    (i1739[4]=i1739[5]∧i322[4]=i322[5]∧&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4]))=TRUE ⇒ JMP2522'(i322[4], i1739[4])≥NonInfC∧JMP2522'(i322[4], i1739[4])≥COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])∧(UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥))



    We simplified constraint (68) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (69)    (>(i322[4], i1739[4])=TRUE∧>(i1739[4], 0)=TRUE∧<=(-(i322[4], i1739[4]), i1739[4])=TRUE ⇒ JMP2522'(i322[4], i1739[4])≥NonInfC∧JMP2522'(i322[4], i1739[4])≥COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])∧(UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥))



    We simplified constraint (69) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (70)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56] + [bni_56]i1739[4] + [bni_56]i322[4] ≥ 0∧[(-1)bso_57] + [-1]i1739[4] + i322[4] ≥ 0)



    We simplified constraint (70) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (71)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56] + [bni_56]i1739[4] + [bni_56]i322[4] ≥ 0∧[(-1)bso_57] + [-1]i1739[4] + i322[4] ≥ 0)



    We simplified constraint (71) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (72)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56] + [bni_56]i1739[4] + [bni_56]i322[4] ≥ 0∧[(-1)bso_57] + [-1]i1739[4] + i322[4] ≥ 0)



    We simplified constraint (72) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (73)    (i322[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧i1739[4] + [-1] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56 + bni_56] + [(2)bni_56]i1739[4] + [bni_56]i322[4] ≥ 0∧[1 + (-1)bso_57] + i322[4] ≥ 0)



    We simplified constraint (73) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (74)    (i322[4] ≥ 0∧i1739[4] ≥ 0∧i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56 + (3)bni_56] + [(2)bni_56]i1739[4] + [bni_56]i322[4] ≥ 0∧[1 + (-1)bso_57] + i322[4] ≥ 0)



    We simplified constraint (74) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (75)    (i322[4] ≥ 0∧i322[4] + i1739[4] ≥ 0∧i1739[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56 + (3)bni_56] + [(3)bni_56]i322[4] + [(2)bni_56]i1739[4] ≥ 0∧[1 + (-1)bso_57] + i322[4] ≥ 0)







For Pair COND_JMP25221(TRUE, i322, i1739) → JMP2522'(i1739, -(i322, i1739)) the following chains were created:
  • We consider the chain JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4]), COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], -(i322[5], i1739[5])) which results in the following constraint:

    (76)    (i1739[4]=i1739[5]∧i322[4]=i322[5]∧&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4]))=TRUE ⇒ COND_JMP25221(TRUE, i322[5], i1739[5])≥NonInfC∧COND_JMP25221(TRUE, i322[5], i1739[5])≥JMP2522'(i1739[5], -(i322[5], i1739[5]))∧(UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥))



    We simplified constraint (76) using rules (III), (IDP_BOOLEAN) which results in the following new constraint:

    (77)    (>(i322[4], i1739[4])=TRUE∧>(i1739[4], 0)=TRUE∧<=(-(i322[4], i1739[4]), i1739[4])=TRUE ⇒ COND_JMP25221(TRUE, i322[4], i1739[4])≥NonInfC∧COND_JMP25221(TRUE, i322[4], i1739[4])≥JMP2522'(i1739[4], -(i322[4], i1739[4]))∧(UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥))



    We simplified constraint (77) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (78)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + [2]i1739[4] + [-1]i322[4] ≥ 0)



    We simplified constraint (78) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (79)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + [2]i1739[4] + [-1]i322[4] ≥ 0)



    We simplified constraint (79) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (80)    (i322[4] + [-1] + [-1]i1739[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧[2]i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + [2]i1739[4] + [-1]i322[4] ≥ 0)



    We simplified constraint (80) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (81)    (i322[4] ≥ 0∧i1739[4] + [-1] ≥ 0∧i1739[4] + [-1] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58] + [(2)bni_58]i1739[4] ≥ 0∧[-1 + (-1)bso_59] + i1739[4] + [-1]i322[4] ≥ 0)



    We simplified constraint (81) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (82)    (i322[4] ≥ 0∧i1739[4] ≥ 0∧i1739[4] + [-1]i322[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58 + (2)bni_58] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + i1739[4] + [-1]i322[4] ≥ 0)



    We simplified constraint (82) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (83)    (i322[4] ≥ 0∧i322[4] + i1739[4] ≥ 0∧i1739[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58 + (2)bni_58] + [(2)bni_58]i322[4] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + i1739[4] ≥ 0)







For Pair JMP2522'(i1739, i1739) → COND_JMP25222(>(i1739, 0), i1739, i1739) the following chains were created:
  • We consider the chain JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6]), COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0) which results in the following constraint:

    (84)    (i1739[6]=i1739[7]∧>(i1739[6], 0)=TRUE ⇒ JMP2522'(i1739[6], i1739[6])≥NonInfC∧JMP2522'(i1739[6], i1739[6])≥COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])∧(UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥))



    We simplified constraint (84) using rule (IV) which results in the following new constraint:

    (85)    (>(i1739[6], 0)=TRUE ⇒ JMP2522'(i1739[6], i1739[6])≥NonInfC∧JMP2522'(i1739[6], i1739[6])≥COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])∧(UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥))



    We simplified constraint (85) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (86)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥)∧[(-1)Bound*bni_60] + [(2)bni_60]i1739[6] ≥ 0∧[1 + (-1)bso_61] ≥ 0)



    We simplified constraint (86) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (87)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥)∧[(-1)Bound*bni_60] + [(2)bni_60]i1739[6] ≥ 0∧[1 + (-1)bso_61] ≥ 0)



    We simplified constraint (87) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (88)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥)∧[(-1)Bound*bni_60] + [(2)bni_60]i1739[6] ≥ 0∧[1 + (-1)bso_61] ≥ 0)



    We simplified constraint (88) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (89)    (i1739[6] ≥ 0 ⇒ (UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥)∧[(-1)Bound*bni_60 + (2)bni_60] + [(2)bni_60]i1739[6] ≥ 0∧[1 + (-1)bso_61] ≥ 0)







For Pair COND_JMP25222(TRUE, i1739, i1739) → JMP2522'(i1739, 0) the following chains were created:
  • We consider the chain JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6]), COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0) which results in the following constraint:

    (90)    (i1739[6]=i1739[7]∧>(i1739[6], 0)=TRUE ⇒ COND_JMP25222(TRUE, i1739[7], i1739[7])≥NonInfC∧COND_JMP25222(TRUE, i1739[7], i1739[7])≥JMP2522'(i1739[7], 0)∧(UIncreasing(JMP2522'(i1739[7], 0)), ≥))



    We simplified constraint (90) using rule (III) which results in the following new constraint:

    (91)    (>(i1739[6], 0)=TRUE ⇒ COND_JMP25222(TRUE, i1739[6], i1739[6])≥NonInfC∧COND_JMP25222(TRUE, i1739[6], i1739[6])≥JMP2522'(i1739[6], 0)∧(UIncreasing(JMP2522'(i1739[7], 0)), ≥))



    We simplified constraint (91) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (92)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[7], 0)), ≥)∧[(-1)bni_62 + (-1)Bound*bni_62] + [(2)bni_62]i1739[6] ≥ 0∧[-1 + (-1)bso_63] + i1739[6] ≥ 0)



    We simplified constraint (92) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (93)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[7], 0)), ≥)∧[(-1)bni_62 + (-1)Bound*bni_62] + [(2)bni_62]i1739[6] ≥ 0∧[-1 + (-1)bso_63] + i1739[6] ≥ 0)



    We simplified constraint (93) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (94)    (i1739[6] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[7], 0)), ≥)∧[(-1)bni_62 + (-1)Bound*bni_62] + [(2)bni_62]i1739[6] ≥ 0∧[-1 + (-1)bso_63] + i1739[6] ≥ 0)



    We simplified constraint (94) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (95)    (i1739[6] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[7], 0)), ≥)∧[bni_62 + (-1)Bound*bni_62] + [(2)bni_62]i1739[6] ≥ 0∧[(-1)bso_63] + i1739[6] ≥ 0)







For Pair JMP4637'(i1739, i1739, i1739, i2851, i1739) → COND_JMP46371(&&(>(i1739, 0), >(i2851, i1739)), i1739, i1739, i1739, i2851, i1739) the following chains were created:
  • We consider the chain JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]), COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9]) which results in the following constraint:

    (96)    (&&(>(i1739[8], 0), >(i2851[8], i1739[8]))=TRUE∧i2851[8]=i2851[9]∧i1739[8]=i1739[9] ⇒ JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥NonInfC∧JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])∧(UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥))



    We simplified constraint (96) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (97)    (>(i1739[8], 0)=TRUE∧>(i2851[8], i1739[8])=TRUE ⇒ JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥NonInfC∧JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])∧(UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥))



    We simplified constraint (97) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (98)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64] + [bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[-1 + (-1)bso_65] + i1739[8] ≥ 0)



    We simplified constraint (98) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (99)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64] + [bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[-1 + (-1)bso_65] + i1739[8] ≥ 0)



    We simplified constraint (99) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (100)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64] + [bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[-1 + (-1)bso_65] + i1739[8] ≥ 0)



    We simplified constraint (100) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (101)    (i1739[8] ≥ 0∧i2851[8] + [-2] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64 + bni_64] + [bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[(-1)bso_65] + i1739[8] ≥ 0)



    We simplified constraint (101) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (102)    (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64 + (3)bni_64] + [(2)bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[(-1)bso_65] + i1739[8] ≥ 0)







For Pair COND_JMP46371(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP4637'(i1739, i1739, i1739, -(i2851, i1739), i1739) the following chains were created:
  • We consider the chain JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]), COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9]), JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) which results in the following constraint:

    (103)    (&&(>(i1739[8], 0), >(i2851[8], i1739[8]))=TRUE∧i2851[8]=i2851[9]∧i1739[8]=i1739[9]∧-(i2851[9], i1739[9])=i2851[2]∧i1739[9]=i1739[2] ⇒ COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9])≥NonInfC∧COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9])≥JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])∧(UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥))



    We simplified constraint (103) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (104)    (>(i1739[8], 0)=TRUE∧>(i2851[8], i1739[8])=TRUE ⇒ COND_JMP46371(TRUE, i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥NonInfC∧COND_JMP46371(TRUE, i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥JMP4637'(i1739[8], i1739[8], i1739[8], -(i2851[8], i1739[8]), i1739[8])∧(UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥))



    We simplified constraint (104) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (105)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (105) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (106)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (106) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (107)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (107) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (108)    (i1739[8] ≥ 0∧i2851[8] + [-2] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (108) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (109)    (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[(3)bni_66 + (-1)Bound*bni_66] + [bni_66]i1739[8] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



  • We consider the chain JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]), COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9]), JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) which results in the following constraint:

    (110)    (&&(>(i1739[8], 0), >(i2851[8], i1739[8]))=TRUE∧i2851[8]=i2851[9]∧i1739[8]=i1739[9]∧-(i2851[9], i1739[9])=i2851[8]1∧i1739[9]=i1739[8]1 ⇒ COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9])≥NonInfC∧COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9])≥JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])∧(UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥))



    We simplified constraint (110) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (111)    (>(i1739[8], 0)=TRUE∧>(i2851[8], i1739[8])=TRUE ⇒ COND_JMP46371(TRUE, i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥NonInfC∧COND_JMP46371(TRUE, i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])≥JMP4637'(i1739[8], i1739[8], i1739[8], -(i2851[8], i1739[8]), i1739[8])∧(UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥))



    We simplified constraint (111) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (112)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (112) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (113)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (113) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (114)    (i1739[8] + [-1] ≥ 0∧i2851[8] + [-1] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (114) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (115)    (i1739[8] ≥ 0∧i2851[8] + [-2] + [-1]i1739[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[bni_66 + (-1)Bound*bni_66] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)



    We simplified constraint (115) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (116)    (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[(3)bni_66 + (-1)Bound*bni_66] + [bni_66]i1739[8] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)







For Pair JMP2522'(i322, i1739) → COND_JMP25223(&&(&&(>(i1739, 0), >(-(i322, i1739), i1739)), >(i322, i1739)), i322, i1739) the following chains were created:
  • We consider the chain JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10]), COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11]) which results in the following constraint:

    (117)    (i322[10]=i322[11]∧i1739[10]=i1739[11]∧&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10]))=TRUE ⇒ JMP2522'(i322[10], i1739[10])≥NonInfC∧JMP2522'(i322[10], i1739[10])≥COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])∧(UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥))



    We simplified constraint (117) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (118)    (>(i322[10], i1739[10])=TRUE∧>(i1739[10], 0)=TRUE∧>(-(i322[10], i1739[10]), i1739[10])=TRUE ⇒ JMP2522'(i322[10], i1739[10])≥NonInfC∧JMP2522'(i322[10], i1739[10])≥COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])∧(UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥))



    We simplified constraint (118) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (119)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68] + [bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[(-1)bso_69] + [2]i1739[10] ≥ 0)



    We simplified constraint (119) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (120)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68] + [bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[(-1)bso_69] + [2]i1739[10] ≥ 0)



    We simplified constraint (120) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (121)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68] + [bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[(-1)bso_69] + [2]i1739[10] ≥ 0)



    We simplified constraint (121) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (122)    (i322[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧[-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68 + bni_68] + [(2)bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[(-1)bso_69] + [2]i1739[10] ≥ 0)



    We simplified constraint (122) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (123)    (i322[10] ≥ 0∧i1739[10] ≥ 0∧[-1] + [-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68 + (3)bni_68] + [(2)bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[2 + (-1)bso_69] + [2]i1739[10] ≥ 0)



    We simplified constraint (123) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (124)    ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68 + (4)bni_68] + [(3)bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[2 + (-1)bso_69] + [2]i1739[10] ≥ 0)







For Pair COND_JMP25223(TRUE, i322, i1739) → JMP4637'(i1739, i1739, i1739, -(-(i322, i1739), i1739), i1739) the following chains were created:
  • We consider the chain JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10]), COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11]), JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) which results in the following constraint:

    (125)    (i322[10]=i322[11]∧i1739[10]=i1739[11]∧&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10]))=TRUE∧-(-(i322[11], i1739[11]), i1739[11])=i2851[2]∧i1739[11]=i1739[2] ⇒ COND_JMP25223(TRUE, i322[11], i1739[11])≥NonInfC∧COND_JMP25223(TRUE, i322[11], i1739[11])≥JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])∧(UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥))



    We simplified constraint (125) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (126)    (>(i322[10], i1739[10])=TRUE∧>(i1739[10], 0)=TRUE∧>(-(i322[10], i1739[10]), i1739[10])=TRUE ⇒ COND_JMP25223(TRUE, i322[10], i1739[10])≥NonInfC∧COND_JMP25223(TRUE, i322[10], i1739[10])≥JMP4637'(i1739[10], i1739[10], i1739[10], -(-(i322[10], i1739[10]), i1739[10]), i1739[10])∧(UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥))



    We simplified constraint (126) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (127)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (127) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (128)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (128) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (129)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (129) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (130)    (i322[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧[-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + bni_70] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (130) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (131)    (i322[10] ≥ 0∧i1739[10] ≥ 0∧[-1] + [-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + bni_70] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (131) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (132)    ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + (2)bni_70] + [bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



  • We consider the chain JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10]), COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11]), JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) which results in the following constraint:

    (133)    (i322[10]=i322[11]∧i1739[10]=i1739[11]∧&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10]))=TRUE∧i1739[11]=i1739[8]∧-(-(i322[11], i1739[11]), i1739[11])=i2851[8] ⇒ COND_JMP25223(TRUE, i322[11], i1739[11])≥NonInfC∧COND_JMP25223(TRUE, i322[11], i1739[11])≥JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])∧(UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥))



    We simplified constraint (133) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (134)    (>(i322[10], i1739[10])=TRUE∧>(i1739[10], 0)=TRUE∧>(-(i322[10], i1739[10]), i1739[10])=TRUE ⇒ COND_JMP25223(TRUE, i322[10], i1739[10])≥NonInfC∧COND_JMP25223(TRUE, i322[10], i1739[10])≥JMP4637'(i1739[10], i1739[10], i1739[10], -(-(i322[10], i1739[10]), i1739[10]), i1739[10])∧(UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥))



    We simplified constraint (134) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (135)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (135) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (136)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (136) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (137)    (i322[10] + [-1] + [-1]i1739[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧i322[10] + [-1] + [-2]i1739[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70] + [(-1)bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (137) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (138)    (i322[10] ≥ 0∧i1739[10] + [-1] ≥ 0∧[-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + bni_70] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (138) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (139)    (i322[10] ≥ 0∧i1739[10] ≥ 0∧[-1] + [-1]i1739[10] + i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + bni_70] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)



    We simplified constraint (139) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (140)    ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + (2)bni_70] + [bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP2522'(i322, i1739) → COND_JMP2522(&&(&&(>(i322, 0), <(i322, i1739)), !(=(i1739, 0))), i322, i1739)
    • (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)Bound*bni_48 + (3)bni_48] + [(2)bni_48]i322[0] + [bni_48]i1739[0] ≥ 0∧[(-1)bso_49] ≥ 0)

  • COND_JMP2522(TRUE, i322, i1739) → JMP2522'(i1739, i322)
    • ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧[(-1)bso_51] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_51] ≥ 0)

  • JMP4637'(i1739, i1739, i1739, i2851, i1739) → COND_JMP4637(&&(>(i1739, 0), <=(i2851, i1739)), i1739, i1739, i1739, i2851, i1739)
    • (i1739[2] ≥ 0∧[1] + i1739[2] + [-1]i2851[2] ≥ 0∧i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52 + bni_52] + [bni_52]i1739[2] + [bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)
    • (i1739[2] ≥ 0∧[1] + i1739[2] + i2851[2] ≥ 0∧i2851[2] ≥ 0 ⇒ (UIncreasing(COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])), ≥)∧[(-1)Bound*bni_52 + bni_52] + [bni_52]i1739[2] + [(-1)bni_52]i2851[2] ≥ 0∧[(-1)bso_53] ≥ 0)

  • COND_JMP4637(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP2522'(i1739, i2851)
    • ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧[(-1)bso_55] ≥ 0)
    • ((UIncreasing(JMP2522'(i1739[3], i2851[3])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_55] ≥ 0)

  • JMP2522'(i322, i1739) → COND_JMP25221(&&(&&(>(i1739, 0), <=(-(i322, i1739), i1739)), >(i322, i1739)), i322, i1739)
    • (i322[4] ≥ 0∧i322[4] + i1739[4] ≥ 0∧i1739[4] ≥ 0 ⇒ (UIncreasing(COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])), ≥)∧[(-1)Bound*bni_56 + (3)bni_56] + [(3)bni_56]i322[4] + [(2)bni_56]i1739[4] ≥ 0∧[1 + (-1)bso_57] + i322[4] ≥ 0)

  • COND_JMP25221(TRUE, i322, i1739) → JMP2522'(i1739, -(i322, i1739))
    • (i322[4] ≥ 0∧i322[4] + i1739[4] ≥ 0∧i1739[4] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[5], -(i322[5], i1739[5]))), ≥)∧[(-1)Bound*bni_58 + (2)bni_58] + [(2)bni_58]i322[4] + [(2)bni_58]i1739[4] ≥ 0∧[(-1)bso_59] + i1739[4] ≥ 0)

  • JMP2522'(i1739, i1739) → COND_JMP25222(>(i1739, 0), i1739, i1739)
    • (i1739[6] ≥ 0 ⇒ (UIncreasing(COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])), ≥)∧[(-1)Bound*bni_60 + (2)bni_60] + [(2)bni_60]i1739[6] ≥ 0∧[1 + (-1)bso_61] ≥ 0)

  • COND_JMP25222(TRUE, i1739, i1739) → JMP2522'(i1739, 0)
    • (i1739[6] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[7], 0)), ≥)∧[bni_62 + (-1)Bound*bni_62] + [(2)bni_62]i1739[6] ≥ 0∧[(-1)bso_63] + i1739[6] ≥ 0)

  • JMP4637'(i1739, i1739, i1739, i2851, i1739) → COND_JMP46371(&&(>(i1739, 0), >(i2851, i1739)), i1739, i1739, i1739, i2851, i1739)
    • (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])), ≥)∧[(-1)Bound*bni_64 + (3)bni_64] + [(2)bni_64]i1739[8] + [bni_64]i2851[8] ≥ 0∧[(-1)bso_65] + i1739[8] ≥ 0)

  • COND_JMP46371(TRUE, i1739, i1739, i1739, i2851, i1739) → JMP4637'(i1739, i1739, i1739, -(i2851, i1739), i1739)
    • (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[(3)bni_66 + (-1)Bound*bni_66] + [bni_66]i1739[8] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)
    • (i1739[8] ≥ 0∧i2851[8] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])), ≥)∧[(3)bni_66 + (-1)Bound*bni_66] + [bni_66]i1739[8] + [bni_66]i2851[8] ≥ 0∧[1 + (-1)bso_67] ≥ 0)

  • JMP2522'(i322, i1739) → COND_JMP25223(&&(&&(>(i1739, 0), >(-(i322, i1739), i1739)), >(i322, i1739)), i322, i1739)
    • ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])), ≥)∧[(-1)Bound*bni_68 + (4)bni_68] + [(3)bni_68]i1739[10] + [bni_68]i322[10] ≥ 0∧[2 + (-1)bso_69] + [2]i1739[10] ≥ 0)

  • COND_JMP25223(TRUE, i322, i1739) → JMP4637'(i1739, i1739, i1739, -(-(i322, i1739), i1739), i1739)
    • ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + (2)bni_70] + [bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)
    • ([1] + i1739[10] + i322[10] ≥ 0∧i1739[10] ≥ 0∧i322[10] ≥ 0 ⇒ (UIncreasing(JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])), ≥)∧[(-1)Bound*bni_70 + (2)bni_70] + [bni_70]i1739[10] + [bni_70]i322[10] ≥ 0∧[(-1)bso_71] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(JMP2522'(x1, x2)) = x2 + x1   
POL(COND_JMP2522(x1, x2, x3)) = x3 + x2   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [2]   
POL(0) = 0   
POL(<(x1, x2)) = [-1]   
POL(!(x1)) = [-1]   
POL(=(x1, x2)) = [-1]   
POL(JMP4637'(x1, x2, x3, x4, x5)) = [2]x5 + x4 + [-1]x2   
POL(COND_JMP4637(x1, x2, x3, x4, x5, x6)) = x6 + x5 + [2]x4 + [-1]x3 + [-1]x2   
POL(<=(x1, x2)) = [-1]   
POL(COND_JMP25221(x1, x2, x3)) = [2]x3   
POL(-(x1, x2)) = x1 + [-1]x2   
POL(COND_JMP25222(x1, x2, x3)) = [-1] + [2]x2   
POL(COND_JMP46371(x1, x2, x3, x4, x5, x6)) = [1] + x6 + x5 + [-1]x3   
POL(COND_JMP25223(x1, x2, x3)) = [-1]x3 + x2   

The following pairs are in P>:

JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])
JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])
COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])
JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])

The following pairs are in Pbound:

JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])
JMP2522'(i322[4], i1739[4]) → COND_JMP25221(&&(&&(>(i1739[4], 0), <=(-(i322[4], i1739[4]), i1739[4])), >(i322[4], i1739[4])), i322[4], i1739[4])
COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], -(i322[5], i1739[5]))
JMP2522'(i1739[6], i1739[6]) → COND_JMP25222(>(i1739[6], 0), i1739[6], i1739[6])
COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0)
JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])
COND_JMP46371(TRUE, i1739[9], i1739[9], i1739[9], i2851[9], i1739[9]) → JMP4637'(i1739[9], i1739[9], i1739[9], -(i2851[9], i1739[9]), i1739[9])
JMP2522'(i322[10], i1739[10]) → COND_JMP25223(&&(&&(>(i1739[10], 0), >(-(i322[10], i1739[10]), i1739[10])), >(i322[10], i1739[10])), i322[10], i1739[10])
COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])

The following pairs are in P≥:

JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])
COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(&&(>(i1739[2], 0), <=(i2851[2], i1739[2])), i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])
COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3])
COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], -(i322[5], i1739[5]))
COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0)
JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(&&(>(i1739[8], 0), >(i2851[8], i1739[8])), i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])
COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], -(-(i322[11], i1739[11]), i1739[11]), i1739[11])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
FALSE1 → &&(TRUE, FALSE)1
FALSE1 → &&(FALSE, TRUE)1
FALSE1 → &&(FALSE, FALSE)1

(11) Complex Obligation (AND)

(12) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP2522'(i322[0], i1739[0]) → COND_JMP2522(i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0), i322[0], i1739[0])
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
(2): JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(i1739[2] > 0 && i2851[2] <= i1739[2], i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])
(3): COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3])
(5): COND_JMP25221(TRUE, i322[5], i1739[5]) → JMP2522'(i1739[5], i322[5] - i1739[5])
(7): COND_JMP25222(TRUE, i1739[7], i1739[7]) → JMP2522'(i1739[7], 0)
(8): JMP4637'(i1739[8], i1739[8], i1739[8], i2851[8], i1739[8]) → COND_JMP46371(i1739[8] > 0 && i2851[8] > i1739[8], i1739[8], i1739[8], i1739[8], i2851[8], i1739[8])
(11): COND_JMP25223(TRUE, i322[11], i1739[11]) → JMP4637'(i1739[11], i1739[11], i1739[11], i322[11] - i1739[11] - i1739[11], i1739[11])

(1) -> (0), if ((i322[1] →* i1739[0])∧(i1739[1] →* i322[0]))


(3) -> (0), if ((i2851[3] →* i1739[0])∧(i1739[3] →* i322[0]))


(5) -> (0), if ((i322[5] - i1739[5] →* i1739[0])∧(i1739[5] →* i322[0]))


(7) -> (0), if ((i1739[7] →* i322[0])∧(0 →* i1739[0]))


(0) -> (1), if ((i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0) →* TRUE)∧(i1739[0] →* i1739[1])∧(i322[0] →* i322[1]))


(11) -> (2), if ((i322[11] - i1739[11] - i1739[11] →* i2851[2])∧(i1739[11] →* i1739[2]))


(2) -> (3), if ((i1739[2] > 0 && i2851[2] <= i1739[2] →* TRUE)∧(i1739[2] →* i1739[3])∧(i2851[2] →* i2851[3]))


(11) -> (8), if ((i1739[11] →* i1739[8])∧(i322[11] - i1739[11] - i1739[11] →* i2851[8]))



The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(13) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 6 less nodes.

(14) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
(0): JMP2522'(i322[0], i1739[0]) → COND_JMP2522(i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0), i322[0], i1739[0])

(1) -> (0), if ((i322[1] →* i1739[0])∧(i1739[1] →* i322[0]))


(0) -> (1), if ((i322[0] > 0 && i322[0] < i1739[0] && !(i1739[0] = 0) →* TRUE)∧(i1739[0] →* i1739[1])∧(i322[0] →* i322[1]))



The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(15) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]) the following chains were created:
  • We consider the chain JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]), COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]) which results in the following constraint:

    (1)    (&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0)))=TRUE∧i1739[0]=i1739[1]∧i322[0]=i322[1]∧i322[1]=i1739[0]1∧i1739[1]=i322[0]1 ⇒ COND_JMP2522(TRUE, i322[1], i1739[1])≥NonInfC∧COND_JMP2522(TRUE, i322[1], i1739[1])≥JMP2522'(i1739[1], i322[1])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (1) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (2)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧<(i1739[0], 0)=TRUE ⇒ COND_JMP2522(TRUE, i322[0], i1739[0])≥NonInfC∧COND_JMP2522(TRUE, i322[0], i1739[0])≥JMP2522'(i1739[0], i322[0])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))


    (3)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧>(i1739[0], 0)=TRUE ⇒ COND_JMP2522(TRUE, i322[0], i1739[0])≥NonInfC∧COND_JMP2522(TRUE, i322[0], i1739[0])≥JMP2522'(i1739[0], i322[0])∧(UIncreasing(JMP2522'(i1739[1], i322[1])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (4)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (3) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (5)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (4) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (6)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (7)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (6) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (8)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (7) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (9)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-2 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We solved constraint (8) using rule (IDP_SMT_SPLIT).We simplified constraint (9) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (10)    (i322[0] ≥ 0∧i1739[0] + [-2] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-3)bni_15 + (-1)Bound*bni_15] + [bni_15]i1739[0] ≥ 0∧[-4 + (-1)bso_16] + [2]i1739[0] + [-2]i322[0] ≥ 0)



    We simplified constraint (10) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (11)    (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bni_15 + (-1)Bound*bni_15] + [bni_15]i322[0] + [bni_15]i1739[0] ≥ 0∧[(-1)bso_16] + [2]i1739[0] ≥ 0)







For Pair JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]) the following chains were created:
  • We consider the chain COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]), JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0]), COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1]) which results in the following constraint:

    (12)    (i322[1]=i1739[0]∧i1739[1]=i322[0]∧&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0)))=TRUE∧i1739[0]=i1739[1]1∧i322[0]=i322[1]1 ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))



    We simplified constraint (12) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (13)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧<(i1739[0], 0)=TRUE ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))


    (14)    (>(i322[0], 0)=TRUE∧<(i322[0], i1739[0])=TRUE∧>(i1739[0], 0)=TRUE ⇒ JMP2522'(i322[0], i1739[0])≥NonInfC∧JMP2522'(i322[0], i1739[0])≥COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])∧(UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥))



    We simplified constraint (13) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (15)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (14) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (16)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (15) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (17)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (16) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (18)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (17) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (19)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧[-1] + [-1]i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (18) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (20)    (i322[0] + [-1] ≥ 0∧i1739[0] + [-1] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-1)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[(-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We solved constraint (19) using rule (IDP_SMT_SPLIT).We simplified constraint (20) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (21)    (i322[0] ≥ 0∧i1739[0] + [-2] + [-1]i322[0] ≥ 0∧i1739[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(-2)bni_17 + (-1)Bound*bni_17] + [(2)bni_17]i1739[0] + [(-1)bni_17]i322[0] ≥ 0∧[-1 + (-1)bso_18] + i1739[0] + [-1]i322[0] ≥ 0)



    We simplified constraint (21) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (22)    (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(2)bni_17 + (-1)Bound*bni_17] + [bni_17]i322[0] + [(2)bni_17]i1739[0] ≥ 0∧[1 + (-1)bso_18] + i1739[0] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
    • (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(JMP2522'(i1739[1], i322[1])), ≥)∧[(-1)bni_15 + (-1)Bound*bni_15] + [bni_15]i322[0] + [bni_15]i1739[0] ≥ 0∧[(-1)bso_16] + [2]i1739[0] ≥ 0)

  • JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])
    • (i322[0] ≥ 0∧i1739[0] ≥ 0∧[1] + i322[0] + i1739[0] ≥ 0 ⇒ (UIncreasing(COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])), ≥)∧[(2)bni_17 + (-1)Bound*bni_17] + [bni_17]i322[0] + [(2)bni_17]i1739[0] ≥ 0∧[1 + (-1)bso_18] + i1739[0] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = [2]   
POL(FALSE) = 0   
POL(COND_JMP2522(x1, x2, x3)) = [-1] + x3 + [-1]x1   
POL(JMP2522'(x1, x2)) = [-1] + [2]x2 + [-1]x1   
POL(&&(x1, x2)) = 0   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(<(x1, x2)) = [-1]   
POL(!(x1)) = [-1]   
POL(=(x1, x2)) = [-1]   

The following pairs are in P>:

JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])

The following pairs are in Pbound:

COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
JMP2522'(i322[0], i1739[0]) → COND_JMP2522(&&(&&(>(i322[0], 0), <(i322[0], i1739[0])), !(=(i1739[0], 0))), i322[0], i1739[0])

The following pairs are in P≥:

COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
&&(TRUE, FALSE)1 ↔ FALSE1
&&(FALSE, TRUE)1 ↔ FALSE1
&&(FALSE, FALSE)1 ↔ FALSE1

(16) Complex Obligation (AND)

(17) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])


The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(18) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(19) TRUE

(20) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph is empty.

The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(21) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

(22) TRUE

(23) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP2522(TRUE, i322[1], i1739[1]) → JMP2522'(i1739[1], i322[1])
(2): JMP4637'(i1739[2], i1739[2], i1739[2], i2851[2], i1739[2]) → COND_JMP4637(i1739[2] > 0 && i2851[2] <= i1739[2], i1739[2], i1739[2], i1739[2], i2851[2], i1739[2])
(3): COND_JMP4637(TRUE, i1739[3], i1739[3], i1739[3], i2851[3], i1739[3]) → JMP2522'(i1739[3], i2851[3])

(2) -> (3), if ((i1739[2] > 0 && i2851[2] <= i1739[2] →* TRUE)∧(i1739[2] →* i1739[3])∧(i2851[2] →* i2851[3]))



The set Q consists of the following terms:
JMP2522(x0, x1)
Cond_JMP2522(TRUE, x0, x1)
JMP4637(x0, x0, x0, x1, x0)
Cond_JMP4637(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25221(TRUE, x0, x1)
Cond_JMP25222(TRUE, x0, x0)
Cond_JMP46371(TRUE, x0, x0, x0, x1, x0)
Cond_JMP25223(TRUE, x0, x1)

(24) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 3 less nodes.

(25) TRUE

(26) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP3853(i42, i42, i42, i42, i1819, i42) → Cond_JMP3853(i42 > 0 && i1819 > i42, i42, i42, i42, i42, i1819, i42)
Cond_JMP3853(TRUE, i42, i42, i42, i42, i1819, i42) → JMP3853(i42, i42, i42, i42, i1819 - i42, i42)
The set Q consists of the following terms:
JMP3853(x0, x0, x0, x0, x1, x0)
Cond_JMP3853(TRUE, x0, x0, x0, x0, x1, x0)

(27) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(28) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP3853(i42, i42, i42, i42, i1819, i42) → Cond_JMP3853(i42 > 0 && i1819 > i42, i42, i42, i42, i42, i1819, i42)
Cond_JMP3853(TRUE, i42, i42, i42, i42, i1819, i42) → JMP3853(i42, i42, i42, i42, i1819 - i42, i42)

The integer pair graph contains the following rules and edges:
(0): JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(i42[0] > 0 && i1819[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])
(1): COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], i1819[1] - i42[1], i42[1])

(0) -> (1), if ((i1819[0] →* i1819[1])∧(i42[0] →* i42[1])∧(i42[0] > 0 && i1819[0] > i42[0] →* TRUE))


(1) -> (0), if ((i1819[1] - i42[1] →* i1819[0])∧(i42[1] →* i42[0]))



The set Q consists of the following terms:
JMP3853(x0, x0, x0, x0, x1, x0)
Cond_JMP3853(TRUE, x0, x0, x0, x0, x1, x0)

(29) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(30) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(i42[0] > 0 && i1819[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])
(1): COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], i1819[1] - i42[1], i42[1])

(0) -> (1), if ((i1819[0] →* i1819[1])∧(i42[0] →* i42[1])∧(i42[0] > 0 && i1819[0] > i42[0] →* TRUE))


(1) -> (0), if ((i1819[1] - i42[1] →* i1819[0])∧(i42[1] →* i42[0]))



The set Q consists of the following terms:
JMP3853(x0, x0, x0, x0, x1, x0)
Cond_JMP3853(TRUE, x0, x0, x0, x0, x1, x0)

(31) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP3853'(i42, i42, i42, i42, i1819, i42) → COND_JMP3853(&&(>(i42, 0), >(i1819, i42)), i42, i42, i42, i42, i1819, i42) the following chains were created:
  • We consider the chain JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]), COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1]) which results in the following constraint:

    (1)    (i1819[0]=i1819[1]∧i42[0]=i42[1]∧&&(>(i42[0], 0), >(i1819[0], i42[0]))=TRUE ⇒ JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥NonInfC∧JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])∧(UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (2)    (>(i42[0], 0)=TRUE∧>(i1819[0], i42[0])=TRUE ⇒ JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥NonInfC∧JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])∧(UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i1819[0] ≥ 0∧[-1 + (-1)bso_21] + i42[0] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i1819[0] ≥ 0∧[-1 + (-1)bso_21] + i42[0] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i1819[0] ≥ 0∧[-1 + (-1)bso_21] + i42[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i42[0] ≥ 0∧i1819[0] + [-2] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-2)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i1819[0] ≥ 0∧[(-1)bso_21] + i42[0] ≥ 0)



    We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (7)    (i42[0] ≥ 0∧i1819[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-1)Bound*bni_20] + [bni_20]i1819[0] ≥ 0∧[(-1)bso_21] + i42[0] ≥ 0)







For Pair COND_JMP3853(TRUE, i42, i42, i42, i42, i1819, i42) → JMP3853'(i42, i42, i42, i42, -(i1819, i42), i42) the following chains were created:
  • We consider the chain JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]), COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1]), JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) which results in the following constraint:

    (8)    (i1819[0]=i1819[1]∧i42[0]=i42[1]∧&&(>(i42[0], 0), >(i1819[0], i42[0]))=TRUE∧-(i1819[1], i42[1])=i1819[0]1∧i42[1]=i42[0]1 ⇒ COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1])≥NonInfC∧COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1])≥JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])∧(UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥))



    We simplified constraint (8) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (9)    (>(i42[0], 0)=TRUE∧>(i1819[0], i42[0])=TRUE ⇒ COND_JMP3853(TRUE, i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥NonInfC∧COND_JMP3853(TRUE, i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])≥JMP3853'(i42[0], i42[0], i42[0], i42[0], -(i1819[0], i42[0]), i42[0])∧(UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥))



    We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (10)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22] + [(-2)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)



    We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (11)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22] + [(-2)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)



    We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (12)    (i42[0] + [-1] ≥ 0∧i1819[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22] + [(-2)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)



    We simplified constraint (12) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (13)    (i42[0] ≥ 0∧i1819[0] + [-2] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22 + (-2)bni_22] + [(-2)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)



    We simplified constraint (13) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (14)    (i42[0] ≥ 0∧i1819[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22] + [(-1)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP3853'(i42, i42, i42, i42, i1819, i42) → COND_JMP3853(&&(>(i42, 0), >(i1819, i42)), i42, i42, i42, i42, i1819, i42)
    • (i42[0] ≥ 0∧i1819[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])), ≥)∧[(-1)Bound*bni_20] + [bni_20]i1819[0] ≥ 0∧[(-1)bso_21] + i42[0] ≥ 0)

  • COND_JMP3853(TRUE, i42, i42, i42, i42, i1819, i42) → JMP3853'(i42, i42, i42, i42, -(i1819, i42), i42)
    • (i42[0] ≥ 0∧i1819[0] ≥ 0 ⇒ (UIncreasing(JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])), ≥)∧[(-1)Bound*bni_22] + [(-1)bni_22]i42[0] + [bni_22]i1819[0] ≥ 0∧[1 + (-1)bso_23] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = [1]   
POL(FALSE) = [2]   
POL(JMP3853'(x1, x2, x3, x4, x5, x6)) = [-1] + x6 + x5 + [-1]x4 + [-1]x3   
POL(COND_JMP3853(x1, x2, x3, x4, x5, x6, x7)) = [1] + [2]x7 + x6 + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(&&(x1, x2)) = [1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(-(x1, x2)) = x1 + [-1]x2   

The following pairs are in P>:

COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], -(i1819[1], i42[1]), i42[1])

The following pairs are in Pbound:

JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])

The following pairs are in P≥:

JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(&&(>(i42[0], 0), >(i1819[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
FALSE1 → &&(TRUE, FALSE)1
FALSE1 → &&(FALSE, TRUE)1
FALSE1 → &&(FALSE, FALSE)1

(32) Complex Obligation (AND)

(33) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP3853'(i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0]) → COND_JMP3853(i42[0] > 0 && i1819[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i1819[0], i42[0])


The set Q consists of the following terms:
JMP3853(x0, x0, x0, x0, x1, x0)
Cond_JMP3853(TRUE, x0, x0, x0, x0, x1, x0)

(34) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(35) TRUE

(36) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP3853(TRUE, i42[1], i42[1], i42[1], i42[1], i1819[1], i42[1]) → JMP3853'(i42[1], i42[1], i42[1], i42[1], i1819[1] - i42[1], i42[1])


The set Q consists of the following terms:
JMP3853(x0, x0, x0, x0, x1, x0)
Cond_JMP3853(TRUE, x0, x0, x0, x0, x1, x0)

(37) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(38) TRUE

(39) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP3835(i1023, i1023, i1023, i1779, i1023) → Cond_JMP3835(i1023 > 0 && i1779 > i1023, i1023, i1023, i1023, i1779, i1023)
Cond_JMP3835(TRUE, i1023, i1023, i1023, i1779, i1023) → JMP3835(i1023, i1023, i1023, i1779 - i1023, i1023)
The set Q consists of the following terms:
JMP3835(x0, x0, x0, x1, x0)
Cond_JMP3835(TRUE, x0, x0, x0, x1, x0)

(40) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(41) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP3835(i1023, i1023, i1023, i1779, i1023) → Cond_JMP3835(i1023 > 0 && i1779 > i1023, i1023, i1023, i1023, i1779, i1023)
Cond_JMP3835(TRUE, i1023, i1023, i1023, i1779, i1023) → JMP3835(i1023, i1023, i1023, i1779 - i1023, i1023)

The integer pair graph contains the following rules and edges:
(0): JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(i1023[0] > 0 && i1779[0] > i1023[0], i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])
(1): COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], i1779[1] - i1023[1], i1023[1])

(0) -> (1), if ((i1779[0] →* i1779[1])∧(i1023[0] →* i1023[1])∧(i1023[0] > 0 && i1779[0] > i1023[0] →* TRUE))


(1) -> (0), if ((i1779[1] - i1023[1] →* i1779[0])∧(i1023[1] →* i1023[0]))



The set Q consists of the following terms:
JMP3835(x0, x0, x0, x1, x0)
Cond_JMP3835(TRUE, x0, x0, x0, x1, x0)

(42) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(43) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(i1023[0] > 0 && i1779[0] > i1023[0], i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])
(1): COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], i1779[1] - i1023[1], i1023[1])

(0) -> (1), if ((i1779[0] →* i1779[1])∧(i1023[0] →* i1023[1])∧(i1023[0] > 0 && i1779[0] > i1023[0] →* TRUE))


(1) -> (0), if ((i1779[1] - i1023[1] →* i1779[0])∧(i1023[1] →* i1023[0]))



The set Q consists of the following terms:
JMP3835(x0, x0, x0, x1, x0)
Cond_JMP3835(TRUE, x0, x0, x0, x1, x0)

(44) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP3835'(i1023, i1023, i1023, i1779, i1023) → COND_JMP3835(&&(>(i1023, 0), >(i1779, i1023)), i1023, i1023, i1023, i1779, i1023) the following chains were created:
  • We consider the chain JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]), COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1]) which results in the following constraint:

    (1)    (i1779[0]=i1779[1]∧i1023[0]=i1023[1]∧&&(>(i1023[0], 0), >(i1779[0], i1023[0]))=TRUE ⇒ JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥NonInfC∧JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])∧(UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (2)    (>(i1023[0], 0)=TRUE∧>(i1779[0], i1023[0])=TRUE ⇒ JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥NonInfC∧JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])∧(UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[bni_18 + (-1)Bound*bni_18] + [(-1)bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[-1 + (-1)bso_19] + i1023[0] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[bni_18 + (-1)Bound*bni_18] + [(-1)bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[-1 + (-1)bso_19] + i1023[0] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[bni_18 + (-1)Bound*bni_18] + [(-1)bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[-1 + (-1)bso_19] + i1023[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i1023[0] ≥ 0∧i1779[0] + [-2] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[(-1)Bound*bni_18] + [(-1)bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[(-1)bso_19] + i1023[0] ≥ 0)



    We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (7)    (i1023[0] ≥ 0∧i1779[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[(-1)Bound*bni_18 + (4)bni_18] + [bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[(-1)bso_19] + i1023[0] ≥ 0)







For Pair COND_JMP3835(TRUE, i1023, i1023, i1023, i1779, i1023) → JMP3835'(i1023, i1023, i1023, -(i1779, i1023), i1023) the following chains were created:
  • We consider the chain JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]), COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1]), JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) which results in the following constraint:

    (8)    (i1779[0]=i1779[1]∧i1023[0]=i1023[1]∧&&(>(i1023[0], 0), >(i1779[0], i1023[0]))=TRUE∧-(i1779[1], i1023[1])=i1779[0]1∧i1023[1]=i1023[0]1 ⇒ COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1])≥NonInfC∧COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1])≥JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])∧(UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥))



    We simplified constraint (8) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (9)    (>(i1023[0], 0)=TRUE∧>(i1779[0], i1023[0])=TRUE ⇒ COND_JMP3835(TRUE, i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥NonInfC∧COND_JMP3835(TRUE, i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])≥JMP3835'(i1023[0], i1023[0], i1023[0], -(i1779[0], i1023[0]), i1023[0])∧(UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥))



    We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (10)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i1023[0] + [(2)bni_20]i1779[0] ≥ 0∧[(-1)bso_21] + i1023[0] ≥ 0)



    We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (11)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i1023[0] + [(2)bni_20]i1779[0] ≥ 0∧[(-1)bso_21] + i1023[0] ≥ 0)



    We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (12)    (i1023[0] + [-1] ≥ 0∧i1779[0] + [-1] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i1023[0] + [(2)bni_20]i1779[0] ≥ 0∧[(-1)bso_21] + i1023[0] ≥ 0)



    We simplified constraint (12) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (13)    (i1023[0] ≥ 0∧i1779[0] + [-2] + [-1]i1023[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i1023[0] + [(2)bni_20]i1779[0] ≥ 0∧[1 + (-1)bso_21] + i1023[0] ≥ 0)



    We simplified constraint (13) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (14)    (i1023[0] ≥ 0∧i1779[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[(3)bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i1779[0] ≥ 0∧[1 + (-1)bso_21] + i1023[0] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP3835'(i1023, i1023, i1023, i1779, i1023) → COND_JMP3835(&&(>(i1023, 0), >(i1779, i1023)), i1023, i1023, i1023, i1779, i1023)
    • (i1023[0] ≥ 0∧i1779[0] ≥ 0 ⇒ (UIncreasing(COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])), ≥)∧[(-1)Bound*bni_18 + (4)bni_18] + [bni_18]i1023[0] + [(2)bni_18]i1779[0] ≥ 0∧[(-1)bso_19] + i1023[0] ≥ 0)

  • COND_JMP3835(TRUE, i1023, i1023, i1023, i1779, i1023) → JMP3835'(i1023, i1023, i1023, -(i1779, i1023), i1023)
    • (i1023[0] ≥ 0∧i1779[0] ≥ 0 ⇒ (UIncreasing(JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])), ≥)∧[(3)bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i1779[0] ≥ 0∧[1 + (-1)bso_21] + i1023[0] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = [1]   
POL(JMP3835'(x1, x2, x3, x4, x5)) = [1] + [2]x5 + [2]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(COND_JMP3835(x1, x2, x3, x4, x5, x6)) = [1] + [-1]x6 + [2]x5 + [-1]x4 + [-1]x3 + x2 + [-1]x1   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(-(x1, x2)) = x1 + [-1]x2   

The following pairs are in P>:

COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])

The following pairs are in Pbound:

JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])
COND_JMP3835(TRUE, i1023[1], i1023[1], i1023[1], i1779[1], i1023[1]) → JMP3835'(i1023[1], i1023[1], i1023[1], -(i1779[1], i1023[1]), i1023[1])

The following pairs are in P≥:

JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(&&(>(i1023[0], 0), >(i1779[0], i1023[0])), i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
FALSE1 → &&(TRUE, FALSE)1
FALSE1 → &&(FALSE, TRUE)1
FALSE1 → &&(FALSE, FALSE)1

(45) Complex Obligation (AND)

(46) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP3835'(i1023[0], i1023[0], i1023[0], i1779[0], i1023[0]) → COND_JMP3835(i1023[0] > 0 && i1779[0] > i1023[0], i1023[0], i1023[0], i1023[0], i1779[0], i1023[0])


The set Q consists of the following terms:
JMP3835(x0, x0, x0, x1, x0)
Cond_JMP3835(TRUE, x0, x0, x0, x1, x0)

(47) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(48) TRUE

(49) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph is empty.

The set Q consists of the following terms:
JMP3835(x0, x0, x0, x1, x0)
Cond_JMP3835(TRUE, x0, x0, x0, x1, x0)

(50) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

(51) TRUE

(52) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP1981(i322, i322, i322, i654, i322) → Cond_JMP1981(i322 > 0 && i654 > i322, i322, i322, i322, i654, i322)
Cond_JMP1981(TRUE, i322, i322, i322, i654, i322) → JMP1981(i322, i322, i322, i654 - i322, i322)
The set Q consists of the following terms:
JMP1981(x0, x0, x0, x1, x0)
Cond_JMP1981(TRUE, x0, x0, x0, x1, x0)

(53) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(54) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP1981(i322, i322, i322, i654, i322) → Cond_JMP1981(i322 > 0 && i654 > i322, i322, i322, i322, i654, i322)
Cond_JMP1981(TRUE, i322, i322, i322, i654, i322) → JMP1981(i322, i322, i322, i654 - i322, i322)

The integer pair graph contains the following rules and edges:
(0): JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(i322[0] > 0 && i654[0] > i322[0], i322[0], i322[0], i322[0], i654[0], i322[0])
(1): COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], i654[1] - i322[1], i322[1])

(0) -> (1), if ((i654[0] →* i654[1])∧(i322[0] > 0 && i654[0] > i322[0] →* TRUE)∧(i322[0] →* i322[1]))


(1) -> (0), if ((i654[1] - i322[1] →* i654[0])∧(i322[1] →* i322[0]))



The set Q consists of the following terms:
JMP1981(x0, x0, x0, x1, x0)
Cond_JMP1981(TRUE, x0, x0, x0, x1, x0)

(55) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(56) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(i322[0] > 0 && i654[0] > i322[0], i322[0], i322[0], i322[0], i654[0], i322[0])
(1): COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], i654[1] - i322[1], i322[1])

(0) -> (1), if ((i654[0] →* i654[1])∧(i322[0] > 0 && i654[0] > i322[0] →* TRUE)∧(i322[0] →* i322[1]))


(1) -> (0), if ((i654[1] - i322[1] →* i654[0])∧(i322[1] →* i322[0]))



The set Q consists of the following terms:
JMP1981(x0, x0, x0, x1, x0)
Cond_JMP1981(TRUE, x0, x0, x0, x1, x0)

(57) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP1981'(i322, i322, i322, i654, i322) → COND_JMP1981(&&(>(i322, 0), >(i654, i322)), i322, i322, i322, i654, i322) the following chains were created:
  • We consider the chain JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0]), COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1]) which results in the following constraint:

    (1)    (i654[0]=i654[1]∧&&(>(i322[0], 0), >(i654[0], i322[0]))=TRUE∧i322[0]=i322[1] ⇒ JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0])≥NonInfC∧JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0])≥COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])∧(UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (2)    (>(i322[0], 0)=TRUE∧>(i654[0], i322[0])=TRUE ⇒ JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0])≥NonInfC∧JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0])≥COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])∧(UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18] + [(-2)bni_18]i322[0] + [(2)bni_18]i654[0] ≥ 0∧[-1 + (-1)bso_19] + [2]i322[0] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18] + [(-2)bni_18]i322[0] + [(2)bni_18]i654[0] ≥ 0∧[-1 + (-1)bso_19] + [2]i322[0] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18] + [(-2)bni_18]i322[0] + [(2)bni_18]i654[0] ≥ 0∧[-1 + (-1)bso_19] + [2]i322[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i322[0] ≥ 0∧i654[0] + [-2] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18 + (-2)bni_18] + [(-2)bni_18]i322[0] + [(2)bni_18]i654[0] ≥ 0∧[1 + (-1)bso_19] + [2]i322[0] ≥ 0)



    We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (7)    (i322[0] ≥ 0∧i654[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18 + (2)bni_18] + [(2)bni_18]i654[0] ≥ 0∧[1 + (-1)bso_19] + [2]i322[0] ≥ 0)







For Pair COND_JMP1981(TRUE, i322, i322, i322, i654, i322) → JMP1981'(i322, i322, i322, -(i654, i322), i322) the following chains were created:
  • We consider the chain JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0]), COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1]), JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0]) which results in the following constraint:

    (8)    (i654[0]=i654[1]∧&&(>(i322[0], 0), >(i654[0], i322[0]))=TRUE∧i322[0]=i322[1]∧-(i654[1], i322[1])=i654[0]1∧i322[1]=i322[0]1 ⇒ COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1])≥NonInfC∧COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1])≥JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])∧(UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥))



    We simplified constraint (8) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (9)    (>(i322[0], 0)=TRUE∧>(i654[0], i322[0])=TRUE ⇒ COND_JMP1981(TRUE, i322[0], i322[0], i322[0], i654[0], i322[0])≥NonInfC∧COND_JMP1981(TRUE, i322[0], i322[0], i322[0], i654[0], i322[0])≥JMP1981'(i322[0], i322[0], i322[0], -(i654[0], i322[0]), i322[0])∧(UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥))



    We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (10)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20] + [(-4)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (11)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20] + [(-4)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (12)    (i322[0] + [-1] ≥ 0∧i654[0] + [-1] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20] + [(-4)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (12) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (13)    (i322[0] ≥ 0∧i654[0] + [-2] + [-1]i322[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20 + (-4)bni_20] + [(-4)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (13) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (14)    (i322[0] ≥ 0∧i654[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20] + [(-2)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP1981'(i322, i322, i322, i654, i322) → COND_JMP1981(&&(>(i322, 0), >(i654, i322)), i322, i322, i322, i654, i322)
    • (i322[0] ≥ 0∧i654[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])), ≥)∧[(-1)Bound*bni_18 + (2)bni_18] + [(2)bni_18]i654[0] ≥ 0∧[1 + (-1)bso_19] + [2]i322[0] ≥ 0)

  • COND_JMP1981(TRUE, i322, i322, i322, i654, i322) → JMP1981'(i322, i322, i322, -(i654, i322), i322)
    • (i322[0] ≥ 0∧i654[0] ≥ 0 ⇒ (UIncreasing(JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])), ≥)∧[(-1)Bound*bni_20] + [(-2)bni_20]i322[0] + [(2)bni_20]i654[0] ≥ 0∧[(-1)bso_21] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = [2]   
POL(JMP1981'(x1, x2, x3, x4, x5)) = [2]x4 + [-1]x3 + [-1]x1   
POL(COND_JMP1981(x1, x2, x3, x4, x5, x6)) = [-1]x6 + [2]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(-(x1, x2)) = x1 + [-1]x2   

The following pairs are in P>:

JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])

The following pairs are in Pbound:

JMP1981'(i322[0], i322[0], i322[0], i654[0], i322[0]) → COND_JMP1981(&&(>(i322[0], 0), >(i654[0], i322[0])), i322[0], i322[0], i322[0], i654[0], i322[0])

The following pairs are in P≥:

COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], -(i654[1], i322[1]), i322[1])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
FALSE1 → &&(TRUE, FALSE)1
FALSE1 → &&(FALSE, TRUE)1
FALSE1 → &&(FALSE, FALSE)1

(58) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP1981(TRUE, i322[1], i322[1], i322[1], i654[1], i322[1]) → JMP1981'(i322[1], i322[1], i322[1], i654[1] - i322[1], i322[1])


The set Q consists of the following terms:
JMP1981(x0, x0, x0, x1, x0)
Cond_JMP1981(TRUE, x0, x0, x0, x1, x0)

(59) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(60) TRUE

(61) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP1936(i1023, i1023, i1023) → Cond_JMP1936(i1023 > 0, i1023, i1023, i1023)
Cond_JMP1936(TRUE, i1023, i1023, i1023) → JMP1936(i1023, i1023, 0)
The set Q consists of the following terms:
JMP1936(x0, x0, x0)
Cond_JMP1936(TRUE, x0, x0, x0)

(62) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(63) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


The ITRS R consists of the following rules:
JMP1936(i1023, i1023, i1023) → Cond_JMP1936(i1023 > 0, i1023, i1023, i1023)
Cond_JMP1936(TRUE, i1023, i1023, i1023) → JMP1936(i1023, i1023, 0)

The integer pair graph contains the following rules and edges:
(0): JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(i1023[0] > 0, i1023[0], i1023[0], i1023[0])
(1): COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0)

(0) -> (1), if ((i1023[0] > 0 →* TRUE)∧(i1023[0] →* i1023[1]))


(1) -> (0), if ((0 →* i1023[0])∧(i1023[1] →* i1023[0]))



The set Q consists of the following terms:
JMP1936(x0, x0, x0)
Cond_JMP1936(TRUE, x0, x0, x0)

(64) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(65) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(i1023[0] > 0, i1023[0], i1023[0], i1023[0])
(1): COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0)

(0) -> (1), if ((i1023[0] > 0 →* TRUE)∧(i1023[0] →* i1023[1]))


(1) -> (0), if ((0 →* i1023[0])∧(i1023[1] →* i1023[0]))



The set Q consists of the following terms:
JMP1936(x0, x0, x0)
Cond_JMP1936(TRUE, x0, x0, x0)

(66) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP1936'(i1023, i1023, i1023) → COND_JMP1936(>(i1023, 0), i1023, i1023, i1023) the following chains were created:
  • We consider the chain JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0]), COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0) which results in the following constraint:

    (1)    (>(i1023[0], 0)=TRUE∧i1023[0]=i1023[1] ⇒ JMP1936'(i1023[0], i1023[0], i1023[0])≥NonInfC∧JMP1936'(i1023[0], i1023[0], i1023[0])≥COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])∧(UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥))



    We simplified constraint (1) using rule (IV) which results in the following new constraint:

    (2)    (>(i1023[0], 0)=TRUE ⇒ JMP1936'(i1023[0], i1023[0], i1023[0])≥NonInfC∧JMP1936'(i1023[0], i1023[0], i1023[0])≥COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])∧(UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i1023[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥)∧[(-1)bni_12 + (-1)Bound*bni_12] + [(4)bni_12]i1023[0] ≥ 0∧[-2 + (-1)bso_13] + [2]i1023[0] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i1023[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥)∧[(-1)bni_12 + (-1)Bound*bni_12] + [(4)bni_12]i1023[0] ≥ 0∧[-2 + (-1)bso_13] + [2]i1023[0] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i1023[0] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥)∧[(-1)bni_12 + (-1)Bound*bni_12] + [(4)bni_12]i1023[0] ≥ 0∧[-2 + (-1)bso_13] + [2]i1023[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥)∧[(3)bni_12 + (-1)Bound*bni_12] + [(4)bni_12]i1023[0] ≥ 0∧[(-1)bso_13] + [2]i1023[0] ≥ 0)







For Pair COND_JMP1936(TRUE, i1023, i1023, i1023) → JMP1936'(i1023, i1023, 0) the following chains were created:
  • We consider the chain COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0) which results in the following constraint:

    (7)    (COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1])≥NonInfC∧COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1])≥JMP1936'(i1023[1], i1023[1], 0)∧(UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥))



    We simplified constraint (7) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (8)    ((UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥)∧[2 + (-1)bso_15] ≥ 0)



    We simplified constraint (8) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (9)    ((UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥)∧[2 + (-1)bso_15] ≥ 0)



    We simplified constraint (9) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (10)    ((UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥)∧[2 + (-1)bso_15] ≥ 0)



    We simplified constraint (10) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (11)    ((UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥)∧0 = 0∧[2 + (-1)bso_15] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP1936'(i1023, i1023, i1023) → COND_JMP1936(>(i1023, 0), i1023, i1023, i1023)
    • (i1023[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])), ≥)∧[(3)bni_12 + (-1)Bound*bni_12] + [(4)bni_12]i1023[0] ≥ 0∧[(-1)bso_13] + [2]i1023[0] ≥ 0)

  • COND_JMP1936(TRUE, i1023, i1023, i1023) → JMP1936'(i1023, i1023, 0)
    • ((UIncreasing(JMP1936'(i1023[1], i1023[1], 0)), ≥)∧0 = 0∧[2 + (-1)bso_15] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(JMP1936'(x1, x2, x3)) = [-1] + [2]x3 + x2 + x1   
POL(COND_JMP1936(x1, x2, x3, x4)) = [1] + x4 + [-1]x3 + [2]x2   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   

The following pairs are in P>:

COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0)

The following pairs are in Pbound:

JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])

The following pairs are in P≥:

JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(>(i1023[0], 0), i1023[0], i1023[0], i1023[0])

There are no usable rules.

(67) Complex Obligation (AND)

(68) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1936'(i1023[0], i1023[0], i1023[0]) → COND_JMP1936(i1023[0] > 0, i1023[0], i1023[0], i1023[0])


The set Q consists of the following terms:
JMP1936(x0, x0, x0)
Cond_JMP1936(TRUE, x0, x0, x0)

(69) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(70) TRUE

(71) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_JMP1936(TRUE, i1023[1], i1023[1], i1023[1]) → JMP1936'(i1023[1], i1023[1], 0)


The set Q consists of the following terms:
JMP1936(x0, x0, x0)
Cond_JMP1936(TRUE, x0, x0, x0)

(72) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(73) TRUE

(74) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP1590(i40, i40, i40, i40, i341, i40) → Cond_JMP1590(i40 > 0 && i341 > i40, i40, i40, i40, i40, i341, i40)
Cond_JMP1590(TRUE, i40, i40, i40, i40, i341, i40) → JMP1590(i40, i40, i40, i40, i341 - i40, i40)
The set Q consists of the following terms:
JMP1590(x0, x0, x0, x0, x1, x0)
Cond_JMP1590(TRUE, x0, x0, x0, x0, x1, x0)

(75) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(76) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP1590(i40, i40, i40, i40, i341, i40) → Cond_JMP1590(i40 > 0 && i341 > i40, i40, i40, i40, i40, i341, i40)
Cond_JMP1590(TRUE, i40, i40, i40, i40, i341, i40) → JMP1590(i40, i40, i40, i40, i341 - i40, i40)

The integer pair graph contains the following rules and edges:
(0): JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(i40[0] > 0 && i341[0] > i40[0], i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])
(1): COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], i341[1] - i40[1], i40[1])

(0) -> (1), if ((i341[0] →* i341[1])∧(i40[0] →* i40[1])∧(i40[0] > 0 && i341[0] > i40[0] →* TRUE))


(1) -> (0), if ((i40[1] →* i40[0])∧(i341[1] - i40[1] →* i341[0]))



The set Q consists of the following terms:
JMP1590(x0, x0, x0, x0, x1, x0)
Cond_JMP1590(TRUE, x0, x0, x0, x0, x1, x0)

(77) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(78) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(i40[0] > 0 && i341[0] > i40[0], i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])
(1): COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], i341[1] - i40[1], i40[1])

(0) -> (1), if ((i341[0] →* i341[1])∧(i40[0] →* i40[1])∧(i40[0] > 0 && i341[0] > i40[0] →* TRUE))


(1) -> (0), if ((i40[1] →* i40[0])∧(i341[1] - i40[1] →* i341[0]))



The set Q consists of the following terms:
JMP1590(x0, x0, x0, x0, x1, x0)
Cond_JMP1590(TRUE, x0, x0, x0, x0, x1, x0)

(79) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP1590'(i40, i40, i40, i40, i341, i40) → COND_JMP1590(&&(>(i40, 0), >(i341, i40)), i40, i40, i40, i40, i341, i40) the following chains were created:
  • We consider the chain JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]), COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1]) which results in the following constraint:

    (1)    (i341[0]=i341[1]∧i40[0]=i40[1]∧&&(>(i40[0], 0), >(i341[0], i40[0]))=TRUE ⇒ JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥NonInfC∧JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])∧(UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (2)    (>(i40[0], 0)=TRUE∧>(i341[0], i40[0])=TRUE ⇒ JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥NonInfC∧JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])∧(UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i341[0] ≥ 0∧[(-1)bso_21] + i40[0] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i341[0] ≥ 0∧[(-1)bso_21] + i40[0] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i341[0] ≥ 0∧[(-1)bso_21] + i40[0] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i40[0] ≥ 0∧i341[0] + [-2] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i341[0] ≥ 0∧[1 + (-1)bso_21] + i40[0] ≥ 0)



    We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (7)    (i40[0] ≥ 0∧i341[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[(5)bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i40[0] + [(2)bni_20]i341[0] ≥ 0∧[1 + (-1)bso_21] + i40[0] ≥ 0)







For Pair COND_JMP1590(TRUE, i40, i40, i40, i40, i341, i40) → JMP1590'(i40, i40, i40, i40, -(i341, i40), i40) the following chains were created:
  • We consider the chain JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]), COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1]), JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) which results in the following constraint:

    (8)    (i341[0]=i341[1]∧i40[0]=i40[1]∧&&(>(i40[0], 0), >(i341[0], i40[0]))=TRUE∧i40[1]=i40[0]1∧-(i341[1], i40[1])=i341[0]1 ⇒ COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1])≥NonInfC∧COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1])≥JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])∧(UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥))



    We simplified constraint (8) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (9)    (>(i40[0], 0)=TRUE∧>(i341[0], i40[0])=TRUE ⇒ COND_JMP1590(TRUE, i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥NonInfC∧COND_JMP1590(TRUE, i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])≥JMP1590'(i40[0], i40[0], i40[0], i40[0], -(i341[0], i40[0]), i40[0])∧(UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥))



    We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (10)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[bni_22 + (-1)Bound*bni_22] + [(-1)bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[(-1)bso_23] + i40[0] ≥ 0)



    We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (11)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[bni_22 + (-1)Bound*bni_22] + [(-1)bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[(-1)bso_23] + i40[0] ≥ 0)



    We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (12)    (i40[0] + [-1] ≥ 0∧i341[0] + [-1] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[bni_22 + (-1)Bound*bni_22] + [(-1)bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[(-1)bso_23] + i40[0] ≥ 0)



    We simplified constraint (12) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (13)    (i40[0] ≥ 0∧i341[0] + [-2] + [-1]i40[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[(-1)Bound*bni_22] + [(-1)bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[1 + (-1)bso_23] + i40[0] ≥ 0)



    We simplified constraint (13) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (14)    (i40[0] ≥ 0∧i341[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[(-1)Bound*bni_22 + (4)bni_22] + [bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[1 + (-1)bso_23] + i40[0] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP1590'(i40, i40, i40, i40, i341, i40) → COND_JMP1590(&&(>(i40, 0), >(i341, i40)), i40, i40, i40, i40, i341, i40)
    • (i40[0] ≥ 0∧i341[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])), ≥)∧[(5)bni_20 + (-1)Bound*bni_20] + [(2)bni_20]i40[0] + [(2)bni_20]i341[0] ≥ 0∧[1 + (-1)bso_21] + i40[0] ≥ 0)

  • COND_JMP1590(TRUE, i40, i40, i40, i40, i341, i40) → JMP1590'(i40, i40, i40, i40, -(i341, i40), i40)
    • (i40[0] ≥ 0∧i341[0] ≥ 0 ⇒ (UIncreasing(JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])), ≥)∧[(-1)Bound*bni_22 + (4)bni_22] + [bni_22]i40[0] + [(2)bni_22]i341[0] ≥ 0∧[1 + (-1)bso_23] + i40[0] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = [1]   
POL(FALSE) = 0   
POL(JMP1590'(x1, x2, x3, x4, x5, x6)) = [1] + [2]x6 + [2]x5 + [-1]x4 + [-1]x3   
POL(COND_JMP1590(x1, x2, x3, x4, x5, x6, x7)) = [1] + [2]x6 + [-1]x4   
POL(&&(x1, x2)) = [2]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(-(x1, x2)) = x1 + [-1]x2   

The following pairs are in P>:

JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])
COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])

The following pairs are in Pbound:

JMP1590'(i40[0], i40[0], i40[0], i40[0], i341[0], i40[0]) → COND_JMP1590(&&(>(i40[0], 0), >(i341[0], i40[0])), i40[0], i40[0], i40[0], i40[0], i341[0], i40[0])
COND_JMP1590(TRUE, i40[1], i40[1], i40[1], i40[1], i341[1], i40[1]) → JMP1590'(i40[1], i40[1], i40[1], i40[1], -(i341[1], i40[1]), i40[1])

The following pairs are in P≥:
none

At least the following rules have been oriented under context sensitive arithmetic replacement:

&&(FALSE, TRUE)1 → FALSE1
&&(FALSE, FALSE)1 → FALSE1

(80) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph is empty.

The set Q consists of the following terms:
JMP1590(x0, x0, x0, x0, x1, x0)
Cond_JMP1590(TRUE, x0, x0, x0, x0, x1, x0)

(81) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

(82) TRUE

(83) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → Cond_NE1621(i42 > 0 && !(i42 = i42), i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
Cond_NE1621(TRUE, i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
JMP1257(i42, i42, i42) → Cond_JMP1257(i42 > 0 && !(i42 = i42), i42, i42, i42)
Cond_JMP1257(TRUE, i42, i42, i42) → NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
NE1621(i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → Cond_NE16211(i322 < i42 && i42 <= i322 && i322 > 0, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322)
Cond_NE16211(TRUE, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → JMP1257(i42, i42, i322)
JMP1257(i42, i42, i322) → Cond_JMP12571(i322 < i42 && i42 <= i322 && i42 > 0 && !(i322 = 0), i42, i42, i322)
Cond_JMP12571(TRUE, i42, i42, i322) → JMP1257(i42, i42, i322)
NE1621(i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → Cond_NE16212(i322 > 0, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322)
Cond_NE16212(TRUE, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → JMP1257(i322, i322, 0)
JMP1257(i322, i322, i322) → Cond_JMP12572(i322 > 0, i322, i322, i322)
Cond_JMP12572(TRUE, i322, i322, i322) → JMP1257(i322, i322, 0)
The set Q consists of the following terms:
Cond_NE1621(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP1257(TRUE, x0, x0, x0)
NE1621(x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE16211(TRUE, x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
JMP1257(x0, x0, x1)
Cond_JMP12571(TRUE, x0, x0, x1)
Cond_NE16212(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP12572(TRUE, x0, x0, x0)

(84) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(85) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → Cond_NE1621(i42 > 0 && !(i42 = i42), i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
Cond_NE1621(TRUE, i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
JMP1257(i42, i42, i42) → Cond_JMP1257(i42 > 0 && !(i42 = i42), i42, i42, i42)
Cond_JMP1257(TRUE, i42, i42, i42) → NE1621(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
NE1621(i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → Cond_NE16211(i322 < i42 && i42 <= i322 && i322 > 0, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322)
Cond_NE16211(TRUE, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → JMP1257(i42, i42, i322)
JMP1257(i42, i42, i322) → Cond_JMP12571(i322 < i42 && i42 <= i322 && i42 > 0 && !(i322 = 0), i42, i42, i322)
Cond_JMP12571(TRUE, i42, i42, i322) → JMP1257(i42, i42, i322)
NE1621(i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → Cond_NE16212(i322 > 0, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322)
Cond_NE16212(TRUE, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → JMP1257(i322, i322, 0)
JMP1257(i322, i322, i322) → Cond_JMP12572(i322 > 0, i322, i322, i322)
Cond_JMP12572(TRUE, i322, i322, i322) → JMP1257(i322, i322, 0)

The integer pair graph contains the following rules and edges:
(0): NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(i42[0] > 0 && !(i42[0] = i42[0]), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])
(1): COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])
(2): JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(i42[2] > 0 && !(i42[2] = i42[2]), i42[2], i42[2], i42[2])
(3): COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])
(4): NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(i322[4] < i42[4] && i42[4] <= i322[4] && i322[4] > 0, i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])
(5): COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5])
(6): JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(i322[6] < i42[6] && i42[6] <= i322[6] && i42[6] > 0 && !(i322[6] = 0), i42[6], i42[6], i322[6])
(7): COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7])
(8): NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(i322[8] > 0, i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])
(9): COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0)
(10): JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(i322[10] > 0, i322[10], i322[10], i322[10])
(11): COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0)

(0) -> (1), if ((i42[0] →* i42[1])∧(i42[0] > 0 && !(i42[0] = i42[0]) →* TRUE))


(1) -> (0), if ((i42[1] →* i42[0]))


(1) -> (4), if ((i42[1] →* i42[4])∧(i42[1] →* i322[4]))


(1) -> (8), if ((i42[1] →* i322[8]))


(2) -> (3), if ((i42[2] →* i42[3])∧(i42[2] > 0 && !(i42[2] = i42[2]) →* TRUE))


(3) -> (0), if ((i42[3] →* i42[0]))


(3) -> (4), if ((i42[3] →* i42[4])∧(i42[3] →* i322[4]))


(3) -> (8), if ((i42[3] →* i322[8]))


(4) -> (5), if ((i322[4] →* i322[5])∧(i42[4] →* i42[5])∧(i322[4] < i42[4] && i42[4] <= i322[4] && i322[4] > 0 →* TRUE))


(5) -> (2), if ((i42[5] →* i42[2])∧(i322[5] →* i42[2]))


(5) -> (6), if ((i322[5] →* i322[6])∧(i42[5] →* i42[6]))


(5) -> (10), if ((i42[5] →* i322[10])∧(i322[5] →* i322[10]))


(6) -> (7), if ((i322[6] < i42[6] && i42[6] <= i322[6] && i42[6] > 0 && !(i322[6] = 0) →* TRUE)∧(i322[6] →* i322[7])∧(i42[6] →* i42[7]))


(7) -> (2), if ((i322[7] →* i42[2])∧(i42[7] →* i42[2]))


(7) -> (6), if ((i322[7] →* i322[6])∧(i42[7] →* i42[6]))


(7) -> (10), if ((i322[7] →* i322[10])∧(i42[7] →* i322[10]))


(8) -> (9), if ((i322[8] →* i322[9])∧(i322[8] > 0 →* TRUE))


(9) -> (2), if ((i322[9] →* i42[2])∧(0 →* i42[2]))


(9) -> (6), if ((i322[9] →* i42[6])∧(0 →* i322[6]))


(9) -> (10), if ((i322[9] →* i322[10])∧(0 →* i322[10]))


(10) -> (11), if ((i322[10] > 0 →* TRUE)∧(i322[10] →* i322[11]))


(11) -> (2), if ((i322[11] →* i42[2])∧(0 →* i42[2]))


(11) -> (6), if ((i322[11] →* i42[6])∧(0 →* i322[6]))


(11) -> (10), if ((0 →* i322[10])∧(i322[11] →* i322[10]))



The set Q consists of the following terms:
Cond_NE1621(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP1257(TRUE, x0, x0, x0)
NE1621(x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE16211(TRUE, x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
JMP1257(x0, x0, x1)
Cond_JMP12571(TRUE, x0, x0, x1)
Cond_NE16212(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP12572(TRUE, x0, x0, x0)

(86) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(87) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(i42[0] > 0 && !(i42[0] = i42[0]), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])
(1): COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])
(2): JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(i42[2] > 0 && !(i42[2] = i42[2]), i42[2], i42[2], i42[2])
(3): COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])
(4): NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(i322[4] < i42[4] && i42[4] <= i322[4] && i322[4] > 0, i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])
(5): COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5])
(6): JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(i322[6] < i42[6] && i42[6] <= i322[6] && i42[6] > 0 && !(i322[6] = 0), i42[6], i42[6], i322[6])
(7): COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7])
(8): NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(i322[8] > 0, i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])
(9): COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0)
(10): JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(i322[10] > 0, i322[10], i322[10], i322[10])
(11): COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0)

(0) -> (1), if ((i42[0] →* i42[1])∧(i42[0] > 0 && !(i42[0] = i42[0]) →* TRUE))


(1) -> (0), if ((i42[1] →* i42[0]))


(1) -> (4), if ((i42[1] →* i42[4])∧(i42[1] →* i322[4]))


(1) -> (8), if ((i42[1] →* i322[8]))


(2) -> (3), if ((i42[2] →* i42[3])∧(i42[2] > 0 && !(i42[2] = i42[2]) →* TRUE))


(3) -> (0), if ((i42[3] →* i42[0]))


(3) -> (4), if ((i42[3] →* i42[4])∧(i42[3] →* i322[4]))


(3) -> (8), if ((i42[3] →* i322[8]))


(4) -> (5), if ((i322[4] →* i322[5])∧(i42[4] →* i42[5])∧(i322[4] < i42[4] && i42[4] <= i322[4] && i322[4] > 0 →* TRUE))


(5) -> (2), if ((i42[5] →* i42[2])∧(i322[5] →* i42[2]))


(5) -> (6), if ((i322[5] →* i322[6])∧(i42[5] →* i42[6]))


(5) -> (10), if ((i42[5] →* i322[10])∧(i322[5] →* i322[10]))


(6) -> (7), if ((i322[6] < i42[6] && i42[6] <= i322[6] && i42[6] > 0 && !(i322[6] = 0) →* TRUE)∧(i322[6] →* i322[7])∧(i42[6] →* i42[7]))


(7) -> (2), if ((i322[7] →* i42[2])∧(i42[7] →* i42[2]))


(7) -> (6), if ((i322[7] →* i322[6])∧(i42[7] →* i42[6]))


(7) -> (10), if ((i322[7] →* i322[10])∧(i42[7] →* i322[10]))


(8) -> (9), if ((i322[8] →* i322[9])∧(i322[8] > 0 →* TRUE))


(9) -> (2), if ((i322[9] →* i42[2])∧(0 →* i42[2]))


(9) -> (6), if ((i322[9] →* i42[6])∧(0 →* i322[6]))


(9) -> (10), if ((i322[9] →* i322[10])∧(0 →* i322[10]))


(10) -> (11), if ((i322[10] > 0 →* TRUE)∧(i322[10] →* i322[11]))


(11) -> (2), if ((i322[11] →* i42[2])∧(0 →* i42[2]))


(11) -> (6), if ((i322[11] →* i42[6])∧(0 →* i322[6]))


(11) -> (10), if ((0 →* i322[10])∧(i322[11] →* i322[10]))



The set Q consists of the following terms:
Cond_NE1621(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP1257(TRUE, x0, x0, x0)
NE1621(x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE16211(TRUE, x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
JMP1257(x0, x0, x1)
Cond_JMP12571(TRUE, x0, x0, x1)
Cond_NE16212(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP12572(TRUE, x0, x0, x0)

(88) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → COND_NE1621(&&(>(i42, 0), !(=(i42, i42))), i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) the following chains were created:
  • We consider the chain NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]), COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) which results in the following constraint:

    (1)    (i42[0]=i42[1]∧&&(>(i42[0], 0), !(=(i42[0], i42[0])))=TRUE ⇒ NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥NonInfC∧NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])∧(UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (2)    (>(i42[0], 0)=TRUE∧<(i42[0], i42[0])=TRUE ⇒ NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥NonInfC∧NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])∧(UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥))


    (3)    (>(i42[0], 0)=TRUE∧>(i42[0], i42[0])=TRUE ⇒ NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥NonInfC∧NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])≥COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])∧(UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (4)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We simplified constraint (3) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (5)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We simplified constraint (4) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (6)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We simplified constraint (5) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (7)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We simplified constraint (6) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (8)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We simplified constraint (7) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (9)    (i42[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])), ≥)∧[(2)bni_75 + (-1)Bound*bni_75] + [(-2)bni_75]i42[0] ≥ 0∧[(-1)bso_76] ≥ 0)



    We solved constraint (8) using rule (IDP_SMT_SPLIT).We solved constraint (9) using rule (IDP_SMT_SPLIT).




For Pair COND_NE1621(TRUE, i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) the following chains were created:
  • We consider the chain COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]), NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) which results in the following constraint:

    (10)    (i42[1]=i42[0] ⇒ COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (10) using rule (IV) which results in the following new constraint:

    (11)    (COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (11) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (12)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (12) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (13)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (13) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (14)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (14) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (15)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)



  • We consider the chain COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]), NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) which results in the following constraint:

    (16)    (i42[1]=i42[4]∧i42[1]=i322[4] ⇒ COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (16) using rule (IV) which results in the following new constraint:

    (17)    (COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (17) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (18)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (18) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (19)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (19) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (20)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (20) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (21)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)



  • We consider the chain COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]), NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) which results in the following constraint:

    (22)    (i42[1]=i322[8] ⇒ COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (22) using rule (IV) which results in the following new constraint:

    (23)    (COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NonInfC∧COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])≥NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])∧(UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥))



    We simplified constraint (23) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (24)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (24) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (25)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (25) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (26)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧[(-1)bso_78] ≥ 0)



    We simplified constraint (26) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (27)    ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)







For Pair JMP1257'(i42, i42, i42) → COND_JMP1257(&&(>(i42, 0), !(=(i42, i42))), i42, i42, i42) the following chains were created:
  • We consider the chain JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2]), COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3]) which results in the following constraint:

    (28)    (i42[2]=i42[3]∧&&(>(i42[2], 0), !(=(i42[2], i42[2])))=TRUE ⇒ JMP1257'(i42[2], i42[2], i42[2])≥NonInfC∧JMP1257'(i42[2], i42[2], i42[2])≥COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])∧(UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥))



    We simplified constraint (28) using rules (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (29)    (>(i42[2], 0)=TRUE∧<(i42[2], i42[2])=TRUE ⇒ JMP1257'(i42[2], i42[2], i42[2])≥NonInfC∧JMP1257'(i42[2], i42[2], i42[2])≥COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])∧(UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥))


    (30)    (>(i42[2], 0)=TRUE∧>(i42[2], i42[2])=TRUE ⇒ JMP1257'(i42[2], i42[2], i42[2])≥NonInfC∧JMP1257'(i42[2], i42[2], i42[2])≥COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])∧(UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥))



    We simplified constraint (29) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (31)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We simplified constraint (30) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (32)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We simplified constraint (31) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (33)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We simplified constraint (32) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (34)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We simplified constraint (33) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (35)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We simplified constraint (34) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (36)    (i42[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])), ≥)∧[(-1)bni_79 + (-1)Bound*bni_79] ≥ 0∧[-3 + (-1)bso_80] + [2]i42[2] ≥ 0)



    We solved constraint (35) using rule (IDP_SMT_SPLIT).We solved constraint (36) using rule (IDP_SMT_SPLIT).




For Pair COND_JMP1257(TRUE, i42, i42, i42) → NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) the following chains were created:
  • We consider the chain COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3]), NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) which results in the following constraint:

    (37)    (i42[3]=i42[0] ⇒ COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (37) using rule (IV) which results in the following new constraint:

    (38)    (COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (38) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (39)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (39) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (40)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (40) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (41)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (41) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (42)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)



  • We consider the chain COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3]), NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) which results in the following constraint:

    (43)    (i42[3]=i42[4]∧i42[3]=i322[4] ⇒ COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (43) using rule (IV) which results in the following new constraint:

    (44)    (COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (44) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (45)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (45) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (46)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (46) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (47)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (47) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (48)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)



  • We consider the chain COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3]), NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) which results in the following constraint:

    (49)    (i42[3]=i322[8] ⇒ COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (49) using rule (IV) which results in the following new constraint:

    (50)    (COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NonInfC∧COND_JMP1257(TRUE, i42[3], i42[3], i42[3])≥NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])∧(UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥))



    We simplified constraint (50) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (51)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (51) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (52)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (52) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (53)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧[(-1)bso_82] ≥ 0)



    We simplified constraint (53) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (54)    ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)







For Pair NE1621'(i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → COND_NE16211(&&(&&(<(i322, i42), <=(i42, i322)), >(i322, 0)), i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) the following chains were created:
  • We consider the chain NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]), COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5]) which results in the following constraint:

    (55)    (i322[4]=i322[5]∧i42[4]=i42[5]∧&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0))=TRUE ⇒ NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])≥NonInfC∧NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])≥COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])∧(UIncreasing(COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])), ≥))



    We simplified constraint (55) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (56)    (>(i322[4], 0)=TRUE∧<(i322[4], i42[4])=TRUE∧<=(i42[4], i322[4])=TRUE ⇒ NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])≥NonInfC∧NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])≥COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])∧(UIncreasing(COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])), ≥))



    We simplified constraint (56) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (57)    (i322[4] + [-1] ≥ 0∧i42[4] + [-1] + [-1]i322[4] ≥ 0∧i322[4] + [-1]i42[4] ≥ 0 ⇒ (UIncreasing(COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])), ≥)∧[(2)bni_83 + (-1)Bound*bni_83] + [(-1)bni_83]i322[4] + [(-1)bni_83]i42[4] ≥ 0∧[1 + (-1)bso_84] + [-3]i322[4] + i42[4] ≥ 0)



    We simplified constraint (57) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (58)    (i322[4] + [-1] ≥ 0∧i42[4] + [-1] + [-1]i322[4] ≥ 0∧i322[4] + [-1]i42[4] ≥ 0 ⇒ (UIncreasing(COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])), ≥)∧[(2)bni_83 + (-1)Bound*bni_83] + [(-1)bni_83]i322[4] + [(-1)bni_83]i42[4] ≥ 0∧[1 + (-1)bso_84] + [-3]i322[4] + i42[4] ≥ 0)



    We simplified constraint (58) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (59)    (i322[4] + [-1] ≥ 0∧i42[4] + [-1] + [-1]i322[4] ≥ 0∧i322[4] + [-1]i42[4] ≥ 0 ⇒ (UIncreasing(COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])), ≥)∧[(2)bni_83 + (-1)Bound*bni_83] + [(-1)bni_83]i322[4] + [(-1)bni_83]i42[4] ≥ 0∧[1 + (-1)bso_84] + [-3]i322[4] + i42[4] ≥ 0)



    We solved constraint (59) using rule (IDP_SMT_SPLIT).




For Pair COND_NE16211(TRUE, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → JMP1257'(i42, i42, i322) the following chains were created:
  • We consider the chain COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5]), JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2]) which results in the following constraint:

    (60)    (i42[5]=i42[2]∧i322[5]=i42[2] ⇒ COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥JMP1257'(i42[5], i42[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (60) using rule (III) which results in the following new constraint:

    (61)    (COND_NE16211(TRUE, i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5])≥JMP1257'(i322[5], i322[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (61) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (62)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (62) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (63)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (63) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (64)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (64) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (65)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧[(-1)bso_86] ≥ 0)



  • We consider the chain COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5]), JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6]) which results in the following constraint:

    (66)    (i322[5]=i322[6]∧i42[5]=i42[6] ⇒ COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥JMP1257'(i42[5], i42[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (66) using rule (IV) which results in the following new constraint:

    (67)    (COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥JMP1257'(i42[5], i42[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (67) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (68)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (68) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (69)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (69) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (70)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (70) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (71)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_86] ≥ 0)



  • We consider the chain COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5]), JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]) which results in the following constraint:

    (72)    (i42[5]=i322[10]∧i322[5]=i322[10] ⇒ COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5])≥JMP1257'(i42[5], i42[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (72) using rule (III) which results in the following new constraint:

    (73)    (COND_NE16211(TRUE, i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5])≥NonInfC∧COND_NE16211(TRUE, i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5], i322[5])≥JMP1257'(i322[5], i322[5], i322[5])∧(UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥))



    We simplified constraint (73) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (74)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (74) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (75)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (75) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (76)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧[(-1)bso_86] ≥ 0)



    We simplified constraint (76) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (77)    ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧[(-1)bso_86] ≥ 0)







For Pair JMP1257'(i42, i42, i322) → COND_JMP12571(&&(&&(&&(<(i322, i42), <=(i42, i322)), >(i42, 0)), !(=(i322, 0))), i42, i42, i322) the following chains were created:
  • We consider the chain JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6]), COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7]) which results in the following constraint:

    (78)    (&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0)))=TRUE∧i322[6]=i322[7]∧i42[6]=i42[7] ⇒ JMP1257'(i42[6], i42[6], i322[6])≥NonInfC∧JMP1257'(i42[6], i42[6], i322[6])≥COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])∧(UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥))



    We simplified constraint (78) using rules (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (79)    (>(i42[6], 0)=TRUE∧<(i322[6], i42[6])=TRUE∧<=(i42[6], i322[6])=TRUE∧<(i322[6], 0)=TRUE ⇒ JMP1257'(i42[6], i42[6], i322[6])≥NonInfC∧JMP1257'(i42[6], i42[6], i322[6])≥COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])∧(UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥))


    (80)    (>(i42[6], 0)=TRUE∧<(i322[6], i42[6])=TRUE∧<=(i42[6], i322[6])=TRUE∧>(i322[6], 0)=TRUE ⇒ JMP1257'(i42[6], i42[6], i322[6])≥NonInfC∧JMP1257'(i42[6], i42[6], i322[6])≥COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])∧(UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥))



    We simplified constraint (79) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (81)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧[-1] + [-1]i322[6] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We simplified constraint (80) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (82)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧i322[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We simplified constraint (81) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (83)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧[-1] + [-1]i322[6] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We simplified constraint (82) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (84)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧i322[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We simplified constraint (83) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (85)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧[-1] + [-1]i322[6] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We simplified constraint (84) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (86)    (i42[6] + [-1] ≥ 0∧i42[6] + [-1] + [-1]i322[6] ≥ 0∧i322[6] + [-1]i42[6] ≥ 0∧i322[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])), ≥)∧[(-1)bni_87 + (-1)Bound*bni_87] + [(2)bni_87]i322[6] + [(-2)bni_87]i42[6] ≥ 0∧[(-1)bso_88] ≥ 0)



    We solved constraint (85) using rule (IDP_SMT_SPLIT).We solved constraint (86) using rule (IDP_SMT_SPLIT).




For Pair COND_JMP12571(TRUE, i42, i42, i322) → JMP1257'(i42, i42, i322) the following chains were created:
  • We consider the chain COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7]), JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2]) which results in the following constraint:

    (87)    (i322[7]=i42[2]∧i42[7]=i42[2] ⇒ COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥JMP1257'(i42[7], i42[7], i322[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (87) using rule (III) which results in the following new constraint:

    (88)    (COND_JMP12571(TRUE, i42[7], i42[7], i42[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i42[7])≥JMP1257'(i42[7], i42[7], i42[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (88) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (89)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (89) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (90)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (90) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (91)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (91) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (92)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧[(-1)bso_90] ≥ 0)



  • We consider the chain COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7]), JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6]) which results in the following constraint:

    (93)    (i322[7]=i322[6]∧i42[7]=i42[6] ⇒ COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥JMP1257'(i42[7], i42[7], i322[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (93) using rule (IV) which results in the following new constraint:

    (94)    (COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥JMP1257'(i42[7], i42[7], i322[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (94) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (95)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (95) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (96)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (96) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (97)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (97) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (98)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_90] ≥ 0)



  • We consider the chain COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7]), JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]) which results in the following constraint:

    (99)    (i322[7]=i322[10]∧i42[7]=i322[10] ⇒ COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i322[7])≥JMP1257'(i42[7], i42[7], i322[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (99) using rule (III) which results in the following new constraint:

    (100)    (COND_JMP12571(TRUE, i42[7], i42[7], i42[7])≥NonInfC∧COND_JMP12571(TRUE, i42[7], i42[7], i42[7])≥JMP1257'(i42[7], i42[7], i42[7])∧(UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥))



    We simplified constraint (100) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (101)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (101) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (102)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (102) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (103)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧[(-1)bso_90] ≥ 0)



    We simplified constraint (103) using rule (IDP_UNRESTRICTED_VARS) which results in the following new constraint:

    (104)    ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧[(-1)bso_90] ≥ 0)







For Pair NE1621'(i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → COND_NE16212(>(i322, 0), i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) the following chains were created:
  • We consider the chain NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]), COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0) which results in the following constraint:

    (105)    (i322[8]=i322[9]∧>(i322[8], 0)=TRUE ⇒ NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥NonInfC∧NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])∧(UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥))



    We simplified constraint (105) using rule (IV) which results in the following new constraint:

    (106)    (>(i322[8], 0)=TRUE ⇒ NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥NonInfC∧NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])∧(UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥))



    We simplified constraint (106) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (107)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥)∧[(2)bni_91 + (-1)Bound*bni_91] + [(-2)bni_91]i322[8] ≥ 0∧[3 + (-1)bso_92] ≥ 0)



    We simplified constraint (107) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (108)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥)∧[(2)bni_91 + (-1)Bound*bni_91] + [(-2)bni_91]i322[8] ≥ 0∧[3 + (-1)bso_92] ≥ 0)



    We simplified constraint (108) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (109)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥)∧[(2)bni_91 + (-1)Bound*bni_91] + [(-2)bni_91]i322[8] ≥ 0∧[3 + (-1)bso_92] ≥ 0)



    We simplified constraint (109) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (110)    (i322[8] ≥ 0 ⇒ (UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥)∧[(-1)Bound*bni_91] + [(-2)bni_91]i322[8] ≥ 0∧[3 + (-1)bso_92] ≥ 0)







For Pair COND_NE16212(TRUE, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → JMP1257'(i322, i322, 0) the following chains were created:
  • We consider the chain NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]), COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0), JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2]) which results in the following constraint:

    (111)    (i322[8]=i322[9]∧>(i322[8], 0)=TRUE∧i322[9]=i42[2]∧0=i42[2] ⇒ COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥NonInfC∧COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥JMP1257'(i322[9], i322[9], 0)∧(UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥))



    We solved constraint (111) using rules (I), (II), (III), (IDP_CONSTANT_FOLD).
  • We consider the chain NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]), COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0), JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6]) which results in the following constraint:

    (112)    (i322[8]=i322[9]∧>(i322[8], 0)=TRUE∧i322[9]=i42[6]∧0=i322[6] ⇒ COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥NonInfC∧COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥JMP1257'(i322[9], i322[9], 0)∧(UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥))



    We simplified constraint (112) using rules (III), (IV) which results in the following new constraint:

    (113)    (>(i322[8], 0)=TRUE ⇒ COND_NE16212(TRUE, i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥NonInfC∧COND_NE16212(TRUE, i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])≥JMP1257'(i322[8], i322[8], 0)∧(UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥))



    We simplified constraint (113) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (114)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥)∧[(-1)bni_93 + (-1)Bound*bni_93] + [(-2)bni_93]i322[8] ≥ 0∧[(-1)bso_94] ≥ 0)



    We simplified constraint (114) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (115)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥)∧[(-1)bni_93 + (-1)Bound*bni_93] + [(-2)bni_93]i322[8] ≥ 0∧[(-1)bso_94] ≥ 0)



    We simplified constraint (115) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (116)    (i322[8] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥)∧[(-1)bni_93 + (-1)Bound*bni_93] + [(-2)bni_93]i322[8] ≥ 0∧[(-1)bso_94] ≥ 0)



    We simplified constraint (116) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (117)    (i322[8] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥)∧[(-3)bni_93 + (-1)Bound*bni_93] + [(-2)bni_93]i322[8] ≥ 0∧[(-1)bso_94] ≥ 0)



  • We consider the chain NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]), COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0), JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]) which results in the following constraint:

    (118)    (i322[8]=i322[9]∧>(i322[8], 0)=TRUE∧i322[9]=i322[10]∧0=i322[10] ⇒ COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥NonInfC∧COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9])≥JMP1257'(i322[9], i322[9], 0)∧(UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥))



    We solved constraint (118) using rules (I), (II), (III), (IDP_CONSTANT_FOLD).




For Pair JMP1257'(i322, i322, i322) → COND_JMP12572(>(i322, 0), i322, i322, i322) the following chains were created:
  • We consider the chain JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]), COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0) which results in the following constraint:

    (119)    (>(i322[10], 0)=TRUE∧i322[10]=i322[11] ⇒ JMP1257'(i322[10], i322[10], i322[10])≥NonInfC∧JMP1257'(i322[10], i322[10], i322[10])≥COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])∧(UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥))



    We simplified constraint (119) using rule (IV) which results in the following new constraint:

    (120)    (>(i322[10], 0)=TRUE ⇒ JMP1257'(i322[10], i322[10], i322[10])≥NonInfC∧JMP1257'(i322[10], i322[10], i322[10])≥COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])∧(UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥))



    We simplified constraint (120) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (121)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] ≥ 0∧[(-1)bso_96] + i322[10] ≥ 0)



    We simplified constraint (121) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (122)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] ≥ 0∧[(-1)bso_96] + i322[10] ≥ 0)



    We simplified constraint (122) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (123)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] ≥ 0∧[(-1)bso_96] + i322[10] ≥ 0)



    We simplified constraint (123) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (124)    (i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] ≥ 0∧[1 + (-1)bso_96] + i322[10] ≥ 0)







For Pair COND_JMP12572(TRUE, i322, i322, i322) → JMP1257'(i322, i322, 0) the following chains were created:
  • We consider the chain JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]), COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0), JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2]) which results in the following constraint:

    (125)    (>(i322[10], 0)=TRUE∧i322[10]=i322[11]∧i322[11]=i42[2]∧0=i42[2] ⇒ COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥NonInfC∧COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥JMP1257'(i322[11], i322[11], 0)∧(UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥))



    We solved constraint (125) using rules (I), (II), (III), (IDP_CONSTANT_FOLD).
  • We consider the chain JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]), COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0), JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6]) which results in the following constraint:

    (126)    (>(i322[10], 0)=TRUE∧i322[10]=i322[11]∧i322[11]=i42[6]∧0=i322[6] ⇒ COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥NonInfC∧COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥JMP1257'(i322[11], i322[11], 0)∧(UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥))



    We simplified constraint (126) using rules (III), (IV) which results in the following new constraint:

    (127)    (>(i322[10], 0)=TRUE ⇒ COND_JMP12572(TRUE, i322[10], i322[10], i322[10])≥NonInfC∧COND_JMP12572(TRUE, i322[10], i322[10], i322[10])≥JMP1257'(i322[10], i322[10], 0)∧(UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥))



    We simplified constraint (127) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (128)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥)∧[(-1)bni_97 + (-1)Bound*bni_97] + [(-1)bni_97]i322[10] ≥ 0∧[(-1)bso_98] + i322[10] ≥ 0)



    We simplified constraint (128) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (129)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥)∧[(-1)bni_97 + (-1)Bound*bni_97] + [(-1)bni_97]i322[10] ≥ 0∧[(-1)bso_98] + i322[10] ≥ 0)



    We simplified constraint (129) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (130)    (i322[10] + [-1] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥)∧[(-1)bni_97 + (-1)Bound*bni_97] + [(-1)bni_97]i322[10] ≥ 0∧[(-1)bso_98] + i322[10] ≥ 0)



    We simplified constraint (130) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (131)    (i322[10] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥)∧[(-2)bni_97 + (-1)Bound*bni_97] + [(-1)bni_97]i322[10] ≥ 0∧[1 + (-1)bso_98] + i322[10] ≥ 0)



  • We consider the chain JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]), COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0), JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10]) which results in the following constraint:

    (132)    (>(i322[10], 0)=TRUE∧i322[10]=i322[11]∧0=i322[10]1∧i322[11]=i322[10]1 ⇒ COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥NonInfC∧COND_JMP12572(TRUE, i322[11], i322[11], i322[11])≥JMP1257'(i322[11], i322[11], 0)∧(UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥))



    We solved constraint (132) using rules (I), (II), (III), (IDP_CONSTANT_FOLD).




To summarize, we get the following constraints P≥ for the following pairs.
  • NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → COND_NE1621(&&(>(i42, 0), !(=(i42, i42))), i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)

  • COND_NE1621(TRUE, i42, i42, i42, i42, i42, i42, i42, i42, i42, i42) → NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
    • ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)
    • ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)
    • ((UIncreasing(NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])), ≥)∧0 = 0∧[(-1)bso_78] ≥ 0)

  • JMP1257'(i42, i42, i42) → COND_JMP1257(&&(>(i42, 0), !(=(i42, i42))), i42, i42, i42)

  • COND_JMP1257(TRUE, i42, i42, i42) → NE1621'(i42, i42, i42, i42, i42, i42, i42, i42, i42, i42)
    • ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)
    • ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)
    • ((UIncreasing(NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])), ≥)∧0 = 0∧[(-1)bso_82] ≥ 0)

  • NE1621'(i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → COND_NE16211(&&(&&(<(i322, i42), <=(i42, i322)), >(i322, 0)), i42, i42, i322, i322, i42, i322, i42, i322, i42, i322)

  • COND_NE16211(TRUE, i42, i42, i322, i322, i42, i322, i42, i322, i42, i322) → JMP1257'(i42, i42, i322)
    • ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧[(-1)bso_86] ≥ 0)
    • ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_86] ≥ 0)
    • ((UIncreasing(JMP1257'(i42[5], i42[5], i322[5])), ≥)∧0 = 0∧[(-1)bso_86] ≥ 0)

  • JMP1257'(i42, i42, i322) → COND_JMP12571(&&(&&(&&(<(i322, i42), <=(i42, i322)), >(i42, 0)), !(=(i322, 0))), i42, i42, i322)

  • COND_JMP12571(TRUE, i42, i42, i322) → JMP1257'(i42, i42, i322)
    • ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧[(-1)bso_90] ≥ 0)
    • ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧0 = 0∧[(-1)bso_90] ≥ 0)
    • ((UIncreasing(JMP1257'(i42[7], i42[7], i322[7])), ≥)∧0 = 0∧[(-1)bso_90] ≥ 0)

  • NE1621'(i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → COND_NE16212(>(i322, 0), i322, i322, i322, i322, i322, i322, i322, i322, i322, i322)
    • (i322[8] ≥ 0 ⇒ (UIncreasing(COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])), ≥)∧[(-1)Bound*bni_91] + [(-2)bni_91]i322[8] ≥ 0∧[3 + (-1)bso_92] ≥ 0)

  • COND_NE16212(TRUE, i322, i322, i322, i322, i322, i322, i322, i322, i322, i322) → JMP1257'(i322, i322, 0)
    • (i322[8] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[9], i322[9], 0)), ≥)∧[(-3)bni_93 + (-1)Bound*bni_93] + [(-2)bni_93]i322[8] ≥ 0∧[(-1)bso_94] ≥ 0)

  • JMP1257'(i322, i322, i322) → COND_JMP12572(>(i322, 0), i322, i322, i322)
    • (i322[10] ≥ 0 ⇒ (UIncreasing(COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])), ≥)∧[(-1)bni_95 + (-1)Bound*bni_95] ≥ 0∧[1 + (-1)bso_96] + i322[10] ≥ 0)

  • COND_JMP12572(TRUE, i322, i322, i322) → JMP1257'(i322, i322, 0)
    • (i322[10] ≥ 0 ⇒ (UIncreasing(JMP1257'(i322[11], i322[11], 0)), ≥)∧[(-2)bni_97 + (-1)Bound*bni_97] + [(-1)bni_97]i322[10] ≥ 0∧[1 + (-1)bso_98] + i322[10] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = [1]   
POL(FALSE) = 0   
POL(NE1621'(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) = [2] + [-1]x10 + [-1]x9 + [-1]x8 + [-1]x7 + [-1]x6 + [-1]x5 + x4 + x3 + [2]x1   
POL(COND_NE1621(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) = [2] + [2]x11 + x10 + x8 + [-1]x7 + [-1]x6 + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(!(x1)) = [-1]   
POL(=(x1, x2)) = [-1]   
POL(JMP1257'(x1, x2, x3)) = [-1] + [2]x3 + [-1]x2 + [-1]x1   
POL(COND_JMP1257(x1, x2, x3, x4)) = [2] + [-1]x3 + [-1]x2   
POL(COND_NE16211(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) = [-1]x10 + [-1]x9 + [-1]x8 + [2]x7 + [-1]x6 + [-1]x5 + [2]x4 + x2 + [-1]x1   
POL(<(x1, x2)) = [-1]   
POL(<=(x1, x2)) = [-1]   
POL(COND_JMP12571(x1, x2, x3, x4)) = [-1] + [2]x4 + [-1]x3 + [-1]x2   
POL(COND_NE16212(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) = [-1] + [-1]x11 + [-1]x10 + [-1]x9 + [-1]x8 + [2]x7 + [2]x6 + x5 + [-1]x4 + [-1]x3 + [-1]x2   
POL(COND_JMP12572(x1, x2, x3, x4)) = [-1] + [-1]x4 + [-1]x3 + x2   

The following pairs are in P>:

NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])
JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])
NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])
JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])
NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(>(i322[8], 0), i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])
JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])
COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0)

The following pairs are in Pbound:

NE1621'(i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0]) → COND_NE1621(&&(>(i42[0], 0), !(=(i42[0], i42[0]))), i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0], i42[0])
JMP1257'(i42[2], i42[2], i42[2]) → COND_JMP1257(&&(>(i42[2], 0), !(=(i42[2], i42[2]))), i42[2], i42[2], i42[2])
NE1621'(i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4]) → COND_NE16211(&&(&&(<(i322[4], i42[4]), <=(i42[4], i322[4])), >(i322[4], 0)), i42[4], i42[4], i322[4], i322[4], i42[4], i322[4], i42[4], i322[4], i42[4], i322[4])
JMP1257'(i42[6], i42[6], i322[6]) → COND_JMP12571(&&(&&(&&(<(i322[6], i42[6]), <=(i42[6], i322[6])), >(i42[6], 0)), !(=(i322[6], 0))), i42[6], i42[6], i322[6])
JMP1257'(i322[10], i322[10], i322[10]) → COND_JMP12572(>(i322[10], 0), i322[10], i322[10], i322[10])

The following pairs are in P≥:

COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])
COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])
COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5])
COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7])
COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0)

There are no usable rules.

(89) Complex Obligation (AND)

(90) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])
(3): COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])
(5): COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5])
(7): COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7])
(9): COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0)


The set Q consists of the following terms:
Cond_NE1621(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP1257(TRUE, x0, x0, x0)
NE1621(x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE16211(TRUE, x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
JMP1257(x0, x0, x1)
Cond_JMP12571(TRUE, x0, x0, x1)
Cond_NE16212(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP12572(TRUE, x0, x0, x0)

(91) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 5 less nodes.

(92) TRUE

(93) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Integer


R is empty.

The integer pair graph contains the following rules and edges:
(1): COND_NE1621(TRUE, i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1]) → NE1621'(i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1], i42[1])
(3): COND_JMP1257(TRUE, i42[3], i42[3], i42[3]) → NE1621'(i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3], i42[3])
(5): COND_NE16211(TRUE, i42[5], i42[5], i322[5], i322[5], i42[5], i322[5], i42[5], i322[5], i42[5], i322[5]) → JMP1257'(i42[5], i42[5], i322[5])
(7): COND_JMP12571(TRUE, i42[7], i42[7], i322[7]) → JMP1257'(i42[7], i42[7], i322[7])
(8): NE1621'(i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8]) → COND_NE16212(i322[8] > 0, i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8], i322[8])
(9): COND_NE16212(TRUE, i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9], i322[9]) → JMP1257'(i322[9], i322[9], 0)
(11): COND_JMP12572(TRUE, i322[11], i322[11], i322[11]) → JMP1257'(i322[11], i322[11], 0)

(1) -> (8), if ((i42[1] →* i322[8]))


(3) -> (8), if ((i42[3] →* i322[8]))


(8) -> (9), if ((i322[8] →* i322[9])∧(i322[8] > 0 →* TRUE))



The set Q consists of the following terms:
Cond_NE1621(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP1257(TRUE, x0, x0, x0)
NE1621(x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE16211(TRUE, x0, x0, x1, x1, x0, x1, x0, x1, x0, x1)
JMP1257(x0, x0, x1)
Cond_JMP12571(TRUE, x0, x0, x1)
Cond_NE16212(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_JMP12572(TRUE, x0, x0, x0)

(94) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 7 less nodes.

(95) TRUE

(96) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
JMP1078(i42, i42, i42, i42, i88, i42) → Cond_JMP1078(i42 > 0 && i88 > i42, i42, i42, i42, i42, i88, i42)
Cond_JMP1078(TRUE, i42, i42, i42, i42, i88, i42) → JMP1078(i42, i42, i42, i42, i88 - i42, i42)
The set Q consists of the following terms:
JMP1078(x0, x0, x0, x0, x1, x0)
Cond_JMP1078(TRUE, x0, x0, x0, x0, x1, x0)

(97) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(98) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
JMP1078(i42, i42, i42, i42, i88, i42) → Cond_JMP1078(i42 > 0 && i88 > i42, i42, i42, i42, i42, i88, i42)
Cond_JMP1078(TRUE, i42, i42, i42, i42, i88, i42) → JMP1078(i42, i42, i42, i42, i88 - i42, i42)

The integer pair graph contains the following rules and edges:
(0): JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(i42[0] > 0 && i88[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])
(1): COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], i88[1] - i42[1], i42[1])

(0) -> (1), if ((i88[0] →* i88[1])∧(i42[0] →* i42[1])∧(i42[0] > 0 && i88[0] > i42[0] →* TRUE))


(1) -> (0), if ((i42[1] →* i42[0])∧(i88[1] - i42[1] →* i88[0]))



The set Q consists of the following terms:
JMP1078(x0, x0, x0, x0, x1, x0)
Cond_JMP1078(TRUE, x0, x0, x0, x0, x1, x0)

(99) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(100) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(i42[0] > 0 && i88[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])
(1): COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], i88[1] - i42[1], i42[1])

(0) -> (1), if ((i88[0] →* i88[1])∧(i42[0] →* i42[1])∧(i42[0] > 0 && i88[0] > i42[0] →* TRUE))


(1) -> (0), if ((i42[1] →* i42[0])∧(i88[1] - i42[1] →* i88[0]))



The set Q consists of the following terms:
JMP1078(x0, x0, x0, x0, x1, x0)
Cond_JMP1078(TRUE, x0, x0, x0, x0, x1, x0)

(101) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair JMP1078'(i42, i42, i42, i42, i88, i42) → COND_JMP1078(&&(>(i42, 0), >(i88, i42)), i42, i42, i42, i42, i88, i42) the following chains were created:
  • We consider the chain JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]), COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1]) which results in the following constraint:

    (1)    (i88[0]=i88[1]∧i42[0]=i42[1]∧&&(>(i42[0], 0), >(i88[0], i42[0]))=TRUE ⇒ JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])≥NonInfC∧JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])≥COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])∧(UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥))



    We simplified constraint (1) using rules (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (2)    (>(i42[0], 0)=TRUE∧>(i88[0], i42[0])=TRUE ⇒ JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])≥NonInfC∧JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])≥COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])∧(UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (3)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (3) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (4)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (4) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (5)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (5) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (6)    (i42[0] ≥ 0∧i88[0] + [-2] + [-1]i42[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-3)bni_20 + (-1)Bound*bni_20] + [(-2)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)



    We simplified constraint (6) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (7)    (i42[0] ≥ 0∧i88[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)







For Pair COND_JMP1078(TRUE, i42, i42, i42, i42, i88, i42) → JMP1078'(i42, i42, i42, i42, -(i88, i42), i42) the following chains were created:
  • We consider the chain JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]), COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1]), JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]), COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1]), JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]), COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1]) which results in the following constraint:

    (8)    (i88[0]=i88[1]∧i42[0]=i42[1]∧&&(>(i42[0], 0), >(i88[0], i42[0]))=TRUE∧i42[1]=i42[0]1∧-(i88[1], i42[1])=i88[0]1∧i88[0]1=i88[1]1∧i42[0]1=i42[1]1∧&&(>(i42[0]1, 0), >(i88[0]1, i42[0]1))=TRUE∧i42[1]1=i42[0]2∧-(i88[1]1, i42[1]1)=i88[0]2∧i88[0]2=i88[1]2∧i42[0]2=i42[1]2∧&&(>(i42[0]2, 0), >(i88[0]2, i42[0]2))=TRUE ⇒ COND_JMP1078(TRUE, i42[1]1, i42[1]1, i42[1]1, i42[1]1, i88[1]1, i42[1]1)≥NonInfC∧COND_JMP1078(TRUE, i42[1]1, i42[1]1, i42[1]1, i42[1]1, i88[1]1, i42[1]1)≥JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)∧(UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥))



    We simplified constraint (8) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (9)    (>(i42[0], 0)=TRUE∧>(i88[0], i42[0])=TRUE∧>(-(i88[0], i42[0]), i42[0])=TRUE∧>(-(-(i88[0], i42[0]), i42[0]), i42[0])=TRUE ⇒ COND_JMP1078(TRUE, i42[0], i42[0], i42[0], i42[0], -(i88[0], i42[0]), i42[0])≥NonInfC∧COND_JMP1078(TRUE, i42[0], i42[0], i42[0], i42[0], -(i88[0], i42[0]), i42[0])≥JMP1078'(i42[0], i42[0], i42[0], i42[0], -(-(i88[0], i42[0]), i42[0]), i42[0])∧(UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥))



    We simplified constraint (9) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (10)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0∧i88[0] + [-1] + [-2]i42[0] ≥ 0∧i88[0] + [-1] + [-3]i42[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)bni_22 + (-1)Bound*bni_22] + [(-3)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[(-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (10) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (11)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0∧i88[0] + [-1] + [-2]i42[0] ≥ 0∧i88[0] + [-1] + [-3]i42[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)bni_22 + (-1)Bound*bni_22] + [(-3)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[(-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (11) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (12)    (i42[0] + [-1] ≥ 0∧i88[0] + [-1] + [-1]i42[0] ≥ 0∧i88[0] + [-1] + [-2]i42[0] ≥ 0∧i88[0] + [-1] + [-3]i42[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)bni_22 + (-1)Bound*bni_22] + [(-3)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[(-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (12) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (13)    (i42[0] ≥ 0∧i88[0] + [-2] + [-1]i42[0] ≥ 0∧i88[0] + [-3] + [-2]i42[0] ≥ 0∧i88[0] + [-4] + [-3]i42[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-4)bni_22 + (-1)Bound*bni_22] + [(-3)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[1 + (-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (13) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (14)    (i42[0] ≥ 0∧i88[0] ≥ 0∧[-1] + [-1]i42[0] + i88[0] ≥ 0∧[-2] + [-2]i42[0] + i88[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-2)bni_22 + (-1)Bound*bni_22] + [(-2)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[1 + (-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (14) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (15)    (i42[0] ≥ 0∧[1] + i42[0] + i88[0] ≥ 0∧i88[0] ≥ 0∧[-1] + [-1]i42[0] + i88[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)bni_22 + (-1)Bound*bni_22] + [(-1)bni_22]i42[0] + [bni_22]i88[0] ≥ 0∧[1 + (-1)bso_23] + i42[0] ≥ 0)



    We simplified constraint (15) using rule (IDP_SMT_SPLIT) which results in the following new constraint:

    (16)    (i42[0] ≥ 0∧[2] + [2]i42[0] + i88[0] ≥ 0∧[1] + i42[0] + i88[0] ≥ 0∧i88[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)Bound*bni_22] + [bni_22]i88[0] ≥ 0∧[1 + (-1)bso_23] + i42[0] ≥ 0)







To summarize, we get the following constraints P≥ for the following pairs.
  • JMP1078'(i42, i42, i42, i42, i88, i42) → COND_JMP1078(&&(>(i42, 0), >(i88, i42)), i42, i42, i42, i42, i88, i42)
    • (i42[0] ≥ 0∧i88[0] ≥ 0 ⇒ (UIncreasing(COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])), ≥)∧[(-1)bni_20 + (-1)Bound*bni_20] + [(-1)bni_20]i42[0] + [bni_20]i88[0] ≥ 0∧[(-1)bso_21] ≥ 0)

  • COND_JMP1078(TRUE, i42, i42, i42, i42, i88, i42) → JMP1078'(i42, i42, i42, i42, -(i88, i42), i42)
    • (i42[0] ≥ 0∧[2] + [2]i42[0] + i88[0] ≥ 0∧[1] + i42[0] + i88[0] ≥ 0∧i88[0] ≥ 0 ⇒ (UIncreasing(JMP1078'(i42[1]1, i42[1]1, i42[1]1, i42[1]1, -(i88[1]1, i42[1]1), i42[1]1)), ≥)∧[(-1)Bound*bni_22] + [bni_22]i88[0] ≥ 0∧[1 + (-1)bso_23] + i42[0] ≥ 0)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = [1]   
POL(FALSE) = [3]   
POL(JMP1078'(x1, x2, x3, x4, x5, x6)) = [-1] + x6 + x5 + [-1]x4 + [-1]x3 + [-1]x2   
POL(COND_JMP1078(x1, x2, x3, x4, x5, x6, x7)) = [-1] + x6 + [-1]x4 + [-1]x2   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(-(x1, x2)) = x1 + [-1]x2   

The following pairs are in P>:

COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1])

The following pairs are in Pbound:

COND_JMP1078(TRUE, i42[1], i42[1], i42[1], i42[1], i88[1], i42[1]) → JMP1078'(i42[1], i42[1], i42[1], i42[1], -(i88[1], i42[1]), i42[1])

The following pairs are in P≥:

JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(&&(>(i42[0], 0), >(i88[0], i42[0])), i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])

At least the following rules have been oriented under context sensitive arithmetic replacement:

TRUE1 → &&(TRUE, TRUE)1
FALSE1 → &&(TRUE, FALSE)1
FALSE1 → &&(FALSE, TRUE)1
FALSE1 → &&(FALSE, FALSE)1

(102) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): JMP1078'(i42[0], i42[0], i42[0], i42[0], i88[0], i42[0]) → COND_JMP1078(i42[0] > 0 && i88[0] > i42[0], i42[0], i42[0], i42[0], i42[0], i88[0], i42[0])


The set Q consists of the following terms:
JMP1078(x0, x0, x0, x0, x1, x0)
Cond_JMP1078(TRUE, x0, x0, x0, x0, x1, x0)

(103) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 1 less node.

(104) TRUE

(105) Obligation:

ITRS problem:

The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean

The TRS R consists of the following rules:
NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → Cond_NE884(i40 > 0 && !(i40 = i40), i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
Cond_NE884(TRUE, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
Load683(i40, i40, i40, i40) → Cond_Load683(i40 > 0 && !(i40 = i40), i40, i40, i40, i40)
Cond_Load683(TRUE, i40, i40, i40, i40) → NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
NE884(i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → Cond_NE8841(i42 < i40 && i40 <= i42 && i42 > 0, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42)
Cond_NE8841(TRUE, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → Load683(i40, i42, i40, i42)
Load683(i40, i42, i40, i42) → Cond_Load6831(i42 < i40 && i40 <= i42 && i40 > 0 && !(i42 = 0), i40, i42, i40, i42)
Cond_Load6831(TRUE, i40, i42, i40, i42) → Load683(i40, i42, i40, i42)
The set Q consists of the following terms:
Cond_NE884(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_Load683(TRUE, x0, x0, x0, x0)
NE884(x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE8841(TRUE, x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Load683(x0, x1, x0, x1)
Cond_Load6831(TRUE, x0, x1, x0, x1)

(106) ITRStoIDPProof (EQUIVALENT transformation)

Added dependency pairs

(107) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


The ITRS R consists of the following rules:
NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → Cond_NE884(i40 > 0 && !(i40 = i40), i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
Cond_NE884(TRUE, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
Load683(i40, i40, i40, i40) → Cond_Load683(i40 > 0 && !(i40 = i40), i40, i40, i40, i40)
Cond_Load683(TRUE, i40, i40, i40, i40) → NE884(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)
NE884(i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → Cond_NE8841(i42 < i40 && i40 <= i42 && i42 > 0, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42)
Cond_NE8841(TRUE, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → Load683(i40, i42, i40, i42)
Load683(i40, i42, i40, i42) → Cond_Load6831(i42 < i40 && i40 <= i42 && i40 > 0 && !(i42 = 0), i40, i42, i40, i42)
Cond_Load6831(TRUE, i40, i42, i40, i42) → Load683(i40, i42, i40, i42)

The integer pair graph contains the following rules and edges:
(0): NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(i40[0] > 0 && !(i40[0] = i40[0]), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])
(1): COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])
(2): LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(i40[2] > 0 && !(i40[2] = i40[2]), i40[2], i40[2], i40[2], i40[2])
(3): COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])
(4): NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(i42[4] < i40[4] && i40[4] <= i42[4] && i42[4] > 0, i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])
(5): COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5])
(6): LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(i42[6] < i40[6] && i40[6] <= i42[6] && i40[6] > 0 && !(i42[6] = 0), i40[6], i42[6], i40[6], i42[6])
(7): COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7])

(0) -> (1), if ((i40[0] > 0 && !(i40[0] = i40[0]) →* TRUE)∧(i40[0] →* i40[1]))


(1) -> (0), if ((i40[1] →* i40[0]))


(1) -> (4), if ((i40[1] →* i40[4])∧(i40[1] →* i42[4]))


(2) -> (3), if ((i40[2] →* i40[3])∧(i40[2] > 0 && !(i40[2] = i40[2]) →* TRUE))


(3) -> (0), if ((i40[3] →* i40[0]))


(3) -> (4), if ((i40[3] →* i40[4])∧(i40[3] →* i42[4]))


(4) -> (5), if ((i40[4] →* i40[5])∧(i42[4] →* i42[5])∧(i42[4] < i40[4] && i40[4] <= i42[4] && i42[4] > 0 →* TRUE))


(5) -> (2), if ((i40[5] →* i40[2])∧(i42[5] →* i40[2]))


(5) -> (6), if ((i42[5] →* i42[6])∧(i40[5] →* i40[6]))


(6) -> (7), if ((i42[6] →* i42[7])∧(i42[6] < i40[6] && i40[6] <= i42[6] && i40[6] > 0 && !(i42[6] = 0) →* TRUE)∧(i40[6] →* i40[7]))


(7) -> (2), if ((i40[7] →* i40[2])∧(i42[7] →* i40[2]))


(7) -> (6), if ((i40[7] →* i40[6])∧(i42[7] →* i42[6]))



The set Q consists of the following terms:
Cond_NE884(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_Load683(TRUE, x0, x0, x0, x0)
NE884(x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE8841(TRUE, x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Load683(x0, x1, x0, x1)
Cond_Load6831(TRUE, x0, x1, x0, x1)

(108) UsableRulesProof (EQUIVALENT transformation)

As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [LPAR04] we can delete all non-usable rules [FROCOS05] from R.

(109) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:

Boolean, Integer


R is empty.

The integer pair graph contains the following rules and edges:
(0): NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(i40[0] > 0 && !(i40[0] = i40[0]), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])
(1): COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])
(2): LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(i40[2] > 0 && !(i40[2] = i40[2]), i40[2], i40[2], i40[2], i40[2])
(3): COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])
(4): NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(i42[4] < i40[4] && i40[4] <= i42[4] && i42[4] > 0, i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])
(5): COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5])
(6): LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(i42[6] < i40[6] && i40[6] <= i42[6] && i40[6] > 0 && !(i42[6] = 0), i40[6], i42[6], i40[6], i42[6])
(7): COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7])

(0) -> (1), if ((i40[0] > 0 && !(i40[0] = i40[0]) →* TRUE)∧(i40[0] →* i40[1]))


(1) -> (0), if ((i40[1] →* i40[0]))


(1) -> (4), if ((i40[1] →* i40[4])∧(i40[1] →* i42[4]))


(2) -> (3), if ((i40[2] →* i40[3])∧(i40[2] > 0 && !(i40[2] = i40[2]) →* TRUE))


(3) -> (0), if ((i40[3] →* i40[0]))


(3) -> (4), if ((i40[3] →* i40[4])∧(i40[3] →* i42[4]))


(4) -> (5), if ((i40[4] →* i40[5])∧(i42[4] →* i42[5])∧(i42[4] < i40[4] && i40[4] <= i42[4] && i42[4] > 0 →* TRUE))


(5) -> (2), if ((i40[5] →* i40[2])∧(i42[5] →* i40[2]))


(5) -> (6), if ((i42[5] →* i42[6])∧(i40[5] →* i40[6]))


(6) -> (7), if ((i42[6] →* i42[7])∧(i42[6] < i40[6] && i40[6] <= i42[6] && i40[6] > 0 && !(i42[6] = 0) →* TRUE)∧(i40[6] →* i40[7]))


(7) -> (2), if ((i40[7] →* i40[2])∧(i42[7] →* i40[2]))


(7) -> (6), if ((i40[7] →* i40[6])∧(i42[7] →* i42[6]))



The set Q consists of the following terms:
Cond_NE884(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_Load683(TRUE, x0, x0, x0, x0)
NE884(x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE8841(TRUE, x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Load683(x0, x1, x0, x1)
Cond_Load6831(TRUE, x0, x1, x0, x1)

(110) IDPNonInfProof (SOUND transformation)

The constraints were generated the following way:
The DP Problem is simplified using the Induction Calculus [NONINF] with the following steps:
Note that final constraints are written in bold face.


For Pair NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → COND_NE884(&&(>(i40, 0), !(=(i40, i40))), i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) the following chains were created:
  • We consider the chain COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]), NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]), COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) which results in the following constraint:

    (1)    (i40[1]=i40[0]∧&&(>(i40[0], 0), !(=(i40[0], i40[0])))=TRUE∧i40[0]=i40[1]1 ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))



    We simplified constraint (1) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (2)    (>(i40[0], 0)=TRUE∧<(i40[0], i40[0])=TRUE ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))


    (3)    (>(i40[0], 0)=TRUE∧>(i40[0], i40[0])=TRUE ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))



    We simplified constraint (2) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (4)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (3) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (5)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (4) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (6)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (5) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (7)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (6) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (8)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (7) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (9)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We solved constraint (8) using rule (IDP_SMT_SPLIT).We solved constraint (9) using rule (IDP_SMT_SPLIT).
  • We consider the chain COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]), NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]), COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) which results in the following constraint:

    (10)    (i40[3]=i40[0]∧&&(>(i40[0], 0), !(=(i40[0], i40[0])))=TRUE∧i40[0]=i40[1] ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))



    We simplified constraint (10) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (11)    (>(i40[0], 0)=TRUE∧<(i40[0], i40[0])=TRUE ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))


    (12)    (>(i40[0], 0)=TRUE∧>(i40[0], i40[0])=TRUE ⇒ NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥))



    We simplified constraint (11) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (13)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (12) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (14)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (13) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (15)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (14) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (16)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (15) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (17)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We simplified constraint (16) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (18)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])), ≥)∧[(-1)bni_64 + (-1)Bound*bni_64] + [(-11)bni_64]i40[0] ≥ 0∧[-1 + (-1)bso_65] ≥ 0)



    We solved constraint (17) using rule (IDP_SMT_SPLIT).We solved constraint (18) using rule (IDP_SMT_SPLIT).




For Pair COND_NE884(TRUE, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) the following chains were created:
  • We consider the chain NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]), COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]), NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) which results in the following constraint:

    (19)    (&&(>(i40[0], 0), !(=(i40[0], i40[0])))=TRUE∧i40[0]=i40[1]∧i40[1]=i40[0]1 ⇒ COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])≥NonInfC∧COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])≥NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))



    We simplified constraint (19) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (20)    (>(i40[0], 0)=TRUE∧<(i40[0], i40[0])=TRUE ⇒ COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))


    (21)    (>(i40[0], 0)=TRUE∧>(i40[0], i40[0])=TRUE ⇒ COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))



    We simplified constraint (20) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (22)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (21) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (23)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (22) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (24)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (23) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (25)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (24) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (26)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (25) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (27)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We solved constraint (26) using rule (IDP_SMT_SPLIT).We solved constraint (27) using rule (IDP_SMT_SPLIT).
  • We consider the chain NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]), COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]), NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) which results in the following constraint:

    (28)    (&&(>(i40[0], 0), !(=(i40[0], i40[0])))=TRUE∧i40[0]=i40[1]∧i40[1]=i40[4]∧i40[1]=i42[4] ⇒ COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])≥NonInfC∧COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])≥NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))



    We simplified constraint (28) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (29)    (>(i40[0], 0)=TRUE∧<(i40[0], i40[0])=TRUE ⇒ COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))


    (30)    (>(i40[0], 0)=TRUE∧>(i40[0], i40[0])=TRUE ⇒ COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NonInfC∧COND_NE884(TRUE, i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])≥NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])∧(UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥))



    We simplified constraint (29) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (31)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (30) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (32)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (31) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (33)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (32) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (34)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (33) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (35)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We simplified constraint (34) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (36)    (i40[0] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])), ≥)∧[(-1)bni_66 + (-1)Bound*bni_66] + [(-11)bni_66]i40[0] ≥ 0∧[(-1)bso_67] ≥ 0)



    We solved constraint (35) using rule (IDP_SMT_SPLIT).We solved constraint (36) using rule (IDP_SMT_SPLIT).




For Pair LOAD683(i40, i40, i40, i40) → COND_LOAD683(&&(>(i40, 0), !(=(i40, i40))), i40, i40, i40, i40) the following chains were created:
  • We consider the chain COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]), LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]), COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]) which results in the following constraint:

    (37)    (i40[5]=i40[2]∧i42[5]=i40[2]∧i40[2]=i40[3]∧&&(>(i40[2], 0), !(=(i40[2], i40[2])))=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))



    We simplified constraint (37) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (38)    (>(i40[2], 0)=TRUE∧<(i40[2], i40[2])=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))


    (39)    (>(i40[2], 0)=TRUE∧>(i40[2], i40[2])=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))



    We simplified constraint (38) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (40)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (39) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (41)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (40) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (42)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (41) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (43)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (42) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (44)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (43) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (45)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We solved constraint (44) using rule (IDP_SMT_SPLIT).We solved constraint (45) using rule (IDP_SMT_SPLIT).
  • We consider the chain COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]), LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]), COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]) which results in the following constraint:

    (46)    (i40[7]=i40[2]∧i42[7]=i40[2]∧i40[2]=i40[3]∧&&(>(i40[2], 0), !(=(i40[2], i40[2])))=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))



    We simplified constraint (46) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (47)    (>(i40[2], 0)=TRUE∧<(i40[2], i40[2])=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))


    (48)    (>(i40[2], 0)=TRUE∧>(i40[2], i40[2])=TRUE ⇒ LOAD683(i40[2], i40[2], i40[2], i40[2])≥NonInfC∧LOAD683(i40[2], i40[2], i40[2], i40[2])≥COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥))



    We simplified constraint (47) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (49)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (48) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (50)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (49) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (51)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (50) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (52)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (51) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (53)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We simplified constraint (52) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (54)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])), ≥)∧[(-1)bni_68 + (-1)Bound*bni_68] + [(-4)bni_68]i40[2] ≥ 0∧[-1 + (-1)bso_69] ≥ 0)



    We solved constraint (53) using rule (IDP_SMT_SPLIT).We solved constraint (54) using rule (IDP_SMT_SPLIT).




For Pair COND_LOAD683(TRUE, i40, i40, i40, i40) → NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) the following chains were created:
  • We consider the chain LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]), COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]), NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) which results in the following constraint:

    (55)    (i40[2]=i40[3]∧&&(>(i40[2], 0), !(=(i40[2], i40[2])))=TRUE∧i40[3]=i40[0] ⇒ COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3])≥NonInfC∧COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3])≥NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))



    We simplified constraint (55) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (56)    (>(i40[2], 0)=TRUE∧<(i40[2], i40[2])=TRUE ⇒ COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NonInfC∧COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NE884'(i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))


    (57)    (>(i40[2], 0)=TRUE∧>(i40[2], i40[2])=TRUE ⇒ COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NonInfC∧COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NE884'(i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))



    We simplified constraint (56) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (58)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (57) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (59)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (58) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (60)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (59) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (61)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (60) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (62)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (61) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (63)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We solved constraint (62) using rule (IDP_SMT_SPLIT).We solved constraint (63) using rule (IDP_SMT_SPLIT).
  • We consider the chain LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]), COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]), NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) which results in the following constraint:

    (64)    (i40[2]=i40[3]∧&&(>(i40[2], 0), !(=(i40[2], i40[2])))=TRUE∧i40[3]=i40[4]∧i40[3]=i42[4] ⇒ COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3])≥NonInfC∧COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3])≥NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))



    We simplified constraint (64) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (65)    (>(i40[2], 0)=TRUE∧<(i40[2], i40[2])=TRUE ⇒ COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NonInfC∧COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NE884'(i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))


    (66)    (>(i40[2], 0)=TRUE∧>(i40[2], i40[2])=TRUE ⇒ COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NonInfC∧COND_LOAD683(TRUE, i40[2], i40[2], i40[2], i40[2])≥NE884'(i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2], i40[2])∧(UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥))



    We simplified constraint (65) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (67)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (66) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (68)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (67) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (69)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (68) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (70)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (69) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (71)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We simplified constraint (70) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (72)    (i40[2] + [-1] ≥ 0∧[-1] ≥ 0 ⇒ (UIncreasing(NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])), ≥)∧[(-1)bni_70 + (-1)Bound*bni_70] + [(-4)bni_70]i40[2] ≥ 0∧[(-1)bso_71] + [7]i40[2] ≥ 0)



    We solved constraint (71) using rule (IDP_SMT_SPLIT).We solved constraint (72) using rule (IDP_SMT_SPLIT).




For Pair NE884'(i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → COND_NE8841(&&(&&(<(i42, i40), <=(i40, i42)), >(i42, 0)), i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) the following chains were created:
  • We consider the chain COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]), NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]), COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]) which results in the following constraint:

    (73)    (i40[1]=i40[4]∧i40[1]=i42[4]∧i40[4]=i40[5]∧i42[4]=i42[5]∧&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0))=TRUE ⇒ NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥NonInfC∧NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])∧(UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥))



    We simplified constraint (73) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (74)    (>(i40[4], 0)=TRUE∧<(i40[4], i40[4])=TRUE∧<=(i40[4], i40[4])=TRUE ⇒ NE884'(i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])≥NonInfC∧NE884'(i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])≥COND_NE8841(&&(&&(<(i40[4], i40[4]), <=(i40[4], i40[4])), >(i40[4], 0)), i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])∧(UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥))



    We simplified constraint (74) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (75)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We simplified constraint (75) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (76)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We simplified constraint (76) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (77)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We solved constraint (77) using rule (IDP_SMT_SPLIT).
  • We consider the chain COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3]), NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]), COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]) which results in the following constraint:

    (78)    (i40[3]=i40[4]∧i40[3]=i42[4]∧i40[4]=i40[5]∧i42[4]=i42[5]∧&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0))=TRUE ⇒ NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥NonInfC∧NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])∧(UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥))



    We simplified constraint (78) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (79)    (>(i40[4], 0)=TRUE∧<(i40[4], i40[4])=TRUE∧<=(i40[4], i40[4])=TRUE ⇒ NE884'(i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])≥NonInfC∧NE884'(i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])≥COND_NE8841(&&(&&(<(i40[4], i40[4]), <=(i40[4], i40[4])), >(i40[4], 0)), i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4], i40[4])∧(UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥))



    We simplified constraint (79) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (80)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We simplified constraint (80) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (81)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We simplified constraint (81) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (82)    (i40[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])), ≥)∧[(-1)bni_72 + (-1)Bound*bni_72] + [(-11)bni_72]i40[4] ≥ 0∧[-1 + (-1)bso_73] ≥ 0)



    We solved constraint (82) using rule (IDP_SMT_SPLIT).




For Pair COND_NE8841(TRUE, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → LOAD683(i40, i42, i40, i42) the following chains were created:
  • We consider the chain NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]), COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]), LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]) which results in the following constraint:

    (83)    (i40[4]=i40[5]∧i42[4]=i42[5]∧&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0))=TRUE∧i40[5]=i40[2]∧i42[5]=i40[2] ⇒ COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5])≥NonInfC∧COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5])≥LOAD683(i40[5], i42[5], i40[5], i42[5])∧(UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥))



    We simplified constraint (83) using rules (III), (IDP_BOOLEAN) which results in the following new constraint:

    (84)    (>(i42[4], 0)=TRUE∧<(i42[4], i42[4])=TRUE∧<=(i42[4], i42[4])=TRUE ⇒ COND_NE8841(TRUE, i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4])≥NonInfC∧COND_NE8841(TRUE, i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4], i42[4])≥LOAD683(i42[4], i42[4], i42[4], i42[4])∧(UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥))



    We simplified constraint (84) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (85)    (i42[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-11)bni_74]i42[4] ≥ 0∧[(-1)bso_75] + [-7]i42[4] ≥ 0)



    We simplified constraint (85) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (86)    (i42[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-11)bni_74]i42[4] ≥ 0∧[(-1)bso_75] + [-7]i42[4] ≥ 0)



    We simplified constraint (86) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (87)    (i42[4] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-11)bni_74]i42[4] ≥ 0∧[(-1)bso_75] + [-7]i42[4] ≥ 0)



    We solved constraint (87) using rule (IDP_SMT_SPLIT).
  • We consider the chain NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]), COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]), LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]) which results in the following constraint:

    (88)    (i40[4]=i40[5]∧i42[4]=i42[5]∧&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0))=TRUE∧i42[5]=i42[6]∧i40[5]=i40[6] ⇒ COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5])≥NonInfC∧COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5])≥LOAD683(i40[5], i42[5], i40[5], i42[5])∧(UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥))



    We simplified constraint (88) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraint:

    (89)    (>(i42[4], 0)=TRUE∧<(i42[4], i40[4])=TRUE∧<=(i40[4], i42[4])=TRUE ⇒ COND_NE8841(TRUE, i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥NonInfC∧COND_NE8841(TRUE, i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])≥LOAD683(i40[4], i42[4], i40[4], i42[4])∧(UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥))



    We simplified constraint (89) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (90)    (i42[4] + [-1] ≥ 0∧i40[4] + [-1] + [-1]i42[4] ≥ 0∧i42[4] + [-1]i40[4] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-6)bni_74]i42[4] + [(-5)bni_74]i40[4] ≥ 0∧[(-1)bso_75] + [-4]i42[4] + [-3]i40[4] ≥ 0)



    We simplified constraint (90) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (91)    (i42[4] + [-1] ≥ 0∧i40[4] + [-1] + [-1]i42[4] ≥ 0∧i42[4] + [-1]i40[4] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-6)bni_74]i42[4] + [(-5)bni_74]i40[4] ≥ 0∧[(-1)bso_75] + [-4]i42[4] + [-3]i40[4] ≥ 0)



    We simplified constraint (91) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (92)    (i42[4] + [-1] ≥ 0∧i40[4] + [-1] + [-1]i42[4] ≥ 0∧i42[4] + [-1]i40[4] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[5], i42[5], i40[5], i42[5])), ≥)∧[(-1)bni_74 + (-1)Bound*bni_74] + [(-6)bni_74]i42[4] + [(-5)bni_74]i40[4] ≥ 0∧[(-1)bso_75] + [-4]i42[4] + [-3]i40[4] ≥ 0)



    We solved constraint (92) using rule (IDP_SMT_SPLIT).




For Pair LOAD683(i40, i42, i40, i42) → COND_LOAD6831(&&(&&(&&(<(i42, i40), <=(i40, i42)), >(i40, 0)), !(=(i42, 0))), i40, i42, i40, i42) the following chains were created:
  • We consider the chain COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5]), LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]), COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]) which results in the following constraint:

    (93)    (i42[5]=i42[6]∧i40[5]=i40[6]∧i42[6]=i42[7]∧&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0)))=TRUE∧i40[6]=i40[7] ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))



    We simplified constraint (93) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (94)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧<(i42[6], 0)=TRUE ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))


    (95)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧>(i42[6], 0)=TRUE ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))



    We simplified constraint (94) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (96)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (95) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (97)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (96) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (98)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (97) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (99)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (98) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (100)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (99) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (101)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We solved constraint (100) using rule (IDP_SMT_SPLIT).We solved constraint (101) using rule (IDP_SMT_SPLIT).
  • We consider the chain COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]), LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]), COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]) which results in the following constraint:

    (102)    (i40[7]=i40[6]∧i42[7]=i42[6]∧i42[6]=i42[7]1∧&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0)))=TRUE∧i40[6]=i40[7]1 ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))



    We simplified constraint (102) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (103)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧<(i42[6], 0)=TRUE ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))


    (104)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧>(i42[6], 0)=TRUE ⇒ LOAD683(i40[6], i42[6], i40[6], i42[6])≥NonInfC∧LOAD683(i40[6], i42[6], i40[6], i42[6])≥COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥))



    We simplified constraint (103) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (105)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (104) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (106)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (105) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (107)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (106) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (108)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (107) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (109)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We simplified constraint (108) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (110)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])), ≥)∧[(-1)bni_76 + (-1)Bound*bni_76] + [(-2)bni_76]i42[6] + [(-2)bni_76]i40[6] ≥ 0∧[-1 + (-1)bso_77] ≥ 0)



    We solved constraint (109) using rule (IDP_SMT_SPLIT).We solved constraint (110) using rule (IDP_SMT_SPLIT).




For Pair COND_LOAD6831(TRUE, i40, i42, i40, i42) → LOAD683(i40, i42, i40, i42) the following chains were created:
  • We consider the chain LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]), COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]), LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2]) which results in the following constraint:

    (111)    (i42[6]=i42[7]∧&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0)))=TRUE∧i40[6]=i40[7]∧i40[7]=i40[2]∧i42[7]=i40[2] ⇒ COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7])≥NonInfC∧COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7])≥LOAD683(i40[7], i42[7], i40[7], i42[7])∧(UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥))



    We simplified constraint (111) using rules (III), (IDP_BOOLEAN) which results in the following new constraint:

    (112)    (>(i42[6], 0)=TRUE∧<(i42[6], i42[6])=TRUE∧<=(i42[6], i42[6])=TRUE∧<(i42[6], 0)=TRUE ⇒ COND_LOAD6831(TRUE, i42[6], i42[6], i42[6], i42[6])≥NonInfC∧COND_LOAD6831(TRUE, i42[6], i42[6], i42[6], i42[6])≥LOAD683(i42[6], i42[6], i42[6], i42[6])∧(UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥))



    We simplified constraint (112) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (113)    (i42[6] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-4)bni_78]i42[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (114) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (115)    (i42[6] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-4)bni_78]i42[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (113) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (116)    (i42[6] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-4)bni_78]i42[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (115) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (117)    (i42[6] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-4)bni_78]i42[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (116) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (118)    (i42[6] + [-1] ≥ 0∧[-1] ≥ 0∧0 ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-4)bni_78]i42[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We solved constraint (117) using rule (IDP_SMT_SPLIT).We solved constraint (118) using rule (IDP_SMT_SPLIT).
  • We consider the chain LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]), COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7]), LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6]) which results in the following constraint:

    (119)    (i42[6]=i42[7]∧&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0)))=TRUE∧i40[6]=i40[7]∧i40[7]=i40[6]1∧i42[7]=i42[6]1 ⇒ COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7])≥NonInfC∧COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7])≥LOAD683(i40[7], i42[7], i40[7], i42[7])∧(UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥))



    We simplified constraint (119) using rules (III), (IV), (IDP_BOOLEAN) which results in the following new constraints:

    (120)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧<(i42[6], 0)=TRUE ⇒ COND_LOAD6831(TRUE, i40[6], i42[6], i40[6], i42[6])≥NonInfC∧COND_LOAD6831(TRUE, i40[6], i42[6], i40[6], i42[6])≥LOAD683(i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥))


    (121)    (>(i40[6], 0)=TRUE∧<(i42[6], i40[6])=TRUE∧<=(i40[6], i42[6])=TRUE∧>(i42[6], 0)=TRUE ⇒ COND_LOAD6831(TRUE, i40[6], i42[6], i40[6], i42[6])≥NonInfC∧COND_LOAD6831(TRUE, i40[6], i42[6], i40[6], i42[6])≥LOAD683(i40[6], i42[6], i40[6], i42[6])∧(UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥))



    We simplified constraint (120) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (122)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (121) using rule (POLY_CONSTRAINTS) which results in the following new constraint:

    (123)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (122) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (124)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (123) using rule (IDP_POLY_SIMPLIFY) which results in the following new constraint:

    (125)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (124) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (126)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧[-1] + [-1]i42[6] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We simplified constraint (125) using rule (POLY_REMOVE_MIN_MAX) which results in the following new constraint:

    (127)    (i40[6] + [-1] ≥ 0∧i40[6] + [-1] + [-1]i42[6] ≥ 0∧i42[6] + [-1]i40[6] ≥ 0∧i42[6] + [-1] ≥ 0 ⇒ (UIncreasing(LOAD683(i40[7], i42[7], i40[7], i42[7])), ≥)∧[(-1)bni_78 + (-1)Bound*bni_78] + [(-2)bni_78]i42[6] + [(-2)bni_78]i40[6] ≥ 0∧[(-1)bso_79] ≥ 0)



    We solved constraint (126) using rule (IDP_SMT_SPLIT).We solved constraint (127) using rule (IDP_SMT_SPLIT).




To summarize, we get the following constraints P≥ for the following pairs.
  • NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → COND_NE884(&&(>(i40, 0), !(=(i40, i40))), i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)

  • COND_NE884(TRUE, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40) → NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)

  • LOAD683(i40, i40, i40, i40) → COND_LOAD683(&&(>(i40, 0), !(=(i40, i40))), i40, i40, i40, i40)

  • COND_LOAD683(TRUE, i40, i40, i40, i40) → NE884'(i40, i40, i40, i40, i40, i40, i40, i40, i40, i40, i40)

  • NE884'(i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → COND_NE8841(&&(&&(<(i42, i40), <=(i40, i42)), >(i42, 0)), i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42)

  • COND_NE8841(TRUE, i40, i42, i40, i42, i42, i40, i42, i40, i42, i40, i42) → LOAD683(i40, i42, i40, i42)

  • LOAD683(i40, i42, i40, i42) → COND_LOAD6831(&&(&&(&&(<(i42, i40), <=(i40, i42)), >(i40, 0)), !(=(i42, 0))), i40, i42, i40, i42)

  • COND_LOAD6831(TRUE, i40, i42, i40, i42) → LOAD683(i40, i42, i40, i42)




The constraints for P> respective Pbound are constructed from P≥ where we just replace every occurence of "t ≥ s" in P≥ by "t > s" respective "t ≥ c". Here c stands for the fresh constant used for Pbound.
Using the following integer polynomial ordering the resulting constraints can be solved
Polynomial interpretation over integers[POLO]:

POL(TRUE) = 0   
POL(FALSE) = 0   
POL(NE884'(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) = [-1] + [-1]x11 + [-1]x10 + [-1]x9 + [-1]x8 + [-1]x7 + [-1]x6 + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(COND_NE884(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) = [-1] + [-1]x12 + [-1]x11 + [-1]x10 + [-1]x9 + [-1]x8 + [-1]x7 + [-1]x6 + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(&&(x1, x2)) = [-1]   
POL(>(x1, x2)) = [-1]   
POL(0) = 0   
POL(!(x1)) = [-1]   
POL(=(x1, x2)) = [-1]   
POL(LOAD683(x1, x2, x3, x4)) = [-1] + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(COND_LOAD683(x1, x2, x3, x4, x5)) = [-1] + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(COND_NE8841(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) = [-1] + [-1]x12 + [-1]x11 + [-1]x10 + [-1]x9 + [-1]x8 + [-1]x7 + [-1]x6 + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   
POL(<(x1, x2)) = [-1]   
POL(<=(x1, x2)) = [-1]   
POL(COND_LOAD6831(x1, x2, x3, x4, x5)) = [-1] + [-1]x5 + [-1]x4 + [-1]x3 + [-1]x2 + [-1]x1   

The following pairs are in P>:

NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])
COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])
LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])
COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])
NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])
COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5])
LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])
COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7])

The following pairs are in Pbound:

NE884'(i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0]) → COND_NE884(&&(>(i40[0], 0), !(=(i40[0], i40[0]))), i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0], i40[0])
COND_NE884(TRUE, i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1]) → NE884'(i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1], i40[1])
LOAD683(i40[2], i40[2], i40[2], i40[2]) → COND_LOAD683(&&(>(i40[2], 0), !(=(i40[2], i40[2]))), i40[2], i40[2], i40[2], i40[2])
COND_LOAD683(TRUE, i40[3], i40[3], i40[3], i40[3]) → NE884'(i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3], i40[3])
NE884'(i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4]) → COND_NE8841(&&(&&(<(i42[4], i40[4]), <=(i40[4], i42[4])), >(i42[4], 0)), i40[4], i42[4], i40[4], i42[4], i42[4], i40[4], i42[4], i40[4], i42[4], i40[4], i42[4])
COND_NE8841(TRUE, i40[5], i42[5], i40[5], i42[5], i42[5], i40[5], i42[5], i40[5], i42[5], i40[5], i42[5]) → LOAD683(i40[5], i42[5], i40[5], i42[5])
LOAD683(i40[6], i42[6], i40[6], i42[6]) → COND_LOAD6831(&&(&&(&&(<(i42[6], i40[6]), <=(i40[6], i42[6])), >(i40[6], 0)), !(=(i42[6], 0))), i40[6], i42[6], i40[6], i42[6])
COND_LOAD6831(TRUE, i40[7], i42[7], i40[7], i42[7]) → LOAD683(i40[7], i42[7], i40[7], i42[7])

The following pairs are in P≥:
none

There are no usable rules.

(111) Obligation:

IDP problem:
The following function symbols are pre-defined:
!=~Neq: (Integer, Integer) -> Boolean
*~Mul: (Integer, Integer) -> Integer
>=~Ge: (Integer, Integer) -> Boolean
-1~UnaryMinus: (Integer) -> Integer
|~Bwor: (Integer, Integer) -> Integer
/~Div: (Integer, Integer) -> Integer
=~Eq: (Integer, Integer) -> Boolean
~Bwxor: (Integer, Integer) -> Integer
||~Lor: (Boolean, Boolean) -> Boolean
!~Lnot: (Boolean) -> Boolean
<~Lt: (Integer, Integer) -> Boolean
-~Sub: (Integer, Integer) -> Integer
<=~Le: (Integer, Integer) -> Boolean
>~Gt: (Integer, Integer) -> Boolean
~~Bwnot: (Integer) -> Integer
%~Mod: (Integer, Integer) -> Integer
&~Bwand: (Integer, Integer) -> Integer
+~Add: (Integer, Integer) -> Integer
&&~Land: (Boolean, Boolean) -> Boolean


The following domains are used:
none


R is empty.

The integer pair graph is empty.

The set Q consists of the following terms:
Cond_NE884(TRUE, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0, x0)
Cond_Load683(TRUE, x0, x0, x0, x0)
NE884(x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Cond_NE8841(TRUE, x0, x1, x0, x1, x1, x0, x1, x0, x1, x0, x1)
Load683(x0, x1, x0, x1)
Cond_Load6831(TRUE, x0, x1, x0, x1)

(112) IDependencyGraphProof (EQUIVALENT transformation)

The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs.

(113) TRUE