(0) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
Q is empty.
(1) Overlay + Local Confluence (EQUIVALENT transformation)
The TRS is overlay and locally confluent. By [NOC] we can switch to innermost.
(2) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
(3) DependencyPairsProof (EQUIVALENT transformation)
Using Dependency Pairs [AG00,LPAR04] we result in the following initial DP problem.
(4) Obligation:
Q DP problem:
The TRS P consists of the following rules:
MINUS(s(x), y) → IF(gt(s(x), y), x, y)
MINUS(s(x), y) → GT(s(x), y)
IF(true, x, y) → MINUS(x, y)
GCD(x, y) → IF1(ge(x, y), x, y)
GCD(x, y) → GE(x, y)
IF1(true, x, y) → IF2(gt(y, 0), x, y)
IF1(true, x, y) → GT(y, 0)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF1(false, x, y) → GT(x, 0)
IF2(true, x, y) → GCD(minus(x, y), y)
IF2(true, x, y) → MINUS(x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
IF3(true, x, y) → MINUS(y, x)
GT(s(x), s(y)) → GT(x, y)
GE(s(x), s(y)) → GE(x, y)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(5) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 4 SCCs with 6 less nodes.
(6) Complex Obligation (AND)
(7) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GE(s(x), s(y)) → GE(x, y)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(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:
Q DP problem:
The TRS P consists of the following rules:
GE(s(x), s(y)) → GE(x, y)
R is empty.
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(10) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
(11) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GE(s(x), s(y)) → GE(x, y)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(12) QDPSizeChangeProof (EQUIVALENT transformation)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.
From the DPs we obtained the following set of size-change graphs:
- GE(s(x), s(y)) → GE(x, y)
The graph contains the following edges 1 > 1, 2 > 2
(13) YES
(14) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT(s(x), s(y)) → GT(x, y)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(15) 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.
(16) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT(s(x), s(y)) → GT(x, y)
R is empty.
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(17) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
(18) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GT(s(x), s(y)) → GT(x, y)
R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
(19) QDPSizeChangeProof (EQUIVALENT transformation)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.
From the DPs we obtained the following set of size-change graphs:
- GT(s(x), s(y)) → GT(x, y)
The graph contains the following edges 1 > 1, 2 > 2
(20) YES
(21) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF(true, x, y) → MINUS(x, y)
MINUS(s(x), y) → IF(gt(s(x), y), x, y)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(22) 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.
(23) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF(true, x, y) → MINUS(x, y)
MINUS(s(x), y) → IF(gt(s(x), y), x, y)
The TRS R consists of the following rules:
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
gt(0, y) → false
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(24) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
(25) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF(true, x, y) → MINUS(x, y)
MINUS(s(x), y) → IF(gt(s(x), y), x, y)
The TRS R consists of the following rules:
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
gt(0, y) → false
The set Q consists of the following terms:
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(26) QDPSizeChangeProof (EQUIVALENT transformation)
By using the subterm criterion [SUBTERM_CRITERION] together with the size-change analysis [AAECC05] we have proven that there are no infinite chains for this DP problem.
From the DPs we obtained the following set of size-change graphs:
- MINUS(s(x), y) → IF(gt(s(x), y), x, y)
The graph contains the following edges 1 > 2, 2 >= 3
- IF(true, x, y) → MINUS(x, y)
The graph contains the following edges 2 >= 1, 3 >= 2
(27) YES
(28) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF2(true, x, y) → GCD(minus(x, y), y)
GCD(x, y) → IF1(ge(x, y), x, y)
IF1(true, x, y) → IF2(gt(y, 0), x, y)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gcd(x, y) → if1(ge(x, y), x, y)
if1(true, x, y) → if2(gt(y, 0), x, y)
if1(false, x, y) → if3(gt(x, 0), x, y)
if2(true, x, y) → gcd(minus(x, y), y)
if2(false, x, y) → x
if3(true, x, y) → gcd(x, minus(y, x))
if3(false, x, y) → y
gt(0, y) → false
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(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:
Q DP problem:
The TRS P consists of the following rules:
IF2(true, x, y) → GCD(minus(x, y), y)
GCD(x, y) → IF1(ge(x, y), x, y)
IF1(true, x, y) → IF2(gt(y, 0), x, y)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(31) QReductionProof (EQUIVALENT transformation)
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.[THIEMANN].
gcd(x0, x1)
if1(true, x0, x1)
if1(false, x0, x1)
if2(true, x0, x1)
if2(false, x0, x1)
if3(true, x0, x1)
if3(false, x0, x1)
(32) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF2(true, x, y) → GCD(minus(x, y), y)
GCD(x, y) → IF1(ge(x, y), x, y)
IF1(true, x, y) → IF2(gt(y, 0), x, y)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(33) Narrowing (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
GCD(
x,
y) →
IF1(
ge(
x,
y),
x,
y) at position [0] we obtained the following new rules [LPAR04]:
GCD(x0, 0) → IF1(true, x0, 0)
GCD(0, s(x0)) → IF1(false, 0, s(x0))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
(34) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF2(true, x, y) → GCD(minus(x, y), y)
IF1(true, x, y) → IF2(gt(y, 0), x, y)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
GCD(x0, 0) → IF1(true, x0, 0)
GCD(0, s(x0)) → IF1(false, 0, s(x0))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(35) Narrowing (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
IF1(
true,
x,
y) →
IF2(
gt(
y,
0),
x,
y) at position [0] we obtained the following new rules [LPAR04]:
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF1(true, y0, 0) → IF2(false, y0, 0)
(36) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF2(true, x, y) → GCD(minus(x, y), y)
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
GCD(x0, 0) → IF1(true, x0, 0)
GCD(0, s(x0)) → IF1(false, 0, s(x0))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF1(true, y0, 0) → IF2(false, y0, 0)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(37) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(38) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(0, s(x0)) → IF1(false, 0, s(x0))
IF1(false, x, y) → IF3(gt(x, 0), x, y)
IF3(true, x, y) → GCD(x, minus(y, x))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF2(true, x, y) → GCD(minus(x, y), y)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(39) Narrowing (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
IF1(
false,
x,
y) →
IF3(
gt(
x,
0),
x,
y) at position [0] we obtained the following new rules [LPAR04]:
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF1(false, 0, y1) → IF3(false, 0, y1)
(40) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(0, s(x0)) → IF1(false, 0, s(x0))
IF3(true, x, y) → GCD(x, minus(y, x))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF2(true, x, y) → GCD(minus(x, y), y)
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF1(false, 0, y1) → IF3(false, 0, y1)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(41) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 2 less nodes.
(42) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF2(true, x, y) → GCD(minus(x, y), y)
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF3(true, x, y) → GCD(x, minus(y, x))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(43) Narrowing (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
IF2(
true,
x,
y) →
GCD(
minus(
x,
y),
y) at position [0] we obtained the following new rules [LPAR04]:
IF2(true, s(x0), x1) → GCD(if(gt(s(x0), x1), x0, x1), x1)
(44) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF3(true, x, y) → GCD(x, minus(y, x))
IF2(true, s(x0), x1) → GCD(if(gt(s(x0), x1), x0, x1), x1)
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(45) Narrowing (EQUIVALENT transformation)
By narrowing [LPAR04] the rule
IF3(
true,
x,
y) →
GCD(
x,
minus(
y,
x)) at position [1] we obtained the following new rules [LPAR04]:
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
(46) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, y0, s(x0)) → IF2(true, y0, s(x0))
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF2(true, s(x0), x1) → GCD(if(gt(s(x0), x1), x0, x1), x1)
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(47) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
IF1(
true,
y0,
s(
x0)) →
IF2(
true,
y0,
s(
x0)) we obtained the following new rules [LPAR04]:
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
(48) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(false, s(x0), y1) → IF3(true, s(x0), y1)
IF2(true, s(x0), x1) → GCD(if(gt(s(x0), x1), x0, x1), x1)
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(49) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
IF1(
false,
s(
x0),
y1) →
IF3(
true,
s(
x0),
y1) we obtained the following new rules [LPAR04]:
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
(50) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF2(true, s(x0), x1) → GCD(if(gt(s(x0), x1), x0, x1), x1)
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(51) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
IF2(
true,
s(
x0),
x1) →
GCD(
if(
gt(
s(
x0),
x1),
x0,
x1),
x1) we obtained the following new rules [LPAR04]:
IF2(true, s(z0), s(z1)) → GCD(if(gt(s(z0), s(z1)), z0, s(z1)), s(z1))
(52) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF2(true, s(z0), s(z1)) → GCD(if(gt(s(z0), s(z1)), z0, s(z1)), s(z1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(53) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
IF2(
true,
s(
z0),
s(
z1)) →
GCD(
if(
gt(
s(
z0),
s(
z1)),
z0,
s(
z1)),
s(
z1)) at position [0,0] we obtained the following new rules [LPAR04]:
IF2(true, s(z0), s(z1)) → GCD(if(gt(z0, z1), z0, s(z1)), s(z1))
(54) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF3(true, x1, s(x0)) → GCD(x1, if(gt(s(x0), x1), x0, x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF2(true, s(z0), s(z1)) → GCD(if(gt(z0, z1), z0, s(z1)), s(z1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(55) Instantiation (EQUIVALENT transformation)
By instantiating [LPAR04] the rule
IF3(
true,
x1,
s(
x0)) →
GCD(
x1,
if(
gt(
s(
x0),
x1),
x0,
x1)) we obtained the following new rules [LPAR04]:
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(s(z1), s(z0)), z1, s(z0)))
(56) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF2(true, s(z0), s(z1)) → GCD(if(gt(z0, z1), z0, s(z1)), s(z1))
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(s(z1), s(z0)), z1, s(z0)))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(57) Rewriting (EQUIVALENT transformation)
By rewriting [LPAR04] the rule
IF3(
true,
s(
z0),
s(
z1)) →
GCD(
s(
z0),
if(
gt(
s(
z1),
s(
z0)),
z1,
s(
z0))) at position [1,0] we obtained the following new rules [LPAR04]:
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(z1, z0), z1, s(z0)))
(58) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF2(true, s(z0), s(z1)) → GCD(if(gt(z0, z1), z0, s(z1)), s(z1))
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(z1, z0), z1, s(z0)))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(59) Induction-Processor (SOUND transformation)
This DP could be deleted by the Induction-Processor:IF2(
true,
s(
z0''),
s(
z1'')) →
GCD(
if(
gt(
z0'',
z1''),
z0'',
s(
z1'')),
s(
z1''))
This order was computed:Polynomial interpretation [POLO]:
POL(0) = 0
POL(GCD(x1, x2)) = x1
POL(IF1(x1, x2, x3)) = x2
POL(IF2(x1, x2, x3)) = x2
POL(IF3(x1, x2, x3)) = x2
POL(false) = 0
POL(ge(x1, x2)) = x1
POL(gt(x1, x2)) = 0
POL(if(x1, x2, x3)) = 1 + x2
POL(minus(x1, x2)) = x1
POL(s(x1)) = 1 + x1
POL(true) = 0
At least one of these decreasing rules is always used after the deleted DP:if(
false,
x332,
y242) →
0The following formula is valid:z0'':sort[a0],z1'':sort[a0].
if'(
gt(
z0'' ,
z1'' ),
z0'' ,
s(
z1'' ))=
trueThe transformed set:minus'(
s(
x5),
y3) →
if'(
gt(
s(
x5),
y3),
x5,
y3)
if'(
true,
x24,
y17) →
minus'(
x24,
y17)
if'(
false,
x33,
y24) →
trueminus'(
0,
x1) →
falsegt(
s(
x),
0) →
trueminus(
s(
x5),
y3) →
if(
gt(
s(
x5),
y3),
x5,
y3)
gt(
s(
x15),
s(
y10)) →
gt(
x15,
y10)
if(
true,
x24,
y17) →
s(
minus(
x24,
y17))
if(
false,
x33,
y24) →
0gt(
0,
y31) →
falsege(
x50,
0) →
truege(
0,
s(
x59)) →
falsege(
s(
x68),
s(
y50)) →
ge(
x68,
y50)
minus(
0,
x1) →
0equal_bool(
true,
false) →
falseequal_bool(
false,
true) →
falseequal_bool(
true,
true) →
trueequal_bool(
false,
false) →
trueand(
true,
x) →
xand(
false,
x) →
falseor(
true,
x) →
trueor(
false,
x) →
xnot(
false) →
truenot(
true) →
falseisa_true(
true) →
trueisa_true(
false) →
falseisa_false(
true) →
falseisa_false(
false) →
trueequal_sort[a0](
s(
x0),
s(
x1)) →
equal_sort[a0](
x0,
x1)
equal_sort[a0](
s(
x0),
0) →
falseequal_sort[a0](
0,
s(
x0)) →
falseequal_sort[a0](
0,
0) →
trueequal_sort[a44](
witness_sort[a44],
witness_sort[a44]) →
trueThe proof given by the theorem prover:The following input was given to ACL2:
(set-ruler-extenders :all)
(defun trs_isbool (x)
(or
(and
(consp
x
)
(eq
'trs_true
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
(and
(consp
x
)
(eq
'trs_false
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_issort[a0] (x)
(or
(and
(consp
x
)
(consp
(cdr
x
)
)
(eq
'trs_s
(car
x
)
)
(trs_issort[a0]
(car
(cdr
x
)
)
)
(eq
(cdr
(cdr
x
)
)
'nil
)
)
(and
(consp
x
)
(eq
'trs_0
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_issort[a44] (x)
(or
(and
(consp
x
)
(eq
'trs_witness_sort[a44]
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_ge (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_0
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_false
)
(if
(and
)
(trs_ge
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_gt (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_s
)
)
(trs_gt
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_equal_sort[a44] (x0 x1)
(if
(and
(trs_issort[a44]
x0
)
(trs_issort[a44]
x1
)
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(defun trs_equal_sort[a0] (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_s
)
)
(trs_equal_sort[a0]
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_0
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_false
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_isa_false (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_false
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_isa_true (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_not (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_or (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
x1
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_and (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
x1
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_equal_bool (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_false
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_false
)
(eq
(car
x1
)
'trs_true
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_if (x0 x1 x2)
(if
(and
(trs_isbool
x0
)
(trs_issort[a0]
x1
)
(trs_issort[a0]
x2
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_0
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_s
(trs_if
(trs_gt
(list 'trs_s
(car
(cdr
x1
)
)
)
x2
)
(car
(cdr
x1
)
)
x2
)
)
(if
(and
)
(list 'trs_s
(list 'trs_0
)
)
(list 'trs_0
)
)
)
)
(list 'trs_0
)
)
)
(defun trs_ifprime (x0 x1 x2)
(if
(and
(trs_isbool
x0
)
(trs_issort[a0]
x1
)
(trs_issort[a0]
x2
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_s
)
)
(trs_ifprime
(trs_gt
(list 'trs_s
(car
(cdr
x1
)
)
)
x2
)
(car
(cdr
x1
)
)
x2
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_minus (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_0
)
)
(list 'trs_0
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(list 'trs_s
(trs_minus
(car
(cdr
x0
)
)
x1
)
)
(if
(and
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_false
)
)
)
(list 'trs_0
)
(list 'trs_0
)
)
)
)
(list 'trs_0
)
)
)
(defun trs_minusprime (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_0
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(trs_minusprime
(car
(cdr
x0
)
)
x1
)
(if
(and
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_false
)
)
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(with-prover-time-limit 3
(defthm test
(implies
(and
(trs_issort[a0] trs_z0primeprime)
(trs_issort[a0] trs_z1primeprime)
)
(eq
(trs_ifprime
(trs_gt
trs_z0primeprime
trs_z1primeprime
)
trs_z0primeprime
(list 'trs_s
trs_z1primeprime
)
)
(list 'trs_true
)
)
)
)
)The following output was given by ACL2:
This is SBCL 1.0.29.11.debian, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
ACL2 Version 3.6 built February 12, 2010 14:59:57.
Copyright (C) 2009 University of Texas at Austin
ACL2 comes with ABSOLUTELY NO WARRANTY. This is free software and you
are welcome to redistribute it under certain conditions. For details,
see the GNU General Public License.
Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*).
See the documentation topic note-3-6 for recent changes.
Note: We have modified the prompt in some underlying Lisps to further
distinguish it from the ACL2 prompt.
ACL2 Version 3.6. Level 1. Cbd "/home/petersk/workspace/benchmark/".
Distributed books directory "/home/petersk/download/acl2-sources/books/".
Type :help for help.
Type (good-bye) to quit completely out of ACL2.
ACL2 !> :ALL
ACL2 !>
Since TRS_ISBOOL is non-recursive, its admission is trivial. We observe
that the type of TRS_ISBOOL is described by the theorem
(OR (EQUAL (TRS_ISBOOL X) T) (EQUAL (TRS_ISBOOL X) NIL)). We used
the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISBOOL ...)
Rules: ((:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_ISBOOL
ACL2 !>
For the admission of TRS_ISSORT[A0] we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQ 'TRS_S (CAR X)))
(O< (ACL2-COUNT (CADR X))
(ACL2-COUNT X))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQUAL 'TRS_S (CAR X)))
(O< (ACL2-COUNT (CADR X))
(ACL2-COUNT X))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP and
O<, the :executable-counterpart of ACL2-COUNT, primitive type reasoning,
the :rewrite rule UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT,
to
Goal''
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQUAL 'TRS_S (CAR X)))
(< (ACL2-COUNT (CADR X))
(+ 1 (ACL2-COUNT (CDR X))))).
The destructor terms (CAR X) and (CDR X) can be eliminated. Furthermore,
those terms are at the root of a chain of two rounds of destructor
elimination. (1) Use CAR-CDR-ELIM to replace X by (CONS X1 X2), (CAR X)
by X1 and (CDR X) by X2 and restrict the type of the new variable X1
to be that of the term it replaces. (2) Use CAR-CDR-ELIM, again, to
replace X2 by (CONS X3 X4), (CAR X2) by X3 and (CDR X2) by X4. These
steps produce the following goal.
Goal'''
(IMPLIES (AND (CONSP (CONS X3 X4))
(SYMBOLP X1)
(NOT (EQUAL X1 T))
(NOT (EQUAL X1 NIL))
(CONSP (LIST* X1 X3 X4))
(EQUAL 'TRS_S X1))
(< (ACL2-COUNT X3)
(+ 1 (ACL2-COUNT (CONS X3 X4))))).
By case analysis we reduce the conjecture to
Goal'4'
(IMPLIES (AND (CONSP (CONS X3 X4))
(SYMBOLP X1)
(NOT (EQUAL X1 T))
X1 (CONSP (LIST* X1 X3 X4))
(EQUAL 'TRS_S X1))
(< (ACL2-COUNT X3)
(+ 1 (ACL2-COUNT (CONS X3 X4))))).
This simplifies, using the :definition ACL2-COUNT, the :executable-
counterparts of EQUAL, NOT and SYMBOLP, primitive type reasoning and
the :rewrite rules CAR-CONS and CDR-CONS, to
Goal'5'
(< (ACL2-COUNT X3)
(+ 1 1 (ACL2-COUNT X3)
(ACL2-COUNT X4))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_ISSORT[A0].
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_ISSORT[A0] is described by the theorem
(OR (EQUAL (TRS_ISSORT[A0] X) T) (EQUAL (TRS_ISSORT[A0] X) NIL)).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISSORT[A0] ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:ELIM CAR-CDR-ELIM)
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART SYMBOLP)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.02 seconds (prove: 0.01, print: 0.00, other: 0.01)
TRS_ISSORT[A0]
ACL2 !>
Since TRS_ISSORT[A44] is non-recursive, its admission is trivial.
We observe that the type of TRS_ISSORT[A44] is described by the theorem
(OR (EQUAL (TRS_ISSORT[A44] X) T) (EQUAL (TRS_ISSORT[A44] X) NIL)).
We used primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISSORT[A44] ...)
Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_ISSORT[A44]
ACL2 !>
For the admission of TRS_GE we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X1) 'TRS_0))
(NOT (AND (EQ (CAR X0) 'TRS_0)
(EQ (CAR X1) 'TRS_S)))
T)
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (AND (EQUAL (CAR X0) 'TRS_0)
(EQUAL (CAR X1) 'TRS_S))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(EQUAL 'TRS_S (CAR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X1) 'TRS_0)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_GE. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_GE is described by the theorem
(AND (CONSP (TRS_GE X0 X1)) (TRUE-LISTP (TRS_GE X0 X1))).
Summary
Form: ( DEFUN TRS_GE ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.02 seconds (prove: 0.00, print: 0.00, other: 0.02)
TRS_GE
ACL2 !>
For the admission of TRS_GT we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_0)))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (AND (EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_GT. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_GT is described by the theorem
(AND (CONSP (TRS_GT X0 X1)) (TRUE-LISTP (TRS_GT X0 X1))). We used
primitive type reasoning.
Summary
Form: ( DEFUN TRS_GT ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_GT
ACL2 !>
Since TRS_EQUAL_SORT[A44] is non-recursive, its admission is trivial.
We observe that the type of TRS_EQUAL_SORT[A44] is described by the
theorem
(AND (CONSP (TRS_EQUAL_SORT[A44] X0 X1))
(TRUE-LISTP (TRS_EQUAL_SORT[A44] X0 X1))).
Summary
Form: ( DEFUN TRS_EQUAL_SORT[A44] ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_EQUAL_SORT[A44]
ACL2 !>
For the admission of TRS_EQUAL_SORT[A0] we will use the relation O<
(which is known to be well-founded on the domain recognized by O-P)
and the measure (ACL2-COUNT X0). The non-trivial part of the measure
conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_EQUAL_SORT[A0].
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_EQUAL_SORT[A0] is described by the theorem
(AND (CONSP (TRS_EQUAL_SORT[A0] X0 X1))
(TRUE-LISTP (TRS_EQUAL_SORT[A0] X0 X1))).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_EQUAL_SORT[A0] ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.02 seconds (prove: 0.00, print: 0.01, other: 0.01)
TRS_EQUAL_SORT[A0]
ACL2 !>
Since TRS_ISA_FALSE is non-recursive, its admission is trivial. We
observe that the type of TRS_ISA_FALSE is described by the theorem
(AND (CONSP (TRS_ISA_FALSE X0)) (TRUE-LISTP (TRS_ISA_FALSE X0))).
Summary
Form: ( DEFUN TRS_ISA_FALSE ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_ISA_FALSE
ACL2 !>
Since TRS_ISA_TRUE is non-recursive, its admission is trivial. We
observe that the type of TRS_ISA_TRUE is described by the theorem
(AND (CONSP (TRS_ISA_TRUE X0)) (TRUE-LISTP (TRS_ISA_TRUE X0))).
Summary
Form: ( DEFUN TRS_ISA_TRUE ...)
Rules: NIL
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_ISA_TRUE
ACL2 !>
Since TRS_NOT is non-recursive, its admission is trivial. We observe
that the type of TRS_NOT is described by the theorem
(AND (CONSP (TRS_NOT X0)) (TRUE-LISTP (TRS_NOT X0))).
Summary
Form: ( DEFUN TRS_NOT ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_NOT
ACL2 !>
Since TRS_OR is non-recursive, its admission is trivial. We observe
that the type of TRS_OR is described by the theorem
(OR (AND (CONSP (TRS_OR X0 X1))
(TRUE-LISTP (TRS_OR X0 X1)))
(EQUAL (TRS_OR X0 X1) X1)).
Summary
Form: ( DEFUN TRS_OR ...)
Rules: NIL
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_OR
ACL2 !>
Since TRS_AND is non-recursive, its admission is trivial. We observe
that the type of TRS_AND is described by the theorem
(OR (AND (CONSP (TRS_AND X0 X1))
(TRUE-LISTP (TRS_AND X0 X1)))
(EQUAL (TRS_AND X0 X1) X1)).
Summary
Form: ( DEFUN TRS_AND ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_AND
ACL2 !>
Since TRS_EQUAL_BOOL is non-recursive, its admission is trivial. We
observe that the type of TRS_EQUAL_BOOL is described by the theorem
(AND (CONSP (TRS_EQUAL_BOOL X0 X1)) (TRUE-LISTP (TRS_EQUAL_BOOL X0 X1))).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_EQUAL_BOOL ...)
Rules: ((:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_EQUAL_BOOL
ACL2 !>
For the admission of TRS_IF we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X1). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISBOOL X0)
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2))
(NOT (EQ (CAR X0) 'TRS_FALSE))
(AND (EQ (CAR X0) 'TRS_TRUE)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Goal'
(IMPLIES (AND (CONSP X0)
(COND ((EQUAL 'TRS_TRUE (CAR X0))
(EQUAL (CDR X0) NIL))
((EQUAL 'TRS_FALSE (CAR X0))
(EQUAL (CDR X0) NIL))
(T NIL))
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2)
(NOT (EQUAL (CAR X0) 'TRS_FALSE))
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(NOT (CDR X0))
(CONSP X1)
(CONSP (CDR X1))
(TRS_ISSORT[A0] (CADR X1))
(NOT (CDDR X1))
(TRS_ISSORT[A0] X2)
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X1))
(+ 1 1 (ACL2-COUNT (CADR X1))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_IF. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_IF is described by the theorem
(AND (CONSP (TRS_IF X0 X1 X2)) (TRUE-LISTP (TRS_IF X0 X1 X2))). We
used primitive type reasoning.
Summary
Form: ( DEFUN TRS_IF ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.01, print: 0.00, other: 0.00)
TRS_IF
ACL2 !>
For the admission of TRS_IFPRIME we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X1). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (AND (TRS_ISBOOL X0)
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2))
(NOT (EQ (CAR X0) 'TRS_FALSE))
(AND (EQ (CAR X0) 'TRS_TRUE)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Goal'
(IMPLIES (AND (CONSP X0)
(COND ((EQUAL 'TRS_TRUE (CAR X0))
(EQUAL (CDR X0) NIL))
((EQUAL 'TRS_FALSE (CAR X0))
(EQUAL (CDR X0) NIL))
(T NIL))
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2)
(NOT (EQUAL (CAR X0) 'TRS_FALSE))
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(NOT (CDR X0))
(CONSP X1)
(CONSP (CDR X1))
(TRS_ISSORT[A0] (CADR X1))
(NOT (CDDR X1))
(TRS_ISSORT[A0] X2)
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X1))
(+ 1 1 (ACL2-COUNT (CADR X1))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_IFPRIME. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_IFPRIME is described by the theorem
(AND (CONSP (TRS_IFPRIME X0 X1 X2)) (TRUE-LISTP (TRS_IFPRIME X0 X1 X2))).
Summary
Form: ( DEFUN TRS_IFPRIME ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.02 seconds (prove: 0.01, print: 0.00, other: 0.01)
TRS_IFPRIME
ACL2 !>
For the admission of TRS_MINUS we will use the relation O< (which is
known to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X0) 'TRS_0))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X0) 'TRS_0))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<,
TRS_GT and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT
and EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS, CDR-CONS,
COMMUTATIVITY-OF-+ and UNICITY-OF-0 and the :type-prescription rules
ACL2-COUNT and TRS_ISSORT[A0], to the following three conjectures.
Subgoal 3
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)
(EQUAL (TRS_EQUAL_BOOL '(TRS_TRUE) '(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
By the :executable-counterparts of EQUAL and TRS_EQUAL_BOOL we reduce
the conjecture to
Subgoal 3'
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Subgoal 2
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (EQUAL (CAR X1) 'TRS_S))
(EQUAL (TRS_EQUAL_BOOL '(TRS_FALSE)
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But we reduce the conjecture to T, by the :executable-counterparts
of EQUAL and TRS_EQUAL_BOOL.
Subgoal 1
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (CADR X0) (CADR X1))
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_MINUS. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_MINUS is described by the theorem
(AND (CONSP (TRS_MINUS X0 X1)) (TRUE-LISTP (TRS_MINUS X0 X1))). We
used primitive type reasoning.
Summary
Form: ( DEFUN TRS_MINUS ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART TRS_EQUAL_BOOL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.02 seconds (prove: 0.00, print: 0.01, other: 0.01)
TRS_MINUS
ACL2 !>
For the admission of TRS_MINUSPRIME we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X0). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X0) 'TRS_0))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X0) 'TRS_0))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<,
TRS_GT and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT
and EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS, CDR-CONS,
COMMUTATIVITY-OF-+ and UNICITY-OF-0 and the :type-prescription rules
ACL2-COUNT and TRS_ISSORT[A0], to the following three conjectures.
Subgoal 3
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)
(EQUAL (TRS_EQUAL_BOOL '(TRS_TRUE) '(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
By the :executable-counterparts of EQUAL and TRS_EQUAL_BOOL we reduce
the conjecture to
Subgoal 3'
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Subgoal 2
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (EQUAL (CAR X1) 'TRS_S))
(EQUAL (TRS_EQUAL_BOOL '(TRS_FALSE)
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But we reduce the conjecture to T, by the :executable-counterparts
of EQUAL and TRS_EQUAL_BOOL.
Subgoal 1
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (CADR X0) (CADR X1))
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_MINUSPRIME.
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_MINUSPRIME is described by the theorem
(AND (CONSP (TRS_MINUSPRIME X0 X1)) (TRUE-LISTP (TRS_MINUSPRIME X0 X1))).
Summary
Form: ( DEFUN TRS_MINUSPRIME ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART TRS_EQUAL_BOOL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.02 seconds (prove: 0.01, print: 0.00, other: 0.01)
TRS_MINUSPRIME
ACL2 !>
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
Name the formula above *1.
Perhaps we can prove *1 by induction. Four induction schemes are suggested
by this conjecture. These merge into one derived induction scheme.
We will induct according to a scheme suggested by
(TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(CONS 'TRS_S
(CONS TRS_Z1PRIMEPRIME 'NIL))),
but modified to accommodate (TRS_ISSORT[A0] TRS_Z1PRIMEPRIME) and
(TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME). These suggestions were
produced using the :induction rules TRS_GT, TRS_IFPRIME and TRS_ISSORT[A0].
If we let (:P TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME) denote *1 above then
the induction scheme we'll use is
(AND
(IMPLIES (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))))
(:P TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S)))
T)
(:P TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(:P (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME)))
(:P TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(:P TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
Note, however, that the unmeasured variable TRS_Z1PRIMEPRIME is being
instantiated. When applied to the goal at hand the above induction
scheme produces six nontautological subgoals.
Subgoal *1/6
(IMPLIES
(AND (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL and
TRS_ISBOOL, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_ISBOOL and TRS_ISSORT[A0],
to the following two conjectures.
Subgoal *1/6.2
(IMPLIES (AND (EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_0)
(NOT (TRS_ISBOOL '(TRS_TRUE)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
But we reduce the conjecture to T, by the :executable-counterpart of
TRS_ISBOOL.
Subgoal *1/6.1
(IMPLIES (AND (EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_S)
(NOT (TRS_ISBOOL (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(CONSP TRS_Z1PRIMEPRIME)
(CONSP (CDR TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME))
(NOT (CDDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISBOOL, the :executable-counterpart of EQUAL, primitive type
reasoning and the :type-prescription rule TRS_GT.
Subgoal *1/5
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S)))
T (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/5'
(IMPLIES
(AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(NOT (AND (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP and
EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0].
Subgoal *1/4
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/4'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_ISSORT[A0],
the :executable-counterparts of CAR, CONSP and EQUAL, primitive type
reasoning, the :rewrite rules CAR-CONS and CDR-CONS and the :type-
prescription rules TRS_GT and TRS_ISSORT[A0], to the following ten
conjectures.
Subgoal *1/4.10
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.10'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.10''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.10'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.10'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.10'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.10'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.10.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.1.
Subgoal *1/4.10.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.9
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.9'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.9''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.9'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.9'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.9'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.9'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.9.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.2.
Subgoal *1/4.9.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.8
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(CONSP (CDR TRS_Z1PRIMEPRIME))
(EQUAL 'TRS_S (CAR TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME))
(NOT (CDDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIMEPRIME by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2),
(CAR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME2 and restrict the type of the new variable
TRS_Z1PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z1PRIMEPRIME2 by
(CONS TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4), (CAR TRS_Z1PRIMEPRIME2)
by TRS_Z1PRIMEPRIME3 and (CDR TRS_Z1PRIMEPRIME2) by TRS_Z1PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.8'
(IMPLIES
(AND (CONSP (CONS TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4))
(SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIMEPRIME1
TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4))
(NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(EQUAL 'TRS_S TRS_Z1PRIMEPRIME1)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3)
(NOT TRS_Z1PRIMEPRIME4))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(LIST* TRS_Z1PRIMEPRIME1
TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8''
(IMPLIES
(AND (CONSP (CONS TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4))
(SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (LIST* TRS_Z1PRIMEPRIME1
TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4))
(NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(EQUAL 'TRS_S TRS_Z1PRIMEPRIME1)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3)
(NOT TRS_Z1PRIMEPRIME4))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(LIST* TRS_Z1PRIMEPRIME1
TRS_Z1PRIMEPRIME3 TRS_Z1PRIMEPRIME4)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of EQUAL, NOT and
SYMBOLP and primitive type reasoning, to
Subgoal *1/4.8'''
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.8'4'
(IMPLIES
(AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8'5'
(IMPLIES
(AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME, TRS_ISBOOL
and TRS_ISSORT[A0], the :executable-counterparts of EQUAL, NOT and
SYMBOLP, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_GT and TRS_ISSORT[A0],
to
Subgoal *1/4.8'6'
(IMPLIES
(AND (NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
We generalize this conjecture, replacing
(TRS_GT TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3) by L and restricting the
type of the new variable L to be that of the term it replaces, as established
by TRS_GT. This produces
Subgoal *1/4.8'7'
(IMPLIES (AND (CONSP L)
(TRUE-LISTP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR L) 'TRS_TRUE)
(EQUAL (TRS_IFPRIME L TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definition TRUE-LISTP and the :executable-
counterpart of TRUE-LISTP, to
Subgoal *1/4.8'8'
(IMPLIES (AND (CONSP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR L) 'TRS_TRUE)
(EQUAL (TRS_IFPRIME L TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR L) and (CDR L) can be eliminated by using
CAR-CDR-ELIM to replace L by (CONS L1 L2), (CAR L) by L1 and (CDR L)
by L2 and restrict the type of the new variable L1 to be that of the
term it replaces. This produces the following goal.
Subgoal *1/4.8'9'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
(NOT (EQUAL L1 NIL))
(CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL L1 'TRS_TRUE)
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8'10'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
L1 (CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL L1 'TRS_TRUE)
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.8'11'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
Name the formula above *1.3.
Subgoal *1/4.7
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.7'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.7''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.7'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.7'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.7'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.7'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.7.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.4.
Subgoal *1/4.7.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.6
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME)))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.6'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.6''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.6'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.6'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.6'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.6'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.6.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.5.
Subgoal *1/4.6.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.5
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_0)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.5'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_0)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.5''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL TRS_Z1PRIMEPRIME1 'TRS_0)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.5'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL TRS_Z1PRIMEPRIME1 'TRS_0)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.5'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.5'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.5'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.5.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.6.
Subgoal *1/4.5.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.4
(IMPLIES (AND (NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.4''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.4'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.4'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.4'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.4'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.4.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.7.
Subgoal *1/4.4.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.3
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.3'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.3''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.3'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.3'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.3'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.3'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.3.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.8.
Subgoal *1/4.3.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.2
(IMPLIES (AND (EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_0)
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.2'
(IMPLIES (AND (EQUAL (CAR TRS_Z1PRIMEPRIME) 'TRS_0)
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.2''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(EQUAL TRS_Z1PRIMEPRIME1 'TRS_0)
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.2'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(EQUAL TRS_Z1PRIMEPRIME1 'TRS_0)
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.2'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.2'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.2'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.2.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.9.
Subgoal *1/4.2.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.1
(IMPLIES (AND (NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME)))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME)
(CADR TRS_Z1PRIMEPRIME))
(CADR TRS_Z0PRIMEPRIME)
(LIST 'TRS_S (CADR TRS_Z1PRIMEPRIME)))
'(TRS_TRUE))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.1'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/4.1''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.1'''
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.1'4'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/4.1'5'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.1'6'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.1.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.10.
Subgoal *1/4.1.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/3
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/3'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME)))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_ISSORT[A0],
the :executable-counterparts of CAR, CDR, CONSP and EQUAL, primitive
type reasoning, the :rewrite rules CAR-CONS and CDR-CONS and the :type-
prescription rule TRS_ISSORT[A0], to
Subgoal *1/3''
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIMEPRIME)))
(CONSP TRS_Z1PRIMEPRIME)
(NOT (CONSP (CDR TRS_Z1PRIMEPRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CAR, CONSP and
TRS_ISSORT[A0], to
Subgoal *1/3'''
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(CONSP TRS_Z1PRIMEPRIME)
(EQUAL 'TRS_0 (CAR TRS_Z1PRIMEPRIME))
(NOT (CDR TRS_Z1PRIMEPRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIMEPRIME) and (CDR TRS_Z1PRIMEPRIME)
can be eliminated by using CAR-CDR-ELIM to replace TRS_Z1PRIMEPRIME
by (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2), (CAR TRS_Z1PRIMEPRIME)
by TRS_Z1PRIMEPRIME1 and (CDR TRS_Z1PRIMEPRIME) by TRS_Z1PRIMEPRIME2
and restrict the type of the new variable TRS_Z1PRIMEPRIME1 to be that
of the term it replaces. This produces the following goal.
Subgoal *1/3'4'
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z1PRIMEPRIME1 NIL))
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/3'5'
(IMPLIES
(AND (SYMBOLP TRS_Z1PRIMEPRIME1)
(NOT (EQUAL TRS_Z1PRIMEPRIME1 T))
TRS_Z1PRIMEPRIME1
(CONSP (CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2))
(CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z1PRIMEPRIME1)
(NOT TRS_Z1PRIMEPRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S
(CONS TRS_Z1PRIMEPRIME1 TRS_Z1PRIMEPRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/3'6'
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME)
(CONSP (CDR TRS_Z0PRIMEPRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME))
(NOT (CDDR TRS_Z0PRIMEPRIME))
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME) and (CDR TRS_Z0PRIMEPRIME)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME by (CONS TRS_Z0PRIMEPRIME1 TRS_Z0PRIMEPRIME2),
(CAR TRS_Z0PRIMEPRIME) by TRS_Z0PRIMEPRIME1 and (CDR TRS_Z0PRIMEPRIME)
by TRS_Z0PRIMEPRIME2 and restrict the type of the new variable
TRS_Z0PRIMEPRIME1 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME2 by
(CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4), (CAR TRS_Z0PRIMEPRIME2)
by TRS_Z0PRIMEPRIME3 and (CDR TRS_Z0PRIMEPRIME2) by TRS_Z0PRIMEPRIME4.
These steps produce the following goal.
Subgoal *1/3'7'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/3'8'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(SYMBOLP TRS_Z0PRIMEPRIME1)
(NOT (EQUAL TRS_Z0PRIMEPRIME1 T))
TRS_Z0PRIMEPRIME1
(CONSP (LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT TRS_Z0PRIMEPRIME4)
(EQUAL TRS_Z0PRIMEPRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z0PRIMEPRIME1
TRS_Z0PRIMEPRIME3 TRS_Z0PRIMEPRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/3.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.11.
Subgoal *1/3.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(NOT (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/2
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/2'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME)))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0] and the :executable-counterparts of CDR, CONSP and
EQUAL.
Subgoal *1/1
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME)))
(EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/1'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z1PRIMEPRIME))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME TRS_Z1PRIMEPRIME)
TRS_Z0PRIMEPRIME
(LIST 'TRS_S TRS_Z1PRIMEPRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, CONSP, EQUAL and TRS_ISBOOL, primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rules
TRS_GT and TRS_ISSORT[A0].
So we now return to *1.11, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.10, which we'll try to prove
later. We therefore regard *1.11 as proved (pending the proof of the
more general *1.10).
We next consider *1.10, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.9, which we'll try to prove
later. We therefore regard *1.10 as proved (pending the proof of the
more general *1.9).
We next consider *1.9, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.8, which we'll try to prove
later. We therefore regard *1.9 as proved (pending the proof of the
more general *1.8).
We next consider *1.8, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.7, which we'll try to prove
later. We therefore regard *1.8 as proved (pending the proof of the
more general *1.7).
We next consider *1.7, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.6, which we'll try to prove
later. We therefore regard *1.7 as proved (pending the proof of the
more general *1.6).
We next consider *1.6, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.5, which we'll try to prove
later. We therefore regard *1.6 as proved (pending the proof of the
more general *1.5).
We next consider *1.5, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.4, which we'll try to prove
later. We therefore regard *1.5 as proved (pending the proof of the
more general *1.4).
We next consider *1.4, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.2, which we'll try to prove
later. We therefore regard *1.4 as proved (pending the proof of the
more general *1.2).
We next consider *1.3, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
Perhaps we can prove *1.3 by induction. Five induction schemes are
suggested by this conjecture. These merge into two derived induction
schemes. By considering those suggested by the largest number of non-
primitive recursive functions, we narrow the field to one.
We will induct according to a scheme suggested by
(TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(CONS 'TRS_S
(CONS TRS_Z1PRIMEPRIME3 'NIL)))
TRS_Z0PRIMEPRIME3
(CONS 'TRS_S
(CONS (CONS 'TRS_S
(CONS TRS_Z1PRIMEPRIME3 'NIL))
'NIL))).
This suggestion was produced using the :induction rules TRS_GT,
TRS_IFPRIME and TRS_ISSORT[A0]. If we let
(:P TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3) denote *1.3 above then the
induction scheme we'll use is
(AND
(IMPLIES (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))))
(:P TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
T)
(:P TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(:P (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3))
(:P TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(:P TRS_Z0PRIMEPRIME3 TRS_Z1PRIMEPRIME3))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
When applied to the goal at hand the above induction scheme produces
six nontautological subgoals.
Subgoal *1.3/6
(IMPLIES
(AND (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL and
TRS_ISBOOL, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_ISBOOL and TRS_ISSORT[A0],
to
Subgoal *1.3/6'
(IMPLIES (AND (EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (TRS_ISBOOL (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)))
(CONSP TRS_Z0PRIMEPRIME3)
(CONSP (CDR TRS_Z0PRIMEPRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3))
(NOT (CDDR TRS_Z0PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISBOOL, the :executable-counterpart of EQUAL, primitive type
reasoning and the :type-prescription rule TRS_GT.
Subgoal *1.3/5
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
T (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/5'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(NOT (AND (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP and
EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0].
Subgoal *1.3/4
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/4'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, EQUAL and TRS_ISBOOL, primitive type reasoning, the :rewrite
rules CAR-CONS and CDR-CONS and the :type-prescription rules TRS_GT
and TRS_ISSORT[A0].
Subgoal *1.3/3
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/3'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, EQUAL and TRS_ISBOOL,
primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0], to
Subgoal *1.3/3''
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)))
(CONSP TRS_Z0PRIMEPRIME3)
(CONSP (CDR TRS_Z0PRIMEPRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3))
(NOT (CDDR TRS_Z0PRIMEPRIME3))
(EQUAL (CAR (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)
(CADR TRS_Z0PRIMEPRIME3)
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z0PRIMEPRIME3)
TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIMEPRIME3) and (CDR TRS_Z0PRIMEPRIME3)
can be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIMEPRIME3 by (CONS TRS_Z0PRIMEPRIME4 TRS_Z0PRIMEPRIME5),
(CAR TRS_Z0PRIMEPRIME3) by TRS_Z0PRIMEPRIME4 and (CDR TRS_Z0PRIMEPRIME3)
by TRS_Z0PRIMEPRIME5 and restrict the type of the new variable
TRS_Z0PRIMEPRIME4 to be that of the term it replaces. (2) Use CAR-CDR-ELIM,
again, to replace TRS_Z0PRIMEPRIME5 by
(CONS TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7), (CAR TRS_Z0PRIMEPRIME5)
by TRS_Z0PRIMEPRIME6 and (CDR TRS_Z0PRIMEPRIME5) by TRS_Z0PRIMEPRIME7.
These steps produce the following goal.
Subgoal *1.3/3'''
(IMPLIES
(AND (CONSP (CONS TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7))
(SYMBOLP TRS_Z0PRIMEPRIME4)
(NOT (EQUAL TRS_Z0PRIMEPRIME4 T))
(NOT (EQUAL TRS_Z0PRIMEPRIME4 NIL))
(CONSP (LIST* TRS_Z0PRIMEPRIME4
TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7))
(NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(NOT TRS_Z0PRIMEPRIME7)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL TRS_Z0PRIMEPRIME4 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)
(LIST* TRS_Z0PRIMEPRIME4
TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1.3/3'4'
(IMPLIES
(AND (CONSP (CONS TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7))
(SYMBOLP TRS_Z0PRIMEPRIME4)
(NOT (EQUAL TRS_Z0PRIMEPRIME4 T))
TRS_Z0PRIMEPRIME4
(CONSP (LIST* TRS_Z0PRIMEPRIME4
TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7))
(NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(NOT TRS_Z0PRIMEPRIME7)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(EQUAL TRS_Z0PRIMEPRIME4 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)
(LIST* TRS_Z0PRIMEPRIME4
TRS_Z0PRIMEPRIME6 TRS_Z0PRIMEPRIME7)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME, TRS_ISBOOL
and TRS_ISSORT[A0], the :executable-counterparts of EQUAL, NOT and
SYMBOLP, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_GT and TRS_ISSORT[A0],
to
Subgoal *1.3/3'5'
(IMPLIES
(AND (NOT (CDR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3))
'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
We generalize this conjecture, replacing
(TRS_GT TRS_Z0PRIMEPRIME6 TRS_Z1PRIMEPRIME3) by L and restricting the
type of the new variable L to be that of the term it replaces, as established
by TRS_GT. This produces
Subgoal *1.3/3'6'
(IMPLIES (AND (CONSP L)
(TRUE-LISTP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(EQUAL (CAR L) 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME L TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definition TRUE-LISTP and the :executable-
counterpart of TRUE-LISTP, to
Subgoal *1.3/3'7'
(IMPLIES (AND (CONSP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(EQUAL (CAR L) 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME L TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR L) and (CDR L) can be eliminated by using
CAR-CDR-ELIM to replace L by (CONS L1 L2), (CAR L) by L1 and (CDR L)
by L2 and restrict the type of the new variable L1 to be that of the
term it replaces. This produces the following goal.
Subgoal *1.3/3'8'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
(NOT (EQUAL L1 NIL))
(CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(EQUAL L1 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1.3/3'9'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
L1 (CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME6)
(EQUAL L1 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME6
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :executable-counterparts
of CONS, CONSP, EQUAL, NOT and SYMBOLP.
Subgoal *1.3/2
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/2'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0] and the :executable-counterparts of CDR, CONSP and
EQUAL.
Subgoal *1.3/1
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQ (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/1'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
(EQUAL (CAR (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'TRS_FALSE)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIMEPRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z0PRIMEPRIME3
(LIST 'TRS_S TRS_Z1PRIMEPRIME3))
TRS_Z0PRIMEPRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z1PRIMEPRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, CONSP, EQUAL and TRS_ISBOOL, primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rules
TRS_GT and TRS_ISSORT[A0].
That completes the proof of *1.3.
We therefore turn our attention to *1.2, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.1, which we'll try to prove
later. We therefore regard *1.2 as proved (pending the proof of the
more general *1.1).
We next consider *1.1, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Perhaps we can prove *1.1 by induction. Two induction schemes are
suggested by this conjecture. These merge into one derived induction
scheme.
We will induct according to a scheme suggested by
(TRS_IFPRIME '(TRS_TRUE) TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0))). This
suggestion was produced using the :induction rules TRS_IFPRIME and
TRS_ISSORT[A0]. If we let (:P TRS_Z0PRIMEPRIME3) denote *1.1 above
then the induction scheme we'll use is
(AND (IMPLIES (NOT (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0)))))
(:P TRS_Z0PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(NOT (AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)))
T)
(:P TRS_Z0PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(:P (CADR TRS_Z0PRIMEPRIME3)))
(:P TRS_Z0PRIMEPRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(EQ 'TRS_TRUE 'TRS_FALSE))
(:P TRS_Z0PRIMEPRIME3))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
When applied to the goal at hand the above induction scheme produces
four nontautological subgoals.
Subgoal *1.1/4
(IMPLIES (AND (NOT (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0)))))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But we reduce the conjecture to T, by the :executable-counterparts
of TRS_ISBOOL and TRS_ISSORT[A0].
Subgoal *1.1/3
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/3'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0], primitive type reasoning, the :rewrite rules CAR-CONS
and CDR-CONS and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1.1/3''
(IMPLIES (AND (CONSP TRS_Z0PRIMEPRIME3)
(CONSP (CDR TRS_Z0PRIMEPRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3))
(NOT (CDDR TRS_Z0PRIMEPRIME3))
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z0PRIMEPRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))
(NOT (EQUAL (CAADR TRS_Z0PRIMEPRIME3)
'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
(CADR TRS_Z0PRIMEPRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1.1/2
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(NOT (EQUAL (CAADR TRS_Z0PRIMEPRIME3)
'TRS_S))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/2'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (EQUAL (CAADR TRS_Z0PRIMEPRIME3)
'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME and TRS_ISSORT[A0], the :executable-counterparts of CAR,
CDR, EQUAL, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning,
the :rewrite rules CAR-CONS and CDR-CONS and the :type-prescription
rule TRS_ISSORT[A0].
Subgoal *1.1/1
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3)))
(TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/1'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z0PRIMEPRIME3)
(EQUAL (CAR TRS_Z0PRIMEPRIME3) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIMEPRIME3))))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z0PRIMEPRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definition TRS_ISSORT[A0]
and the :executable-counterpart of EQUAL.
That completes the proofs of *1.1 and *1.
Q.E.D.
Summary
Form: ( DEFTHM TEST ...)
Rules: ((:DEFINITION EQ)
(:DEFINITION NOT)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_IFPRIME)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:DEFINITION TRUE-LISTP)
(:ELIM CAR-CDR-ELIM)
(:EXECUTABLE-COUNTERPART CAR)
(:EXECUTABLE-COUNTERPART CDR)
(:EXECUTABLE-COUNTERPART CONS)
(:EXECUTABLE-COUNTERPART CONSP)
(:EXECUTABLE-COUNTERPART EQ)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART SYMBOLP)
(:EXECUTABLE-COUNTERPART TRS_ISBOOL)
(:EXECUTABLE-COUNTERPART TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART TRUE-LISTP)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:INDUCTION TRS_GT)
(:INDUCTION TRS_IFPRIME)
(:INDUCTION TRS_ISSORT[A0])
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:TYPE-PRESCRIPTION TRS_GT)
(:TYPE-PRESCRIPTION TRS_ISBOOL)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.44 seconds (prove: 0.36, print: 0.08, other: 0.00)
TEST
ACL2 !>Bye.
(60) Complex Obligation (AND)
(61) Obligation:
Q DP problem:
The TRS P consists of the following rules:
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
IF1(true, s(z0), s(z1)) → IF2(true, s(z0), s(z1))
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(z1, z0), z1, s(z0)))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(62) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 1 SCC with 1 less node.
(63) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
IF3(true, s(z0), s(z1)) → GCD(s(z0), if(gt(z1, z0), z1, s(z0)))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(64) Induction-Processor (SOUND transformation)
This DP could be deleted by the Induction-Processor:IF3(
true,
s(
z0'),
s(
z1')) →
GCD(
s(
z0'),
if(
gt(
z1',
z0'),
z1',
s(
z0')))
This order was computed:Polynomial interpretation [POLO]:
POL(0) = 0
POL(GCD(x1, x2)) = x2
POL(IF1(x1, x2, x3)) = x3
POL(IF3(x1, x2, x3)) = x3
POL(false) = 0
POL(ge(x1, x2)) = x2
POL(gt(x1, x2)) = 0
POL(if(x1, x2, x3)) = 1 + x2
POL(minus(x1, x2)) = x1
POL(s(x1)) = 1 + x1
POL(true) = 0
At least one of these decreasing rules is always used after the deleted DP:if(
false,
x332,
y242) →
0The following formula is valid:z1':sort[a0],z0':sort[a0].
if'(
gt(
z1' ,
z0' ),
z1' ,
s(
z0' ))=
trueThe transformed set:minus'(
s(
x5),
y3) →
if'(
gt(
s(
x5),
y3),
x5,
y3)
if'(
true,
x24,
y17) →
minus'(
x24,
y17)
if'(
false,
x33,
y24) →
trueminus'(
0,
x1) →
falsegt(
s(
x),
0) →
trueminus(
s(
x5),
y3) →
if(
gt(
s(
x5),
y3),
x5,
y3)
gt(
s(
x15),
s(
y10)) →
gt(
x15,
y10)
if(
true,
x24,
y17) →
s(
minus(
x24,
y17))
if(
false,
x33,
y24) →
0gt(
0,
y31) →
falsege(
x50,
0) →
truege(
0,
s(
x59)) →
falsege(
s(
x68),
s(
y50)) →
ge(
x68,
y50)
minus(
0,
x1) →
0equal_bool(
true,
false) →
falseequal_bool(
false,
true) →
falseequal_bool(
true,
true) →
trueequal_bool(
false,
false) →
trueand(
true,
x) →
xand(
false,
x) →
falseor(
true,
x) →
trueor(
false,
x) →
xnot(
false) →
truenot(
true) →
falseisa_true(
true) →
trueisa_true(
false) →
falseisa_false(
true) →
falseisa_false(
false) →
trueequal_sort[a0](
s(
x0),
s(
x1)) →
equal_sort[a0](
x0,
x1)
equal_sort[a0](
s(
x0),
0) →
falseequal_sort[a0](
0,
s(
x0)) →
falseequal_sort[a0](
0,
0) →
trueequal_sort[a41](
witness_sort[a41],
witness_sort[a41]) →
trueThe proof given by the theorem prover:The following input was given to ACL2:
(set-ruler-extenders :all)
(defun trs_isbool (x)
(or
(and
(consp
x
)
(eq
'trs_true
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
(and
(consp
x
)
(eq
'trs_false
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_issort[a0] (x)
(or
(and
(consp
x
)
(consp
(cdr
x
)
)
(eq
'trs_s
(car
x
)
)
(trs_issort[a0]
(car
(cdr
x
)
)
)
(eq
(cdr
(cdr
x
)
)
'nil
)
)
(and
(consp
x
)
(eq
'trs_0
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_issort[a41] (x)
(or
(and
(consp
x
)
(eq
'trs_witness_sort[a41]
(car
x
)
)
(eq
(cdr
x
)
'nil
)
)
)
)
(defun trs_ge (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_0
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_false
)
(if
(and
)
(trs_ge
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_gt (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_s
)
)
(trs_gt
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_equal_sort[a41] (x0 x1)
(if
(and
(trs_issort[a41]
x0
)
(trs_issort[a41]
x1
)
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(defun trs_equal_sort[a0] (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_s
)
)
(trs_equal_sort[a0]
(car
(cdr
x0
)
)
(car
(cdr
x1
)
)
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(car
x1
)
'trs_0
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_0
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_false
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_isa_false (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_false
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_isa_true (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_not (x0)
(if
(and
(trs_isbool
x0
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_or (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
x1
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_and (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
)
x1
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
(list 'trs_true
)
)
)
(defun trs_equal_bool (x0 x1)
(if
(and
(trs_isbool
x0
)
(trs_isbool
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_false
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_false
)
(eq
(car
x1
)
'trs_true
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_true
)
)
(list 'trs_true
)
(if
(and
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_if (x0 x1 x2)
(if
(and
(trs_isbool
x0
)
(trs_issort[a0]
x1
)
(trs_issort[a0]
x2
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_0
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_s
)
)
(list 'trs_s
(trs_if
(trs_gt
(list 'trs_s
(car
(cdr
x1
)
)
)
x2
)
(car
(cdr
x1
)
)
x2
)
)
(if
(and
)
(list 'trs_s
(list 'trs_0
)
)
(list 'trs_0
)
)
)
)
(list 'trs_0
)
)
)
(defun trs_ifprime (x0 x1 x2)
(if
(and
(trs_isbool
x0
)
(trs_issort[a0]
x1
)
(trs_issort[a0]
x2
)
)
(if
(and
(eq
(car
x0
)
'trs_false
)
)
(list 'trs_true
)
(if
(and
(eq
(car
x0
)
'trs_true
)
(eq
(car
x1
)
'trs_s
)
)
(trs_ifprime
(trs_gt
(list 'trs_s
(car
(cdr
x1
)
)
)
x2
)
(car
(cdr
x1
)
)
x2
)
(if
(and
)
(list 'trs_false
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(defun trs_minus (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_0
)
)
(list 'trs_0
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(list 'trs_s
(trs_minus
(car
(cdr
x0
)
)
x1
)
)
(if
(and
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_false
)
)
)
(list 'trs_0
)
(list 'trs_0
)
)
)
)
(list 'trs_0
)
)
)
(defun trs_minusprime (x0 x1)
(if
(and
(trs_issort[a0]
x0
)
(trs_issort[a0]
x1
)
)
(if
(and
(eq
(car
x0
)
'trs_0
)
)
(list 'trs_false
)
(if
(and
(eq
(car
x0
)
'trs_s
)
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_true
)
)
)
(trs_minusprime
(car
(cdr
x0
)
)
x1
)
(if
(and
(eq
(trs_equal_bool
(trs_gt
(list 'trs_s
(car
(cdr
x0
)
)
)
x1
)
(list 'trs_true
)
)
(list 'trs_false
)
)
)
(list 'trs_true
)
(list 'trs_true
)
)
)
)
(list 'trs_true
)
)
)
(with-prover-time-limit 3
(defthm test
(implies
(and
(trs_issort[a0] trs_z1prime)
(trs_issort[a0] trs_z0prime)
)
(eq
(trs_ifprime
(trs_gt
trs_z1prime
trs_z0prime
)
trs_z1prime
(list 'trs_s
trs_z0prime
)
)
(list 'trs_true
)
)
)
)
)The following output was given by ACL2:
This is SBCL 1.0.29.11.debian, an implementation of ANSI Common Lisp.
More information about SBCL is available at .
SBCL is free software, provided as is, with absolutely no warranty.
It is mostly in the public domain; some portions are provided under
BSD-style licenses. See the CREDITS and COPYING files in the
distribution for more information.
ACL2 Version 3.6 built February 12, 2010 14:59:57.
Copyright (C) 2009 University of Texas at Austin
ACL2 comes with ABSOLUTELY NO WARRANTY. This is free software and you
are welcome to redistribute it under certain conditions. For details,
see the GNU General Public License.
Initialized with (INITIALIZE-ACL2 'INCLUDE-BOOK *ACL2-PASS-2-FILES*).
See the documentation topic note-3-6 for recent changes.
Note: We have modified the prompt in some underlying Lisps to further
distinguish it from the ACL2 prompt.
ACL2 Version 3.6. Level 1. Cbd "/home/petersk/workspace/benchmark/".
Distributed books directory "/home/petersk/download/acl2-sources/books/".
Type :help for help.
Type (good-bye) to quit completely out of ACL2.
ACL2 !> :ALL
ACL2 !>
Since TRS_ISBOOL is non-recursive, its admission is trivial. We observe
that the type of TRS_ISBOOL is described by the theorem
(OR (EQUAL (TRS_ISBOOL X) T) (EQUAL (TRS_ISBOOL X) NIL)). We used
the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISBOOL ...)
Rules: ((:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_ISBOOL
ACL2 !>
For the admission of TRS_ISSORT[A0] we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQ 'TRS_S (CAR X)))
(O< (ACL2-COUNT (CADR X))
(ACL2-COUNT X))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQUAL 'TRS_S (CAR X)))
(O< (ACL2-COUNT (CADR X))
(ACL2-COUNT X))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP and
O<, the :executable-counterpart of ACL2-COUNT, primitive type reasoning,
the :rewrite rule UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT,
to
Goal''
(IMPLIES (AND (CONSP X)
(CONSP (CDR X))
(EQUAL 'TRS_S (CAR X)))
(< (ACL2-COUNT (CADR X))
(+ 1 (ACL2-COUNT (CDR X))))).
The destructor terms (CAR X) and (CDR X) can be eliminated. Furthermore,
those terms are at the root of a chain of two rounds of destructor
elimination. (1) Use CAR-CDR-ELIM to replace X by (CONS X1 X2), (CAR X)
by X1 and (CDR X) by X2 and restrict the type of the new variable X1
to be that of the term it replaces. (2) Use CAR-CDR-ELIM, again, to
replace X2 by (CONS X3 X4), (CAR X2) by X3 and (CDR X2) by X4. These
steps produce the following goal.
Goal'''
(IMPLIES (AND (CONSP (CONS X3 X4))
(SYMBOLP X1)
(NOT (EQUAL X1 T))
(NOT (EQUAL X1 NIL))
(CONSP (LIST* X1 X3 X4))
(EQUAL 'TRS_S X1))
(< (ACL2-COUNT X3)
(+ 1 (ACL2-COUNT (CONS X3 X4))))).
By case analysis we reduce the conjecture to
Goal'4'
(IMPLIES (AND (CONSP (CONS X3 X4))
(SYMBOLP X1)
(NOT (EQUAL X1 T))
X1 (CONSP (LIST* X1 X3 X4))
(EQUAL 'TRS_S X1))
(< (ACL2-COUNT X3)
(+ 1 (ACL2-COUNT (CONS X3 X4))))).
This simplifies, using the :definition ACL2-COUNT, the :executable-
counterparts of EQUAL, NOT and SYMBOLP, primitive type reasoning and
the :rewrite rules CAR-CONS and CDR-CONS, to
Goal'5'
(< (ACL2-COUNT X3)
(+ 1 1 (ACL2-COUNT X3)
(ACL2-COUNT X4))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_ISSORT[A0].
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_ISSORT[A0] is described by the theorem
(OR (EQUAL (TRS_ISSORT[A0] X) T) (EQUAL (TRS_ISSORT[A0] X) NIL)).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISSORT[A0] ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:ELIM CAR-CDR-ELIM)
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART SYMBOLP)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.01, other: 0.00)
TRS_ISSORT[A0]
ACL2 !>
Since TRS_ISSORT[A41] is non-recursive, its admission is trivial.
We observe that the type of TRS_ISSORT[A41] is described by the theorem
(OR (EQUAL (TRS_ISSORT[A41] X) T) (EQUAL (TRS_ISSORT[A41] X) NIL)).
We used primitive type reasoning.
Summary
Form: ( DEFUN TRS_ISSORT[A41] ...)
Rules: ((:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_ISSORT[A41]
ACL2 !>
For the admission of TRS_GE we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X1) 'TRS_0))
(NOT (AND (EQ (CAR X0) 'TRS_0)
(EQ (CAR X1) 'TRS_S)))
T)
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (AND (EQUAL (CAR X0) 'TRS_0)
(EQUAL (CAR X1) 'TRS_S))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(EQUAL 'TRS_S (CAR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X1) 'TRS_0)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_GE. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_GE is described by the theorem
(AND (CONSP (TRS_GE X0 X1)) (TRUE-LISTP (TRS_GE X0 X1))).
Summary
Form: ( DEFUN TRS_GE ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.01, print: 0.00, other: 0.00)
TRS_GE
ACL2 !>
For the admission of TRS_GT we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_0)))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (AND (EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_GT. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_GT is described by the theorem
(AND (CONSP (TRS_GT X0 X1)) (TRUE-LISTP (TRS_GT X0 X1))). We used
primitive type reasoning.
Summary
Form: ( DEFUN TRS_GT ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.01, other: 0.00)
TRS_GT
ACL2 !>
Since TRS_EQUAL_SORT[A41] is non-recursive, its admission is trivial.
We observe that the type of TRS_EQUAL_SORT[A41] is described by the
theorem
(AND (CONSP (TRS_EQUAL_SORT[A41] X0 X1))
(TRUE-LISTP (TRS_EQUAL_SORT[A41] X0 X1))).
Summary
Form: ( DEFUN TRS_EQUAL_SORT[A41] ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_EQUAL_SORT[A41]
ACL2 !>
For the admission of TRS_EQUAL_SORT[A0] we will use the relation O<
(which is known to be well-founded on the domain recognized by O-P)
and the measure (ACL2-COUNT X0). The non-trivial part of the measure
conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_EQUAL_SORT[A0].
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_EQUAL_SORT[A0] is described by the theorem
(AND (CONSP (TRS_EQUAL_SORT[A0] X0 X1))
(TRUE-LISTP (TRS_EQUAL_SORT[A0] X0 X1))).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_EQUAL_SORT[A0] ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.01, other: 0.00)
TRS_EQUAL_SORT[A0]
ACL2 !>
Since TRS_ISA_FALSE is non-recursive, its admission is trivial. We
observe that the type of TRS_ISA_FALSE is described by the theorem
(AND (CONSP (TRS_ISA_FALSE X0)) (TRUE-LISTP (TRS_ISA_FALSE X0))).
Summary
Form: ( DEFUN TRS_ISA_FALSE ...)
Rules: NIL
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_ISA_FALSE
ACL2 !>
Since TRS_ISA_TRUE is non-recursive, its admission is trivial. We
observe that the type of TRS_ISA_TRUE is described by the theorem
(AND (CONSP (TRS_ISA_TRUE X0)) (TRUE-LISTP (TRS_ISA_TRUE X0))).
Summary
Form: ( DEFUN TRS_ISA_TRUE ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_ISA_TRUE
ACL2 !>
Since TRS_NOT is non-recursive, its admission is trivial. We observe
that the type of TRS_NOT is described by the theorem
(AND (CONSP (TRS_NOT X0)) (TRUE-LISTP (TRS_NOT X0))).
Summary
Form: ( DEFUN TRS_NOT ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_NOT
ACL2 !>
Since TRS_OR is non-recursive, its admission is trivial. We observe
that the type of TRS_OR is described by the theorem
(OR (AND (CONSP (TRS_OR X0 X1))
(TRUE-LISTP (TRS_OR X0 X1)))
(EQUAL (TRS_OR X0 X1) X1)).
Summary
Form: ( DEFUN TRS_OR ...)
Rules: NIL
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_OR
ACL2 !>
Since TRS_AND is non-recursive, its admission is trivial. We observe
that the type of TRS_AND is described by the theorem
(OR (AND (CONSP (TRS_AND X0 X1))
(TRUE-LISTP (TRS_AND X0 X1)))
(EQUAL (TRS_AND X0 X1) X1)).
Summary
Form: ( DEFUN TRS_AND ...)
Rules: NIL
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_AND
ACL2 !>
Since TRS_EQUAL_BOOL is non-recursive, its admission is trivial. We
observe that the type of TRS_EQUAL_BOOL is described by the theorem
(AND (CONSP (TRS_EQUAL_BOOL X0 X1)) (TRUE-LISTP (TRS_EQUAL_BOOL X0 X1))).
We used the :executable-counterpart of EQUAL and primitive type reasoning.
Summary
Form: ( DEFUN TRS_EQUAL_BOOL ...)
Rules: ((:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-TYPE-SET NIL))
Warnings: None
Time: 0.00 seconds (prove: 0.00, print: 0.00, other: 0.00)
TRS_EQUAL_BOOL
ACL2 !>
For the admission of TRS_IF we will use the relation O< (which is known
to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X1). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISBOOL X0)
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2))
(NOT (EQ (CAR X0) 'TRS_FALSE))
(AND (EQ (CAR X0) 'TRS_TRUE)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Goal'
(IMPLIES (AND (CONSP X0)
(COND ((EQUAL 'TRS_TRUE (CAR X0))
(EQUAL (CDR X0) NIL))
((EQUAL 'TRS_FALSE (CAR X0))
(EQUAL (CDR X0) NIL))
(T NIL))
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2)
(NOT (EQUAL (CAR X0) 'TRS_FALSE))
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(NOT (CDR X0))
(CONSP X1)
(CONSP (CDR X1))
(TRS_ISSORT[A0] (CADR X1))
(NOT (CDDR X1))
(TRS_ISSORT[A0] X2)
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X1))
(+ 1 1 (ACL2-COUNT (CADR X1))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_IF. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_IF is described by the theorem
(AND (CONSP (TRS_IF X0 X1 X2)) (TRUE-LISTP (TRS_IF X0 X1 X2))). We
used primitive type reasoning.
Summary
Form: ( DEFUN TRS_IF ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.00, other: 0.01)
TRS_IF
ACL2 !>
For the admission of TRS_IFPRIME we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X1). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (AND (TRS_ISBOOL X0)
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2))
(NOT (EQ (CAR X0) 'TRS_FALSE))
(AND (EQ (CAR X0) 'TRS_TRUE)
(EQ (CAR X1) 'TRS_S)))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Goal'
(IMPLIES (AND (CONSP X0)
(COND ((EQUAL 'TRS_TRUE (CAR X0))
(EQUAL (CDR X0) NIL))
((EQUAL 'TRS_FALSE (CAR X0))
(EQUAL (CDR X0) NIL))
(T NIL))
(TRS_ISSORT[A0] X1)
(TRS_ISSORT[A0] X2)
(NOT (EQUAL (CAR X0) 'TRS_FALSE))
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(O< (ACL2-COUNT (CADR X1))
(ACL2-COUNT X1))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<
and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT and
EQUAL, primitive type reasoning, the :rewrite rules COMMUTATIVITY-OF-+
and UNICITY-OF-0 and the :type-prescription rule ACL2-COUNT, to
Goal''
(IMPLIES (AND (CONSP X0)
(NOT (CDR X0))
(CONSP X1)
(CONSP (CDR X1))
(TRS_ISSORT[A0] (CADR X1))
(NOT (CDDR X1))
(TRS_ISSORT[A0] X2)
(EQUAL (CAR X0) 'TRS_TRUE)
(EQUAL (CAR X1) 'TRS_S))
(< (ACL2-COUNT (CADR X1))
(+ 1 1 (ACL2-COUNT (CADR X1))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_IFPRIME. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_IFPRIME is described by the theorem
(AND (CONSP (TRS_IFPRIME X0 X1 X2)) (TRUE-LISTP (TRS_IFPRIME X0 X1 X2))).
Summary
Form: ( DEFUN TRS_IFPRIME ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT))
Warnings: None
Time: 0.01 seconds (prove: 0.00, print: 0.01, other: 0.00)
TRS_IFPRIME
ACL2 !>
For the admission of TRS_MINUS we will use the relation O< (which is
known to be well-founded on the domain recognized by O-P) and the measure
(ACL2-COUNT X0). The non-trivial part of the measure conjecture is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X0) 'TRS_0))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X0) 'TRS_0))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<,
TRS_GT and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT
and EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS, CDR-CONS,
COMMUTATIVITY-OF-+ and UNICITY-OF-0 and the :type-prescription rules
ACL2-COUNT and TRS_ISSORT[A0], to the following three conjectures.
Subgoal 3
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)
(EQUAL (TRS_EQUAL_BOOL '(TRS_TRUE) '(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
By the :executable-counterparts of EQUAL and TRS_EQUAL_BOOL we reduce
the conjecture to
Subgoal 3'
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Subgoal 2
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (EQUAL (CAR X1) 'TRS_S))
(EQUAL (TRS_EQUAL_BOOL '(TRS_FALSE)
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But we reduce the conjecture to T, by the :executable-counterparts
of EQUAL and TRS_EQUAL_BOOL.
Subgoal 1
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (CADR X0) (CADR X1))
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_MINUS. Thus,
we admit this function under the principle of definition. We observe
that the type of TRS_MINUS is described by the theorem
(AND (CONSP (TRS_MINUS X0 X1)) (TRUE-LISTP (TRS_MINUS X0 X1))). We
used primitive type reasoning.
Summary
Form: ( DEFUN TRS_MINUS ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART TRS_EQUAL_BOOL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.02 seconds (prove: 0.01, print: 0.00, other: 0.01)
TRS_MINUS
ACL2 !>
For the admission of TRS_MINUSPRIME we will use the relation O< (which
is known to be well-founded on the domain recognized by O-P) and the
measure (ACL2-COUNT X0). The non-trivial part of the measure conjecture
is
Goal
(IMPLIES (AND (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1))
(NOT (EQ (CAR X0) 'TRS_0))
(AND (EQ (CAR X0) 'TRS_S)
(EQ (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE))))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] X0)
(TRS_ISSORT[A0] X1)
(NOT (EQUAL (CAR X0) 'TRS_0))
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (LIST 'TRS_S (CADR X0)) X1)
'(TRS_TRUE))
'(TRS_TRUE)))
(O< (ACL2-COUNT (CADR X0))
(ACL2-COUNT X0))).
This simplifies, using the :definitions ACL2-COUNT, FIX, O-FINP, O<,
TRS_GT and TRS_ISSORT[A0], the :executable-counterparts of ACL2-COUNT
and EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS, CDR-CONS,
COMMUTATIVITY-OF-+ and UNICITY-OF-0 and the :type-prescription rules
ACL2-COUNT and TRS_ISSORT[A0], to the following three conjectures.
Subgoal 3
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0)
(EQUAL (TRS_EQUAL_BOOL '(TRS_TRUE) '(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
By the :executable-counterparts of EQUAL and TRS_EQUAL_BOOL we reduce
the conjecture to
Subgoal 3'
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_0))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Subgoal 2
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(NOT (EQUAL (CAR X1) 'TRS_0))
(NOT (EQUAL (CAR X1) 'TRS_S))
(EQUAL (TRS_EQUAL_BOOL '(TRS_FALSE)
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But we reduce the conjecture to T, by the :executable-counterparts
of EQUAL and TRS_EQUAL_BOOL.
Subgoal 1
(IMPLIES (AND (CONSP X0)
(CONSP (CDR X0))
(TRS_ISSORT[A0] (CADR X0))
(NOT (CDDR X0))
(TRS_ISSORT[A0] X1)
(EQUAL (CAR X0) 'TRS_S)
(EQUAL (CAR X1) 'TRS_S)
(EQUAL (TRS_EQUAL_BOOL (TRS_GT (CADR X0) (CADR X1))
'(TRS_TRUE))
'(TRS_TRUE)))
(< (ACL2-COUNT (CADR X0))
(+ 1 1 (ACL2-COUNT (CADR X0))))).
But simplification reduces this to T, using linear arithmetic, primitive
type reasoning and the :type-prescription rule ACL2-COUNT.
Q.E.D.
That completes the proof of the measure theorem for TRS_MINUSPRIME.
Thus, we admit this function under the principle of definition. We
observe that the type of TRS_MINUSPRIME is described by the theorem
(AND (CONSP (TRS_MINUSPRIME X0 X1)) (TRUE-LISTP (TRS_MINUSPRIME X0 X1))).
Summary
Form: ( DEFUN TRS_MINUSPRIME ...)
Rules: ((:DEFINITION ACL2-COUNT)
(:DEFINITION EQ)
(:DEFINITION FIX)
(:DEFINITION NOT)
(:DEFINITION O-FINP)
(:DEFINITION O<)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART ACL2-COUNT)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART TRS_EQUAL_BOOL)
(:FAKE-RUNE-FOR-LINEAR NIL)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:REWRITE COMMUTATIVITY-OF-+)
(:REWRITE UNICITY-OF-0)
(:TYPE-PRESCRIPTION ACL2-COUNT)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.02 seconds (prove: 0.01, print: 0.00, other: 0.01)
TRS_MINUSPRIME
ACL2 !>
By the simple :definition EQ we reduce the conjecture to
Goal'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
Name the formula above *1.
Perhaps we can prove *1 by induction. Four induction schemes are suggested
by this conjecture. These merge into one derived induction scheme.
We will induct according to a scheme suggested by
(TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME
(CONS 'TRS_S (CONS TRS_Z0PRIME 'NIL))),
but modified to accommodate (TRS_ISSORT[A0] TRS_Z0PRIME) and
(TRS_GT TRS_Z1PRIME TRS_Z0PRIME). These suggestions were produced
using the :induction rules TRS_GT, TRS_IFPRIME and TRS_ISSORT[A0].
If we let (:P TRS_Z0PRIME TRS_Z1PRIME) denote *1 above then the induction
scheme we'll use is
(AND (IMPLIES (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))))
(:P TRS_Z0PRIME TRS_Z1PRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S)))
T)
(:P TRS_Z0PRIME TRS_Z1PRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S))
(:P (CADR TRS_Z0PRIME)
(CADR TRS_Z1PRIME)))
(:P TRS_Z0PRIME TRS_Z1PRIME))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(:P TRS_Z0PRIME TRS_Z1PRIME))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
Note, however, that the unmeasured variable TRS_Z0PRIME is being instantiated.
When applied to the goal at hand the above induction scheme produces
six nontautological subgoals.
Subgoal *1/6
(IMPLIES (AND (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL and
TRS_ISBOOL, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_ISBOOL and TRS_ISSORT[A0],
to the following two conjectures.
Subgoal *1/6.2
(IMPLIES (AND (EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (CAR TRS_Z0PRIME) 'TRS_0)
(NOT (TRS_ISBOOL '(TRS_TRUE)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
But we reduce the conjecture to T, by the :executable-counterpart of
TRS_ISBOOL.
Subgoal *1/6.1
(IMPLIES (AND (EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (CAR TRS_Z0PRIME) 'TRS_S)
(NOT (TRS_ISBOOL (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(CONSP TRS_Z0PRIME)
(CONSP (CDR TRS_Z0PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIME))
(NOT (CDDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISBOOL, the :executable-counterpart of EQUAL, primitive type
reasoning and the :type-prescription rule TRS_GT.
Subgoal *1/5
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S)))
T (TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/5'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(NOT (AND (EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)))
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP and
EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0].
Subgoal *1/4
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/4'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_ISSORT[A0],
the :executable-counterparts of CAR, CONSP and EQUAL, primitive type
reasoning, the :rewrite rules CAR-CONS and CDR-CONS and the :type-
prescription rules TRS_GT and TRS_ISSORT[A0], to the following ten
conjectures.
Subgoal *1/4.10
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.10'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.10''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.10'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.10'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.10'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.10'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.10.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.1.
Subgoal *1/4.10.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.9
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.9'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.9''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.9'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.9'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.9'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.9'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.9.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.2.
Subgoal *1/4.9.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.8
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(CONSP (CDR TRS_Z0PRIME))
(EQUAL 'TRS_S (CAR TRS_Z0PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z0PRIME))
(NOT (CDDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z0PRIME by (CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME)
by TRS_Z0PRIME1 and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict
the type of the new variable TRS_Z0PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z0PRIME2 by
(CONS TRS_Z0PRIME3 TRS_Z0PRIME4), (CAR TRS_Z0PRIME2) by TRS_Z0PRIME3
and (CDR TRS_Z0PRIME2) by TRS_Z0PRIME4. These steps produce the
following goal.
Subgoal *1/4.8'
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIME3 TRS_Z0PRIME4))
(SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (LIST* TRS_Z0PRIME1 TRS_Z0PRIME3 TRS_Z0PRIME4))
(NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
(CADR TRS_Z1PRIME)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(EQUAL 'TRS_S TRS_Z0PRIME1)
(TRS_ISSORT[A0] TRS_Z0PRIME3)
(NOT TRS_Z0PRIME4))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
TRS_Z1PRIME
(LIST 'TRS_S
(LIST* TRS_Z0PRIME1
TRS_Z0PRIME3 TRS_Z0PRIME4)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8''
(IMPLIES (AND (CONSP (CONS TRS_Z0PRIME3 TRS_Z0PRIME4))
(SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (LIST* TRS_Z0PRIME1 TRS_Z0PRIME3 TRS_Z0PRIME4))
(NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
(CADR TRS_Z1PRIME)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(EQUAL 'TRS_S TRS_Z0PRIME1)
(TRS_ISSORT[A0] TRS_Z0PRIME3)
(NOT TRS_Z0PRIME4))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
TRS_Z1PRIME
(LIST 'TRS_S
(LIST* TRS_Z0PRIME1
TRS_Z0PRIME3 TRS_Z0PRIME4)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of EQUAL, NOT and
SYMBOLP and primitive type reasoning, to
Subgoal *1/4.8'''
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME)
TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
(CADR TRS_Z1PRIME)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME) TRS_Z0PRIME3)
TRS_Z1PRIME
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.8'4'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(NOT (CDR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL TRS_Z1PRIME1 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(NOT (CDR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL TRS_Z1PRIME1 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME, TRS_ISBOOL
and TRS_ISSORT[A0], the :executable-counterparts of EQUAL, NOT and
SYMBOLP, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_GT and TRS_ISSORT[A0],
to
Subgoal *1/4.8'6'
(IMPLIES (AND (NOT (CDR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
We generalize this conjecture, replacing (TRS_GT TRS_Z1PRIME3 TRS_Z0PRIME3)
by L and restricting the type of the new variable L to be that of the
term it replaces, as established by TRS_GT. This produces
Subgoal *1/4.8'7'
(IMPLIES (AND (CONSP L)
(TRUE-LISTP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR L) 'TRS_TRUE)
(EQUAL (TRS_IFPRIME L
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definition TRUE-LISTP and the :executable-
counterpart of TRUE-LISTP, to
Subgoal *1/4.8'8'
(IMPLIES (AND (CONSP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR L) 'TRS_TRUE)
(EQUAL (TRS_IFPRIME L
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR L) and (CDR L) can be eliminated by using
CAR-CDR-ELIM to replace L by (CONS L1 L2), (CAR L) by L1 and (CDR L)
by L2 and restrict the type of the new variable L1 to be that of the
term it replaces. This produces the following goal.
Subgoal *1/4.8'9'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
(NOT (EQUAL L1 NIL))
(CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL L1 'TRS_TRUE)
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.8'10'
(IMPLIES (AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
L1 (CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL L1 'TRS_TRUE)
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.8'11'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
Name the formula above *1.3.
Subgoal *1/4.7
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.7'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.7''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.7'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.7'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.7'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.7'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.7.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.4.
Subgoal *1/4.7.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.6
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIME)))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.6'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.6''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.6'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.6'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.6'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.6'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.6.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.5.
Subgoal *1/4.6.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.5
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z0PRIME) 'TRS_0)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CDR, CONS, CONSP, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0],
to
Subgoal *1/4.5'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z0PRIME) 'TRS_0)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.5''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL TRS_Z0PRIME1 'TRS_0)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.5'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL TRS_Z0PRIME1 'TRS_0)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.5'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.5'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.5'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.5.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.6.
Subgoal *1/4.5.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.4
(IMPLIES (AND (NOT (CONSP (CDR TRS_Z0PRIME)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.4''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.4'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.4'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.4'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.4'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.4.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.7.
Subgoal *1/4.4.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.3
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.3'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.3''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.3'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.3'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.3'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.3'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.3.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.8.
Subgoal *1/4.3.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.2
(IMPLIES (AND (EQUAL (CAR TRS_Z0PRIME) 'TRS_0)
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.2'
(IMPLIES (AND (EQUAL (CAR TRS_Z0PRIME) 'TRS_0)
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.2''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(EQUAL TRS_Z0PRIME1 'TRS_0)
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.2'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(EQUAL TRS_Z0PRIME1 'TRS_0)
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.2'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.2'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.2'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.2.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.9.
Subgoal *1/4.2.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/4.1
(IMPLIES (AND (NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIME)))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME)
(CADR TRS_Z0PRIME))
(CADR TRS_Z1PRIME)
(LIST 'TRS_S (CADR TRS_Z0PRIME)))
'(TRS_TRUE))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_IFPRIME, the
:executable-counterparts of CAR, CONS, CONSP, EQUAL, TRS_ISBOOL and
TRS_ISSORT[A0] and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1/4.1'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/4.1''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.1'''
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/4.1'4'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/4.1'5'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/4.1'6'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/4.1.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.10.
Subgoal *1/4.1.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/3
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIME)))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/3'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIME)))
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT and TRS_ISSORT[A0],
the :executable-counterparts of CAR, CDR, CONSP and EQUAL, primitive
type reasoning, the :rewrite rules CAR-CONS and CDR-CONS and the :type-
prescription rule TRS_ISSORT[A0], to
Subgoal *1/3''
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z0PRIME)))
(CONSP TRS_Z0PRIME)
(NOT (CONSP (CDR TRS_Z0PRIME)))
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CAR, CONSP and
TRS_ISSORT[A0], to
Subgoal *1/3'''
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(CONSP TRS_Z0PRIME)
(EQUAL 'TRS_0 (CAR TRS_Z0PRIME))
(NOT (CDR TRS_Z0PRIME)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z0PRIME) and (CDR TRS_Z0PRIME) can be
eliminated by using CAR-CDR-ELIM to replace TRS_Z0PRIME by
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2), (CAR TRS_Z0PRIME) by TRS_Z0PRIME1
and (CDR TRS_Z0PRIME) by TRS_Z0PRIME2 and restrict the type of the
new variable TRS_Z0PRIME1 to be that of the term it replaces. This
produces the following goal.
Subgoal *1/3'4'
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
(NOT (EQUAL TRS_Z0PRIME1 NIL))
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/3'5'
(IMPLIES (AND (SYMBOLP TRS_Z0PRIME1)
(NOT (EQUAL TRS_Z0PRIME1 T))
TRS_Z0PRIME1
(CONSP (CONS TRS_Z0PRIME1 TRS_Z0PRIME2))
(CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(EQUAL 'TRS_0 TRS_Z0PRIME1)
(NOT TRS_Z0PRIME2))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME
(LIST 'TRS_S
(CONS TRS_Z0PRIME1 TRS_Z0PRIME2)))
'(TRS_TRUE))).
This simplifies, using the :executable-counterparts of CONS, CONSP,
EQUAL, NOT and SYMBOLP, to
Subgoal *1/3'6'
(IMPLIES (AND (CONSP TRS_Z1PRIME)
(CONSP (CDR TRS_Z1PRIME))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME))
(NOT (CDDR TRS_Z1PRIME))
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME '(TRS_S (TRS_0)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME) and (CDR TRS_Z1PRIME) can be
eliminated. Furthermore, those terms are at the root of a chain of
two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME by (CONS TRS_Z1PRIME1 TRS_Z1PRIME2), (CAR TRS_Z1PRIME)
by TRS_Z1PRIME1 and (CDR TRS_Z1PRIME) by TRS_Z1PRIME2 and restrict
the type of the new variable TRS_Z1PRIME1 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME2 by
(CONS TRS_Z1PRIME3 TRS_Z1PRIME4), (CAR TRS_Z1PRIME2) by TRS_Z1PRIME3
and (CDR TRS_Z1PRIME2) by TRS_Z1PRIME4. These steps produce the
following goal.
Subgoal *1/3'7'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
(NOT (EQUAL TRS_Z1PRIME1 NIL))
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1/3'8'
(IMPLIES (AND (CONSP (CONS TRS_Z1PRIME3 TRS_Z1PRIME4))
(SYMBOLP TRS_Z1PRIME1)
(NOT (EQUAL TRS_Z1PRIME1 T))
TRS_Z1PRIME1
(CONSP (LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT TRS_Z1PRIME4)
(EQUAL TRS_Z1PRIME1 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(LIST* TRS_Z1PRIME1 TRS_Z1PRIME3 TRS_Z1PRIME4)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, NOT,
SYMBOLP, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rule
TRS_ISSORT[A0], to the following two conjectures.
Subgoal *1/3.2
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Name the formula above *1.11.
Subgoal *1/3.1
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(NOT (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1/2
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME)))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/2'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME)))
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0] and the :executable-counterparts of CDR, CONSP and
EQUAL.
Subgoal *1/1
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME)))
(EQ (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1/1'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME)
(TRS_ISSORT[A0] (LIST 'TRS_S TRS_Z0PRIME))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME TRS_Z0PRIME))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z0PRIME))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME TRS_Z0PRIME)
TRS_Z1PRIME (LIST 'TRS_S TRS_Z0PRIME))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, CONSP, EQUAL and TRS_ISBOOL, primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rules
TRS_GT and TRS_ISSORT[A0].
So we now return to *1.11, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.10, which we'll try to prove
later. We therefore regard *1.11 as proved (pending the proof of the
more general *1.10).
We next consider *1.10, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.9, which we'll try to prove
later. We therefore regard *1.10 as proved (pending the proof of the
more general *1.9).
We next consider *1.9, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.8, which we'll try to prove
later. We therefore regard *1.9 as proved (pending the proof of the
more general *1.8).
We next consider *1.8, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.7, which we'll try to prove
later. We therefore regard *1.8 as proved (pending the proof of the
more general *1.7).
We next consider *1.7, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.6, which we'll try to prove
later. We therefore regard *1.7 as proved (pending the proof of the
more general *1.6).
We next consider *1.6, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.5, which we'll try to prove
later. We therefore regard *1.6 as proved (pending the proof of the
more general *1.5).
We next consider *1.5, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.4, which we'll try to prove
later. We therefore regard *1.5 as proved (pending the proof of the
more general *1.4).
We next consider *1.4, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.2, which we'll try to prove
later. We therefore regard *1.4 as proved (pending the proof of the
more general *1.2).
We next consider *1.3, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
Perhaps we can prove *1.3 by induction. Five induction schemes are
suggested by this conjecture. These merge into two derived induction
schemes. By considering those suggested by the largest number of non-
primitive recursive functions, we narrow the field to one.
We will induct according to a scheme suggested by
(TRS_IFPRIME (TRS_GT TRS_Z1PRIME3
(CONS 'TRS_S (CONS TRS_Z0PRIME3 'NIL)))
TRS_Z1PRIME3
(CONS 'TRS_S
(CONS (CONS 'TRS_S (CONS TRS_Z0PRIME3 'NIL))
'NIL))).
This suggestion was produced using the :induction rules TRS_GT,
TRS_IFPRIME and TRS_ISSORT[A0]. If we let (:P TRS_Z0PRIME3 TRS_Z1PRIME3)
denote *1.3 above then the induction scheme we'll use is
(AND (IMPLIES (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))))
(:P TRS_Z0PRIME3 TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S)))
T)
(:P TRS_Z0PRIME3 TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(:P TRS_Z0PRIME3 (CADR TRS_Z1PRIME3)))
(:P TRS_Z0PRIME3 TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(:P TRS_Z0PRIME3 TRS_Z1PRIME3))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
When applied to the goal at hand the above induction scheme produces
six nontautological subgoals.
Subgoal *1.3/6
(IMPLIES (AND (NOT (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL and
TRS_ISBOOL, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_ISBOOL and TRS_ISSORT[A0],
to
Subgoal *1.3/6'
(IMPLIES (AND (EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (TRS_ISBOOL (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)))
(CONSP TRS_Z1PRIME3)
(CONSP (CDR TRS_Z1PRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME3))
(NOT (CDDR TRS_Z1PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISBOOL, the :executable-counterpart of EQUAL, primitive type
reasoning and the :type-prescription rule TRS_GT.
Subgoal *1.3/5
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(NOT (AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S)))
T (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/5'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(NOT (AND (EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP and
EQUAL, primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0].
Subgoal *1.3/4
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/4'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, EQUAL and TRS_ISBOOL, primitive type reasoning, the :rewrite
rules CAR-CONS and CDR-CONS and the :type-prescription rules TRS_GT
and TRS_ISSORT[A0].
Subgoal *1.3/3
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/3'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, EQUAL and TRS_ISBOOL,
primitive type reasoning, the :rewrite rules CAR-CONS and CDR-CONS
and the :type-prescription rules TRS_GT and TRS_ISSORT[A0], to
Subgoal *1.3/3''
(IMPLIES (AND (NOT (CDR (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)))
(CONSP TRS_Z1PRIME3)
(CONSP (CDR TRS_Z1PRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME3))
(NOT (CDDR TRS_Z1PRIME3))
(EQUAL (CAR (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)
(CADR TRS_Z1PRIME3)
(LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT (CADR TRS_Z1PRIME3)
TRS_Z0PRIME3)
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR TRS_Z1PRIME3) and (CDR TRS_Z1PRIME3) can
be eliminated. Furthermore, those terms are at the root of a chain
of two rounds of destructor elimination. (1) Use CAR-CDR-ELIM to replace
TRS_Z1PRIME3 by (CONS TRS_Z1PRIME4 TRS_Z1PRIME5), (CAR TRS_Z1PRIME3)
by TRS_Z1PRIME4 and (CDR TRS_Z1PRIME3) by TRS_Z1PRIME5 and restrict
the type of the new variable TRS_Z1PRIME4 to be that of the term it
replaces. (2) Use CAR-CDR-ELIM, again, to replace TRS_Z1PRIME5 by
(CONS TRS_Z1PRIME6 TRS_Z1PRIME7), (CAR TRS_Z1PRIME5) by TRS_Z1PRIME6
and (CDR TRS_Z1PRIME5) by TRS_Z1PRIME7. These steps produce the
following goal.
Subgoal *1.3/3'''
(IMPLIES
(AND (CONSP (CONS TRS_Z1PRIME6 TRS_Z1PRIME7))
(SYMBOLP TRS_Z1PRIME4)
(NOT (EQUAL TRS_Z1PRIME4 T))
(NOT (EQUAL TRS_Z1PRIME4 NIL))
(CONSP (LIST* TRS_Z1PRIME4 TRS_Z1PRIME6 TRS_Z1PRIME7))
(NOT (CDR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(NOT TRS_Z1PRIME7)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL TRS_Z1PRIME4 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
(LIST* TRS_Z1PRIME4 TRS_Z1PRIME6 TRS_Z1PRIME7)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1.3/3'4'
(IMPLIES
(AND (CONSP (CONS TRS_Z1PRIME6 TRS_Z1PRIME7))
(SYMBOLP TRS_Z1PRIME4)
(NOT (EQUAL TRS_Z1PRIME4 T))
TRS_Z1PRIME4
(CONSP (LIST* TRS_Z1PRIME4 TRS_Z1PRIME6 TRS_Z1PRIME7))
(NOT (CDR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(NOT TRS_Z1PRIME7)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3))
'TRS_TRUE)
(EQUAL TRS_Z1PRIME4 'TRS_S)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
(LIST* TRS_Z1PRIME4 TRS_Z1PRIME6 TRS_Z1PRIME7)
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME, TRS_ISBOOL
and TRS_ISSORT[A0], the :executable-counterparts of EQUAL, NOT and
SYMBOLP, primitive type reasoning, the :rewrite rules CAR-CONS and
CDR-CONS and the :type-prescription rules TRS_GT and TRS_ISSORT[A0],
to
Subgoal *1.3/3'5'
(IMPLIES
(AND (NOT (CDR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(EQUAL (CAR (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3))
'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
We generalize this conjecture, replacing (TRS_GT TRS_Z1PRIME6 TRS_Z0PRIME3)
by L and restricting the type of the new variable L to be that of the
term it replaces, as established by TRS_GT. This produces
Subgoal *1.3/3'6'
(IMPLIES
(AND (CONSP L)
(TRUE-LISTP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(EQUAL (CAR L) 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME L
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
This simplifies, using the :definition TRUE-LISTP and the :executable-
counterpart of TRUE-LISTP, to
Subgoal *1.3/3'7'
(IMPLIES
(AND (CONSP L)
(NOT (CDR L))
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(EQUAL (CAR L) 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME L
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
The destructor terms (CAR L) and (CDR L) can be eliminated by using
CAR-CDR-ELIM to replace L by (CONS L1 L2), (CAR L) by L1 and (CDR L)
by L2 and restrict the type of the new variable L1 to be that of the
term it replaces. This produces the following goal.
Subgoal *1.3/3'8'
(IMPLIES
(AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
(NOT (EQUAL L1 NIL))
(CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(EQUAL L1 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By case analysis we reduce the conjecture to
Subgoal *1.3/3'9'
(IMPLIES
(AND (SYMBOLP L1)
(NOT (EQUAL L1 T))
L1 (CONSP (CONS L1 L2))
(NOT L2)
(TRS_ISSORT[A0] TRS_Z1PRIME6)
(EQUAL L1 'TRS_TRUE)
(NOT (EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME (CONS L1 L2)
TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME6 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME6
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :executable-counterparts
of CONS, CONSP, EQUAL, NOT and SYMBOLP.
Subgoal *1.3/2
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(NOT (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(AND (EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/2'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
(NOT (EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_TRUE)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME3)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT
and TRS_ISSORT[A0] and the :executable-counterparts of CDR, CONSP and
EQUAL.
Subgoal *1.3/1
(IMPLIES (AND (AND (TRS_ISBOOL (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQ (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE)
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
By the simple :definitions EQ and TRS_ISBOOL we reduce the conjecture
to
Subgoal *1.3/1'
(IMPLIES (AND (CONSP (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
(COND ((EQUAL 'TRS_TRUE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
((EQUAL 'TRS_FALSE
(CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3))))
(EQUAL (CDR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
NIL))
(T NIL))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] (LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
(EQUAL (CAR (TRS_GT TRS_Z1PRIME3
(LIST 'TRS_S TRS_Z0PRIME3)))
'TRS_FALSE)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z0PRIME3))
(EQUAL (TRS_IFPRIME (TRS_GT TRS_Z1PRIME3 (LIST 'TRS_S TRS_Z0PRIME3))
TRS_Z1PRIME3
(LIST 'TRS_S
(LIST 'TRS_S TRS_Z0PRIME3)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME, TRS_ISBOOL and TRS_ISSORT[A0], the :executable-counterparts
of CAR, CONSP, EQUAL and TRS_ISBOOL, primitive type reasoning, the
:rewrite rules CAR-CONS and CDR-CONS and the :type-prescription rules
TRS_GT and TRS_ISSORT[A0].
That completes the proof of *1.3.
We therefore turn our attention to *1.2, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But the formula above is subsumed by *1.1, which we'll try to prove
later. We therefore regard *1.2 as proved (pending the proof of the
more general *1.1).
We next consider *1.1, which is
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
Perhaps we can prove *1.1 by induction. Two induction schemes are
suggested by this conjecture. These merge into one derived induction
scheme.
We will induct according to a scheme suggested by
(TRS_IFPRIME '(TRS_TRUE) TRS_Z1PRIME3 '(TRS_S (TRS_0))). This suggestion
was produced using the :induction rules TRS_IFPRIME and TRS_ISSORT[A0].
If we let (:P TRS_Z1PRIME3) denote *1.1 above then the induction scheme
we'll use is
(AND (IMPLIES (NOT (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0)))))
(:P TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(NOT (AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S)))
T)
(:P TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(:P (CADR TRS_Z1PRIME3)))
(:P TRS_Z1PRIME3))
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(EQ 'TRS_TRUE 'TRS_FALSE))
(:P TRS_Z1PRIME3))).
This induction is justified by the same argument used to admit TRS_IFPRIME.
When applied to the goal at hand the above induction scheme produces
four nontautological subgoals.
Subgoal *1.1/4
(IMPLIES (AND (NOT (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0)))))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But we reduce the conjecture to T, by the :executable-counterparts
of TRS_ISBOOL and TRS_ISSORT[A0].
Subgoal *1.1/3
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/3'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
This simplifies, using the :definitions TRS_GT, TRS_IFPRIME and
TRS_ISSORT[A0], the :executable-counterparts of CAR, CDR, EQUAL, TRS_ISBOOL
and TRS_ISSORT[A0], primitive type reasoning, the :rewrite rules CAR-CONS
and CDR-CONS and the :type-prescription rule TRS_ISSORT[A0], to
Subgoal *1.1/3''
(IMPLIES (AND (CONSP TRS_Z1PRIME3)
(CONSP (CDR TRS_Z1PRIME3))
(TRS_ISSORT[A0] (CADR TRS_Z1PRIME3))
(NOT (CDDR TRS_Z1PRIME3))
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
(CADR TRS_Z1PRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))
(NOT (EQUAL (CAADR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_FALSE)
(CADR TRS_Z1PRIME3)
'(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_IFPRIME
and TRS_ISSORT[A0], the :executable-counterparts of CAR, CONSP, EQUAL,
TRS_ISBOOL and TRS_ISSORT[A0] and primitive type reasoning.
Subgoal *1.1/2
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(NOT (EQUAL (CAADR TRS_Z1PRIME3) 'TRS_S))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/2'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (EQUAL (CAADR TRS_Z1PRIME3) 'TRS_S)))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definitions TRS_GT,
TRS_IFPRIME and TRS_ISSORT[A0], the :executable-counterparts of CAR,
CDR, EQUAL, TRS_ISBOOL and TRS_ISSORT[A0], primitive type reasoning,
the :rewrite rules CAR-CONS and CDR-CONS and the :type-prescription
rule TRS_ISSORT[A0].
Subgoal *1.1/1
(IMPLIES (AND (AND (TRS_ISBOOL '(TRS_TRUE))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(TRS_ISSORT[A0] '(TRS_S (TRS_0))))
(NOT (EQ 'TRS_TRUE 'TRS_FALSE))
(AND (EQ 'TRS_TRUE 'TRS_TRUE)
(EQ (CAR TRS_Z1PRIME3) 'TRS_S))
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME3)))
(TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
By the simple :definition EQ and the :executable-counterparts of EQ,
TRS_ISBOOL and TRS_ISSORT[A0] we reduce the conjecture to
Subgoal *1.1/1'
(IMPLIES (AND (TRS_ISSORT[A0] TRS_Z1PRIME3)
(EQUAL (CAR TRS_Z1PRIME3) 'TRS_S)
(NOT (TRS_ISSORT[A0] (CADR TRS_Z1PRIME3))))
(EQUAL (TRS_IFPRIME '(TRS_TRUE)
TRS_Z1PRIME3 '(TRS_S (TRS_0)))
'(TRS_TRUE))).
But simplification reduces this to T, using the :definition TRS_ISSORT[A0]
and the :executable-counterpart of EQUAL.
That completes the proofs of *1.1 and *1.
Q.E.D.
Summary
Form: ( DEFTHM TEST ...)
Rules: ((:DEFINITION EQ)
(:DEFINITION NOT)
(:DEFINITION TRS_GT)
(:DEFINITION TRS_IFPRIME)
(:DEFINITION TRS_ISBOOL)
(:DEFINITION TRS_ISSORT[A0])
(:DEFINITION TRUE-LISTP)
(:ELIM CAR-CDR-ELIM)
(:EXECUTABLE-COUNTERPART CAR)
(:EXECUTABLE-COUNTERPART CDR)
(:EXECUTABLE-COUNTERPART CONS)
(:EXECUTABLE-COUNTERPART CONSP)
(:EXECUTABLE-COUNTERPART EQ)
(:EXECUTABLE-COUNTERPART EQUAL)
(:EXECUTABLE-COUNTERPART NOT)
(:EXECUTABLE-COUNTERPART SYMBOLP)
(:EXECUTABLE-COUNTERPART TRS_ISBOOL)
(:EXECUTABLE-COUNTERPART TRS_ISSORT[A0])
(:EXECUTABLE-COUNTERPART TRUE-LISTP)
(:FAKE-RUNE-FOR-TYPE-SET NIL)
(:INDUCTION TRS_GT)
(:INDUCTION TRS_IFPRIME)
(:INDUCTION TRS_ISSORT[A0])
(:REWRITE CAR-CONS)
(:REWRITE CDR-CONS)
(:TYPE-PRESCRIPTION TRS_GT)
(:TYPE-PRESCRIPTION TRS_ISBOOL)
(:TYPE-PRESCRIPTION TRS_ISSORT[A0]))
Warnings: None
Time: 0.41 seconds (prove: 0.35, print: 0.06, other: 0.00)
TEST
ACL2 !>Bye.
(65) Complex Obligation (AND)
(66) Obligation:
Q DP problem:
The TRS P consists of the following rules:
IF1(false, s(z0), s(z1)) → IF3(true, s(z0), s(z1))
GCD(s(x0), s(x1)) → IF1(ge(x0, x1), s(x0), s(x1))
The TRS R consists of the following rules:
minus(s(x), y) → if(gt(s(x), y), x, y)
gt(s(x), 0) → true
gt(s(x), s(y)) → gt(x, y)
if(true, x, y) → s(minus(x, y))
if(false, x, y) → 0
gt(0, y) → false
ge(x, 0) → true
ge(0, s(x)) → false
ge(s(x), s(y)) → ge(x, y)
The set Q consists of the following terms:
minus(s(x0), x1)
if(true, x0, x1)
if(false, x0, x1)
gt(0, x0)
gt(s(x0), 0)
gt(s(x0), s(x1))
ge(x0, 0)
ge(0, s(x0))
ge(s(x0), s(x1))
We have to consider all minimal (P,Q,R)-chains.
(67) DependencyGraphProof (EQUIVALENT transformation)
The approximation of the Dependency Graph [LPAR04,FROCOS05,EDGSTAR] contains 0 SCCs with 2 less nodes.
(68) TRUE
(69) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
minus'(s(x5), y3) → if'(gt(s(x5), y3), x5, y3)
if'(true, x24, y17) → minus'(x24, y17)
if'(false, x33, y24) → true
minus'(0, x1) → false
gt(s(x), 0) → true
minus(s(x5), y3) → if(gt(s(x5), y3), x5, y3)
gt(s(x15), s(y10)) → gt(x15, y10)
if(true, x24, y17) → s(minus(x24, y17))
if(false, x33, y24) → 0
gt(0, y31) → false
ge(x50, 0) → true
ge(0, s(x59)) → false
ge(s(x68), s(y50)) → ge(x68, y50)
minus(0, x1) → 0
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](0, 0) → true
equal_sort[a41](witness_sort[a41], witness_sort[a41]) → true
Q is empty.
(70) QTRSRRRProof (EQUIVALENT transformation)
Used ordering:
Combined order from the following AFS and order.
minus'(
x1,
x2) =
minus'(
x1,
x2)
s(
x1) =
s(
x1)
if'(
x1,
x2,
x3) =
if'(
x1,
x2,
x3)
gt(
x1,
x2) =
gt(
x1,
x2)
true =
true
false =
false
0 =
0
minus(
x1,
x2) =
minus(
x1,
x2)
if(
x1,
x2,
x3) =
if(
x1,
x2,
x3)
ge(
x1,
x2) =
ge(
x1,
x2)
equal_bool(
x1,
x2) =
equal_bool(
x1,
x2)
and(
x1,
x2) =
and(
x1,
x2)
or(
x1,
x2) =
or(
x1,
x2)
not(
x1) =
x1
isa_true(
x1) =
x1
isa_false(
x1) =
isa_false(
x1)
equal_sort[a0](
x1,
x2) =
equal_sort[a0](
x1,
x2)
equal_sort[a41](
x1,
x2) =
equal_sort[a41](
x1,
x2)
witness_sort[a41] =
witness_sort[a41]
Recursive path order with status [RPO].
Quasi-Precedence:
[true, false, 0, and2, equalsort[a41]2] > [minus2, if3] > s1 > [minus'2, if'3] > gt2
ge2 > gt2
equalbool2 > gt2
or2 > gt2
isafalse1 > gt2
equalsort[a0]2 > gt2
witnesssort[a41] > gt2
Status:
minus'2: [1,2]
s1: multiset
if'3: [2,3,1]
gt2: [1,2]
true: multiset
false: multiset
0: multiset
minus2: [1,2]
if3: [2,3,1]
ge2: [2,1]
equalbool2: multiset
and2: multiset
or2: multiset
isafalse1: multiset
equalsort[a0]2: [2,1]
equalsort[a41]2: [1,2]
witnesssort[a41]: multiset
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:
minus'(s(x5), y3) → if'(gt(s(x5), y3), x5, y3)
if'(true, x24, y17) → minus'(x24, y17)
if'(false, x33, y24) → true
minus'(0, x1) → false
gt(s(x), 0) → true
minus(s(x5), y3) → if(gt(s(x5), y3), x5, y3)
gt(s(x15), s(y10)) → gt(x15, y10)
if(true, x24, y17) → s(minus(x24, y17))
if(false, x33, y24) → 0
gt(0, y31) → false
ge(x50, 0) → true
ge(0, s(x59)) → false
ge(s(x68), s(y50)) → ge(x68, y50)
minus(0, x1) → 0
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](0, 0) → true
equal_sort[a41](witness_sort[a41], witness_sort[a41]) → true
(71) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
Q is empty.
(72) QTRSRRRProof (EQUIVALENT transformation)
Used ordering:
Polynomial interpretation [POLO]:
POL(false) = 1
POL(isa_true(x1)) = 2 + 2·x1
POL(not(x1)) = 2 + 2·x1
POL(true) = 1
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
(73) Obligation:
Q restricted rewrite system:
R is empty.
Q is empty.
(74) RisEmptyProof (EQUIVALENT transformation)
The TRS R is empty. Hence, termination is trivially proven.
(75) YES
(76) Obligation:
Q restricted rewrite system:
The TRS R consists of the following rules:
minus'(s(x5), y3) → if'(gt(s(x5), y3), x5, y3)
if'(true, x24, y17) → minus'(x24, y17)
if'(false, x33, y24) → true
minus'(0, x1) → false
gt(s(x), 0) → true
minus(s(x5), y3) → if(gt(s(x5), y3), x5, y3)
gt(s(x15), s(y10)) → gt(x15, y10)
if(true, x24, y17) → s(minus(x24, y17))
if(false, x33, y24) → 0
gt(0, y31) → false
ge(x50, 0) → true
ge(0, s(x59)) → false
ge(s(x68), s(y50)) → ge(x68, y50)
minus(0, x1) → 0
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](0, 0) → true
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true
Q is empty.
(77) QTRSRRRProof (EQUIVALENT transformation)
Used ordering:
Recursive path order with status [RPO].
Quasi-Precedence:
[false, 0, equalbool2, not1, isafalse1] > true > [minus2, if3] > s1 > [minus'2, if'3] > gt2
[false, 0, equalbool2, not1, isafalse1] > true > [minus2, if3] > s1 > ge2 > gt2
and2 > gt2
or2 > gt2
isatrue1 > gt2
equalsort[a0]2 > true > [minus2, if3] > s1 > [minus'2, if'3] > gt2
equalsort[a0]2 > true > [minus2, if3] > s1 > ge2 > gt2
equalsort[a44]2 > gt2
witnesssort[a44] > true > [minus2, if3] > s1 > [minus'2, if'3] > gt2
witnesssort[a44] > true > [minus2, if3] > s1 > ge2 > gt2
Status:
minus'2: [1,2]
s1: multiset
if'3: [2,3,1]
gt2: [2,1]
true: multiset
false: multiset
0: multiset
minus2: [2,1]
if3: [3,2,1]
ge2: [2,1]
equalbool2: multiset
and2: multiset
or2: [2,1]
not1: [1]
isatrue1: [1]
isafalse1: [1]
equalsort[a0]2: [1,2]
equalsort[a44]2: [2,1]
witnesssort[a44]: multiset
With this ordering the following rules can be removed by the rule removal processor [LPAR04] because they are oriented strictly:
minus'(s(x5), y3) → if'(gt(s(x5), y3), x5, y3)
if'(true, x24, y17) → minus'(x24, y17)
if'(false, x33, y24) → true
minus'(0, x1) → false
gt(s(x), 0) → true
minus(s(x5), y3) → if(gt(s(x5), y3), x5, y3)
gt(s(x15), s(y10)) → gt(x15, y10)
if(true, x24, y17) → s(minus(x24, y17))
if(false, x33, y24) → 0
gt(0, y31) → false
ge(x50, 0) → true
ge(0, s(x59)) → false
ge(s(x68), s(y50)) → ge(x68, y50)
minus(0, x1) → 0
equal_bool(true, false) → false
equal_bool(false, true) → false
equal_bool(true, true) → true
equal_bool(false, false) → true
and(true, x) → x
and(false, x) → false
or(true, x) → true
or(false, x) → x
not(false) → true
not(true) → false
isa_true(true) → true
isa_true(false) → false
isa_false(true) → false
isa_false(false) → true
equal_sort[a0](s(x0), s(x1)) → equal_sort[a0](x0, x1)
equal_sort[a0](s(x0), 0) → false
equal_sort[a0](0, s(x0)) → false
equal_sort[a0](0, 0) → true
equal_sort[a44](witness_sort[a44], witness_sort[a44]) → true
(78) Obligation:
Q restricted rewrite system:
R is empty.
Q is empty.
(79) RisEmptyProof (EQUIVALENT transformation)
The TRS R is empty. Hence, termination is trivially proven.
(80) YES